Rust में WebSocket: real-time एप्लिकेशन बनाना

WebSocket का Rust में परिचय

Real-time एप्लिकेशन आधुनिक वेब का एक अनिवार्य हिस्सा बन गए हैं। चैट सिस्टम, ऑनलाइन गेम, शेयर बाजार के कोटेशन और रियल टाइम नोटिफिकेशन — इन सभी के लिए क्लाइंट और सर्वर के बीच निरंतर द्विदिश डेटा आदान-प्रदान की आवश्यकता होती है। WebSocket प्रोटोकॉल बिल्कुल यही क्षमता प्रदान करता है, और Rust अपनी उच्च प्रदर्शन क्षमता और सुरक्षा के कारण ऐसे सिस्टम बनाने के लिए एक आदर्श भाषा है।

इस लेख में, हम विस्तार से जानेंगे कि WebSocket का उपयोग करके Rust में real-time एप्लिकेशन कैसे बनाएं। आप लोकप्रिय क्रेट्स, आर्किटेक्चरल दृष्टिकोणों के बारे में जानेंगे और त्वरित शुरुआत के लिए तैयार कोड उदाहरण प्राप्त करेंगे।

WebSocket की मूल बातें और लाइब्रेरी का चयन

WebSocket एक प्रोटोकॉल है जो एकल TCP-कनेक्शन के माध्यम से पूर्ण-द्वैध संचार प्रदान करता है। HTTP के विपरीत, जहां क्लाइंट अनुरोध शुरू करता है और सर्वर जवाब देता है, WebSocket दोनों पक्षों को किसी भी समय डेटा भेजने की अनुमति देता है।

Rust में WebSocket के लिए लोकप्रिय क्रेट्स

• tokio-tungstenite — Tokio पर आधारित एक एसिंक्रोनस WebSocket क्लाइंट और सर्वर। हल्का और तेज़।
• actix-web — अंतर्निहित WebSocket समर्थन के साथ एक शक्तिशाली वेब फ्रेमवर्क।
• tungstenite — सिंक्रोनस संस्करण, सरल परिदृश्यों के लिए सुविधाजनक।
• warp — WebSocket समर्थन के साथ एक और एसिंक्रोनस फ्रेमवर्क।

अधिकांश प्रोजेक्ट्स के लिए, हम tokio-tungstenite या actix-web की सलाह देते हैं। पहला हल्के सर्वर और क्लाइंट के लिए, दूसरा पूर्ण वेब एप्लिकेशन के लिए उपयुक्त है।

Rust में WebSocket सर्वर बनाना

आइए एक सरल echo-सर्वर बनाने पर विचार करें जो संदेश प्राप्त करता है और उन्हें वापस क्लाइंट को भेजता है। हम tokio-tungstenite का उपयोग करेंगे।

प्रोजेक्ट सेटअप

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

[dependencies]tokio = { version = "1", features = ["full"] }tokio-tungstenite = "0.21"futures-util = "0.3"

बेसिक echo-सर्वर

use futures_util::{SinkExt, StreamExt};use tokio::net::TcpListener;use tokio_tungstenite::accept_async;

#[tokio::main]async fn main() -> Result<(), Box> {    let listener = TcpListener::bind("127.0.0.1:8080").await?;    println!("सर्वर ws://127.0.0.1:8080 पर शुरू हुआ");

    while let Ok((stream, addr)) = listener.accept().await {        println!("नया कनेक्शन: {}", addr);        tokio::spawn(handle_connection(stream));    }

    Ok(())}

async fn handle_connection(stream: tokio::net::TcpStream) {    let ws_stream = accept_async(stream).await.unwrap();    let (mut write, mut read) = ws_stream.split();

    while let Some(msg) = read.next().await {        let msg = msg.unwrap();        // संदेश वापस भेजें        write.send(msg).await.unwrap();    }}

यह कोड पोर्ट 8080 पर एक TCP सर्वर बनाता है, WebSocket कनेक्शन स्वीकार करता है, और प्रत्येक क्लाइंट के लिए एक एसिंक्रोनस टास्क शुरू करता है जो सभी आने वाले संदेशों को echo करता है।

Rust में WebSocket क्लाइंट बनाना

अब हम एक क्लाइंट लिखेंगे जो हमारे सर्वर से कनेक्ट होता है, एक संदेश भेजता है और जवाब प्राप्त करता है।

use futures_util::StreamExt;use tokio_tungstenite::connect_async;

#[tokio::main]async fn main() -> Result<(), Box> {    let url = "ws://127.0.0.1:8080";    let (ws_stream, _) = connect_async(url).await?;

    println!("सर्वर से कनेक्ट हुआ");

    let (mut write, mut read) = ws_stream.split();

    // संदेश भेजें    write.send("नमस्ते, WebSocket!".into()).await?;

    // जवाब प्राप्त करें    if let Some(msg) = read.next().await {        let msg = msg?;        println!("प्राप्त हुआ: {}", msg.to_text().unwrap());    }

    Ok(())}

actix-web का उपयोग करके Real-time चैट

अब हम सो```