Rust में माइक्रोसर्विसेज़: शुरुआती लोगों के लिए आर्किटेक्चर और अभ्यास

परिचय: माइक्रोसर्विसेज़ के लिए Rust क्यों?

माइक्रोसर्विस आर्किटेक्चर लंबे समय से स्केलेबल वितरित सिस्टम बनाने का मानक बन गया है। आमतौर पर इसे लागू करने के लिए Go, Java या Node.js चुना जाता है। लेकिन हाल के वर्षों में, Rust अधिक ध्यान आकर्षित कर रहा है — एक सिस्टम प्रोग्रामिंग भाषा जो C++ के प्रदर्शन को मेमोरी सुरक्षा के साथ जोड़ती है। इस लेख में pythonlib.ru पर, हम देखेंगे कि Rust में माइक्रोसर्विसेज़ कैसे बनाएं, कौन सी लाइब्रेरीज़ का उपयोग करें और आर्किटेक्चर को कैसे व्यवस्थित करें।

Rust माइक्रोसर्विसेज़ के लिए आदर्श है क्योंकि:

• कोई गार्बेज कलेक्टर नहीं (कम विलंबता और अनुमानित मेमोरी खपत);
• कंपाइलेशन चरण में सुरक्षित मेमोरी प्रबंधन;
• Tokio इकोसिस्टम के माध्यम से एसिंक्रोनसिटी का उत्कृष्ट समर्थन;
• अंतिम बाइनरी फ़ाइल का छोटा आकार (कंटेनरीकरण के लिए आदर्श)।

Rust पर माइक्रोसर्विस आर्किटेक्चर

Rust पर एक सामान्य माइक्रोसर्विस कई परतों से बना होता है:

• HTTP सर्वर (आमतौर पर actix-web या axum पर आधारित);
• बिज़नेस लॉजिक (शुद्ध Rust फ़ंक्शन);
• डेटा लेयर (sqlx या diesel के माध्यम से DB के साथ काम करना);
• एसिंक्रोनस रनटाइम (Tokio);
• सीरियलाइज़ेशन (अक्सर JSON के लिए serde)।

आइए एक सरल उपयोगकर्ता प्रबंधन सेवा के उदाहरण के साथ बुनियादी आर्किटेक्चर देखें।

1. प्रोजेक्ट सेटअप और डिपेंडेंसीज़

एक नया Cargo प्रोजेक्ट बनाएं और Cargo.toml में डिपेंडेंसीज़ जोड़ें:

[package]name = "user-service"version = "0.1.0"edition = "2021"

[dependencies]actix-web = "4"serde = { version = "1", features = ["derive"] }serde_json = "1"tokio = { version = "1", features = ["full"] }sqlx = { version = "0.7", features = ["runtime-tokio", "postgres"] }dotenv = "0.15"

2. सर्वर की मूल संरचना बनाना

डेटा मॉडल परिभाषित करें और HTTP सर्वर शुरू करें:

use actix_web::{web, App, HttpServer, Responder};use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Clone)]struct User {    id: u32,    name: String,    email: String,}

// उदाहरण के लिए In-memory स्टोरेजasync fn get_users() -> impl Responder {    let users = vec![        User { id: 1, name: "Alice".into(), email: "alice@example.com".into() },        User { id: 2, name: "Bob".into(), email: "bob@example.com".into() },    ];    web::Json(users)}

#[actix_web::main]async fn main() -> std::io::Result<()> {    println!("Starting user-service on http://127.0.0.1:8080");

    HttpServer::new(|| {        App::new()            .route("/users", web::get().to(get_users))    })    .bind("127.0.0.1:8080")?    .run()    .await}

यह एक न्यूनतम माइक्रोसर्विस है। ध्यान दें: #[actix_web::main] एक मैक्रो है जो Tokio एसिंक्रोनस रनटाइम शुरू करता है।

3. डेटाबेस के साथ एसिंक्रोनस कार्य

एक वास्तविक माइक्रोसर्विस को डेटा संग्रहीत करना चाहिए। PostgreSQL के लिए sqlx का उपयोग करें। कनेक्शन URL के साथ एक .env फ़ाइल बनाएं:

DATABASE_URL=postgres://user:password@localhost/users_db

अब DB से उपयोगकर्ता प्राप्त करने के लिए एक फ़ंक्शन लिखें:

use sqlx::PgPool;

async fn get_users_from_db(pool: web::Data<PgPool>) -> impl Responder {    // SQL क्वेरी निष्पादित करें और परिणाम को User स्ट्रक्चर में मैप करें    let users: Vec<User> = sqlx::query_as::<_, User>("SELECT id, name, email FROM users")        .fetch_all(pool.get_ref())        .await        .unwrap_or_default();

    web::Json(users)}

#[actix_web::main]async fn main() -> std::io::Result<()> {    dotenv::dotenv().ok();    let database_url = std::env::va