30 मिनट में Rust पर REST API कैसे लिखें: व्यावहारिक मार्गदर्शिका

परिचय: REST API के लिए Rust क्यों?

Rust एक आधुनिक सिस्टम प्रोग्रामिंग भाषा है जो C/C++ के प्रदर्शन और कचरा संग्रहकर्ता के बिना मेमोरी सुरक्षा को जोड़ती है। REST API बनाने के लिए Rust कई शक्तिशाली फ्रेमवर्क प्रदान करता है, और Actix-web सबसे लोकप्रिय में से एक है। इस मार्गदर्शिका में हम 30 मिनट में Rust पर एक पूर्ण REST API बनाएंगे। आप देखेंगे कि कितनी जल्दी शुरू किया जा सकता है, भले ही आप Rust में नए हों।

पर्यावरण की तैयारी

कोड लिखने से पहले, सुनिश्चित करें कि आपके पास Rust स्थापित है। यदि नहीं, तो यह कमांड चलाएँ:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

स्थापना के बाद संस्करण जाँचें:

rustc --version

अब एक नया प्रोजेक्ट बनाएँ:

cargo new rust_rest_api\ncd rust_rest_api

फ़ाइल Cargo.toml खोलें और निर्भरताएँ जोड़ें:

[dependencies]\nactix-web = "4"\nserde = { version = "1.0", features = ["derive"] }\nserde_json = "1.0"\ntokio = { version = "1", features = ["full"] }

सभी पैकेज स्थापित करने के लिए cargo build चलाएँ। इसमें 1-2 मिनट लगेंगे।

Rust पर बेसिक REST API बनाना

एक सरल एंडपॉइंट से शुरू करते हैं जो अभिवादन लौटाता है। src/main.rs खोलें और लिखें:

use actix_web::{web, App, HttpServer, Responder};\n\nasync fn hello() -> impl Responder {\n    "नमस्ते, दुनिया! यह Rust पर REST API है!"\n}\n\n#[actix_web::main]\nasync fn main() -> std::io::Result<()> {\n    println!("सर्वर http://127.0.0.1:8080 पर चालू है");\n    HttpServer::new(|| {\n        App::new()\n            .route("/", web::get().to(hello))\n    })\n    .bind("127.0.0.1:8080")?\n    .run()\n    .await\n}

cargo run कमांड से सर्वर चलाएँ और ब्राउज़र में http://127.0.0.1:8080 खोलें। आप हमारा अभिवादन देखेंगे। यह Rust पर किसी भी REST API का आधार है।

डेटा संरचना और JSON जोड़ना

असली REST API JSON के साथ काम करता है। आइए एक उपयोगकर्ता मॉडल और उसे प्राप्त करने के लिए एंडपॉइंट बनाएँ:

use serde::{Deserialize, Serialize};\n\n#[derive(Serialize, Deserialize)]\nstruct User {\n    id: u32,\n    name: String,\n    email: String,\n}\n\nasync fn get_user() -> impl Responder {\n    let user = User {\n        id: 1,\n        name: "इवान पेत्रोव".to_string(),\n        email: "ivan@example.com".to_string(),\n    };\n    web::Json(user)\n}\n\n// main() में एक नया रूट जोड़ें:\n// .route("/user", web::get().to(get_user))

अब /user पते पर आपको एक JSON ऑब्जेक्ट मिलेगा। यह महत्वपूर्ण बिंदु है: serde के कारण Rust स्वचालित रूप से संरचना को JSON में क्रमबद्ध करता है।

अनुरोध पैरामीटर और POST अनुरोधों के साथ काम करना

असली API को विभिन्न HTTP विधियों और पैरामीटरों को संभालना चाहिए। POST के माध्यम से उपयोगकर्ता बनाने के लिए एंडपॉइंट जोड़ें:

use actix_web::web::Json;\n\nasync fn create_user(user: Json<User>) -> impl Responder {\n    let new_user = user.into_inner();\n    println!("उपयोगकर्ता बनाया गया: {} ({})", new_user.name, new_user.email);\n    web::Json(new_user)\n}\n\n// main() में:\n// .route("/user", web::post().to(create_user))

अब आप JSON बॉडी के साथ POST अनुरोध भेज सकते हैं, उदाहरण के लिए curl के माध्यम से:

curl -X POST http://127.0.0.1:8080/user \\\n  -H "Content-Type: application/json" \\\n  -d '{"id":2,"name":"मारिया स्मिर्नोवा","email":"maria@example.com"}'

सर्वर उसी ऑब्जेक्ट को लौटाएगा, जो निर्माण की पुष्टि करता है। यह CRUD संचालन का आधार है।

पथ और क्वेरी स्ट्रिंग पैरामीटर को संभालना

पथ पैरामीटर के माध्यम से ID द्वारा उपयोगकर्ता प्राप्त करने के लिए एंडपॉइंट जोड़ें:

use actix_web::web::Path;\n\nasync fn get_user_by_id(path: Path<u32>) -> impl Responder {\n    let user_id = path.into_inner();\n    // वास्तविक एप्लिकेशन में यहाँ डेटाबेस क्वेरी होगी\n