Rust के साथ GraphQL API: व्यावहारिक चरण-दर-चरण ट्यूटोरियल

Rust के साथ GraphQL API: व्यावहारिक चरण-दर-चरण ट्यूटोरियल

GraphQL API के लिए एक शक्तिशाली क्वेरी भाषा है जो क्लाइंट को केवल वही डेटा मांगने की अनुमति देती है जिसकी उन्हें आवश्यकता है। Rust की प्रदर्शन क्षमता और सुरक्षा के साथ मिलकर, आपको उच्च-लोड वेब सेवाओं के लिए एक आदर्श समाधान मिलता है। इस ट्यूटोरियल में, हम async-graphql क्रेट का उपयोग करके शुरू से एक पूर्ण GraphQL API बनाएंगे।

Rust क्यों? यह शून्य-लागत एब्स्ट्रैक्शन, मेमोरी सुरक्षा और अद्भुत गति प्रदान करता है। Rust पर GraphQL, JavaScript या Python पर बने समकक्षों की तुलना में तेज़ चलता है, जो प्रोडक्शन सिस्टम के लिए महत्वपूर्ण है।

1. प्रोजेक्ट सेटअप और निर्भरताएँ

एक नया Rust प्रोजेक्ट बनाकर शुरू करें। टर्मिनल खोलें और निम्नलिखित चलाएँ:

cargo new graphql_rust_apicd graphql_rust_api

अब Cargo.toml फ़ाइल में आवश्यक निर्भरताएँ जोड़ें:

[dependencies]async-graphql = "7.0"async-graphql-actix-web = "7.0"actix-web = "4"actix-cors = "0.7"serde = { version = "1.0", features = ["derive"] }tokio = { version = "1", features = ["full"] }

ये क्रेट सब कुछ प्रदान करते हैं: async-graphql — GraphQL कोर, actix-web — वेब सर्वर, serde — डेटा सीरियलाइज़ेशन।

2. डेटा मॉडल और स्कीमा बनाना

अपने API के लिए एक सरल मॉडल परिभाषित करें — पुस्तकें। स्ट्रक्चर और GraphQL स्कीमा बनाएँ:

use async_graphql::*;use serde::{Serialize, Deserialize};

#[derive(Clone, Debug, Serialize, Deserialize, SimpleObject)]struct Book {    id: ID,    title: String,    author: String,    year: i32,}

#[derive(Clone, Debug, Serialize, Deserialize, InputObject)]struct BookInput {    title: String,    author: String,    year: i32,}

#[derive(SimpleObject)] और #[derive(InputObject)] एट्रीब्यूट पर ध्यान दें। पहला आउटपुट के लिए स्वचालित रूप से GraphQL प्रकार उत्पन्न करता है, दूसरा डेटा इनपुट के लिए।

3. रिज़ॉल्वर लागू करना (Query और Mutation)

रिज़ॉल्वर वे फ़ंक्शन हैं जो क्वेरी को संसाधित करते हैं। स्टोरेज स्ट्रक्चर और रिज़ॉल्वर बनाएँ:

use std::sync::Mutex;

struct QueryRoot;

#[Object]impl QueryRoot {    async fn books(&self, ctx: &Context<'_>) -> Vec<Book> {        let storage = ctx.data_unchecked::<Mutex<Vec<Book>>>();        storage.lock().unwrap().clone()    }

    async fn book(&self, ctx: &Context<'_>, id: ID) -> Option<Book> {        let storage = ctx.data_unchecked::<Mutex<Vec<Book>>>();        storage.lock().unwrap().iter().find(|b| b.id == id).cloned()    }}

struct MutationRoot;

#[Object]impl MutationRoot {    async fn add_book(&self, ctx: &Context<'_>, input: BookInput) -> Book {        let mut storage = ctx.data_unchecked::<Mutex<Vec<Book>>>()            .lock().unwrap();        let book = Book {            id: ID::from(storage.len() + 1),            title: input.title,            author: input.author,            year: input.year,        };        storage.push(book.clone());        book    }}

हम डेटा तक थ्रेड-सुरक्षित पहुँच के लिए Mutex का उपयोग कर रहे हैं। वास्तविक प्रोजेक्ट में, आप एक डेटाबेस कनेक्ट करेंगे, लेकिन ट्यूटोरियल के लिए यह एक आदर्श विकल्प है।

4. सर्वर बनाना और चलाना

अंतिम चरण — सब कुछ एक कार्यशील सर्वर में संयोजित करना। एंट्री पॉइंट बनाएँ:

use actix_web::{guard, web, App, HttpServer, HttpRequest, HttpResponse};use actix_cors::Cors;use async_graphql_actix_web::{GraphQLRequest, GraphQLResponse};

async fn index(    schema: web::Data<Schema<QueryRoot, MutationRoot, EmptySubscription>>,    req: GraphQLRequest,) -> GraphQLResponse {    schema.execute(req.into_inner()).await.into()}

#[actix_web::main]async fn main() -> std::