Hyper Rust: पूरी गाइड उदाहरणों के साथ

Hyper क्या है और इसकी ज़रूरत क्यों है

Hyper, Rust भाषा के लिए एक हाई-परफॉर्मेंस असिंक्रोनस HTTP लाइब्रेरी है, जो खुद Rust में लिखी गई है। यह Rust इकोसिस्टम में HTTP/1 और HTTP/2 प्रोटोकॉल के साथ काम करने के लिए सबसे लोकप्रिय और सम्मानित लाइब्रेरी में से एक है। Hyper क्लाइंट और सर्वर दोनों भाग प्रदान करता है, जिससे डेवलपर्स तेज़, सुरक्षित और कुशल वेब एप्लिकेशन और API बना सकते हैं।

Hyper का उपयोग करने के मुख्य कारण:

• परफॉर्मेंस: Hyper, Tokio असिंक्रोनस रनटाइम पर बनाया गया है और नॉन-ब्लॉकिंग इनपुट-आउटपुट का उपयोग करता है, जो न्यूनतम संसाधनों के साथ हज़ारों एक साथ कनेक्शन को संभाल सकता है।
• सुरक्षा: Rust कंपाइल टाइम पर मेमोरी सुरक्षा सुनिश्चित करता है, और Hyper इन सिद्धांतों का पालन करता है, जिससे मेमोरी लीक और डेटा रेस के जोखिम कम होते हैं।
• लचीलापन: लाइब्रेरी HTTP कनेक्शन पर लो-लेवल कंट्रोल प्रदान करती है, जिससे आप लगभग किसी भी रिक्वेस्ट प्रोसेसिंग लॉजिक को लागू कर सकते हैं।
• संगतता: Hyper, Warp, Axum और Tide जैसे कई अन्य लोकप्रिय Rust फ्रेमवर्क का आधार है।
• HTTP/2 सपोर्ट: नेटवर्क संसाधनों के अधिक कुशल उपयोग के लिए बिल्ट-इन HTTP/2 सपोर्ट।

Hyper माइक्रोसर्विसेज, प्रॉक्सी सर्वर, API गेटवे और किसी भी अन्य नेटवर्क एप्लिकेशन के लिए आदर्श है जहाँ गति और विश्वसनीयता महत्वपूर्ण है।

Hyper की इंस्टॉलेशन

Rust प्रोजेक्ट में Hyper इंस्टॉल करने के लिए Cargo पैकेज मैनेजर का उपयोग करें। Cargo.toml फ़ाइल में निम्नलिखित डिपेंडेंसी जोड़ें:

[dependencies]
hyper = { version = "1.5", features = ["full"] }
tokio = { version = "1", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

डिपेंडेंसी की व्याख्या:

• hyper: सभी फीचर्स (सर्वर, क्लाइंट, HTTP/2) के साथ मुख्य लाइब्रेरी।
• tokio: असिंक्रोनस रनटाइम, Hyper के काम करने के लिए आवश्यक।
• serde और serde_json: डेटा सीरियलाइज़ेशन/डीसीरियलाइज़ेशन के लिए (उदाहरणों में काम आएगा)।

डिपेंडेंसी जोड़ने के बाद, लाइब्रेरी को डाउनलोड और कंपाइल करने के लिए cargo build कमांड चलाएँ।

त्वरित शुरुआत: एक सरल HTTP सर्वर

चलिए एक न्यूनतम HTTP सर्वर बनाते हैं जो किसी भी रिक्वेस्ट पर "Hello, World!" का जवाब देता है। src/main.rs फ़ाइल बनाएँ और उसमें निम्नलिखित कोड डालें:

use hyper::service::{service_fn, Service};
use hyper::{Body, Request, Response, Server};
use std::convert::Infallible;
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};

// हमारे सर्विस के लिए टाइप डिफाइन करें
struct HelloWorld;

impl Service<Request<Body>> for HelloWorld {
    type Response = Response<Body>;
    type Error = Infallible;
    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;

    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        Poll::Ready(Ok(()))
    }

    fn call(&mut self, _req: Request<Body>) -> Self::Future {
        let response = Response::builder()
            .status(200)
            .header("Content-Type", "text/plain")
            .body(Body::from("Hello, World!"))
            .unwrap();

        Box::pin(async { Ok(response) })
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let addr = ([127, 0, 0, 1], 3000).into();
    let server = Server::bind(&addr).serve(service_fn(|req| async move {
        let response = Response::builder()
            .status(200)
            .header("Content-Type", "text/plain")
            .body(Body::from("Hello, World!"))
            .unwrap();
        Ok::<_, Infallible>(respo