Rust में Serverless फंक्शन: AWS Lambda पूरी गाइड

परिचय: Rust Serverless के लिए क्यों एक क्रांति है

Serverless आर्किटेक्चर लंबे समय से स्केलेबल और किफायती एप्लिकेशन बनाने का मानक बन गया है। लेकिन पारंपरिक भाषाओं (Python, Node.js, Java) में कोल्ड स्टार्ट और अधिक मेमोरी खपत की समस्या होती है। Rust, अपने जीरो-कॉस्ट एब्स्ट्रैक्शन और गार्बेज कलेक्टर की अनुपस्थिति के साथ, एक क्रांतिकारी समाधान प्रदान करता है। इस लेख में हम सीखेंगे कि AWS Lambda के लिए Rust में Serverless फंक्शन कैसे बनाएं, कॉन्फ़िगर करें और डिप्लॉय करें — टूल्स इंस्टॉल करने से लेकर प्रोडक्शन रिलीज़ तक।

इस लेख के अंत तक आप यह कर पाएंगे:

\n
• Rust + AWS Lambda के लिए डेवलपमेंट एनवायरनमेंट सेट करना
\n
• इवेंट हैंडलिंग के साथ एक कुशल फंक्शन लिखना
\n
• कोल्ड स्टार्ट टाइम को कम करने के लिए बाइनरी फ़ाइल को ऑप्टिमाइज़ करना
\n
• Cargo Lambda का उपयोग करके AWS में फंक्शन डिप्लॉय करना
\n

एनवायरनमेंट तैयार करना: Cargo Lambda और AWS CLI

AWS Lambda पर Rust के साथ काम करने के लिए हमें एक विशेष टूल चाहिए — cargo-lambda। यह बिल्ड, टेस्टिंग और डिप्लॉयमेंट को ऑटोमेट करता है। इसे Cargo के माध्यम से इंस्टॉल करें:

cargo install cargo-lambda

सुनिश्चित करें कि आपके पास aws-cli (IAM कीज़ के साथ कॉन्फ़िगर किया हुआ) और Docker (लोकल टेस्टिंग के लिए) इंस्टॉल है। एक नया प्रोजेक्ट बनाएं:

cargo lambda new my-rust-lambda\ncd my-rust-lambda

यह कमांड Cargo.toml और src/main.rs फ़ाइलों के साथ एक बेसिक स्ट्रक्चर बनाएगा। Cargo.toml में डिपेंडेंसी पर ध्यान दें:

[package]\nname = "my-rust-lambda"\nversion = "0.1.0"\nedition = "2021"\n\n[dependencies]\nlambda_runtime = "0.11"\ntokio = { version = "1", features = ["macros", "rt-multi-thread"] }\nserde = { version = "1.0", features = ["derive"] }\nserde_json = "1.0"\ntracing = { version = "0.1", features = ["log"] }\ntracing-subscriber = { version = "0.3", features = ["fmt"] }

मुख्य लाइब्रेरी lambda_runtime है। यह LambdaHandler ट्रेट प्रदान करती है, जिसे हम इम्प्लीमेंट करेंगे।

पहला फंक्शन लिखना: API Gateway रिक्वेस्ट को हैंडल करना

एक क्लासिक सीनारियो देखते हैं: एक फंक्शन जो यूज़र के नाम के साथ JSON लेता है और एक ग्रीटिंग लौटाता है। src/main.rs खोलें और निम्न कोड लिखें:

use lambda_runtime::{run, service_fn, Error, LambdaEvent};\nuse serde::{Deserialize, Serialize};\n\n#[derive(Deserialize)]\nstruct Request {\n    name: String,\n}\n\n#[derive(Serialize)]\nstruct Response {\n    message: String,\n}\n\nasync fn function_handler(event: LambdaEvent<Request>) -> Result<Response, Error> {\n    let name = event.payload.name;\n    let message = format!("नमस्ते, {}! तुमने अभी-अभी Lambda पर Rust चलाया!", name);\n    Ok(Response { message })\n}\n\n#[tokio::main]\nasync fn main() -> Result<(), Error> {\n    tracing_subscriber::fmt()\n        .with_max_level(tracing::Level::INFO)\n        .init();\n\n    run(service_fn(function_handler)).await\n}

मुख्य बिंदुओं को समझते हैं:

\n
• LambdaEvent<Request> — एक स्ट्रक्चर जिसमें रिक्वेस्ट बॉडी और एक्ज़ीक्यूशन कॉन्टेक्स्ट होता है।
\n
• #[tokio::main] — एसिंक्रोनस रनटाइम, जो Lambda runtime के लिए आवश्यक है।
\n
• serde — इनकमिंग JSON को डिसीरियलाइज़ करना और रिस्पॉन्स को सीरियलाइज़ करना।
\n

लोकल टेस्ट करें:

cargo lambda watch

फिर दूसरे टर्मिनल में:

cargo lambda invoke --data-ascii '{"name": "राहुल"}'

आपको यह दिखना चाहिए: {"message":"नमस्ते, राहुल! तुमने अभी-अभी Lambda पर Rust चलाया!"}

कोल्ड स्टार्ट और बाइनरी साइज़ का ऑप्टिमाइज़ेशन

Rust का मुख्य लाभ न्यूनतम कोल्ड स्टार्ट है। लेकिन इसे प्राप्त करने के लिए, बाइनरी को सही तरीके से बिल्ड करना होगा। बि