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

परिचय: क्यों Rust पर WebSocket एक शक्तिशाली जोड़ी है

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

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

WebSocket की मूल बातें और वातावरण तैयार करना

WebSocket क्या है?

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

निर्भरताएँ स्थापित करना

काम करने के लिए हमें tokio (अतुल्यकालिक रनटाइम) और tokio-tungstenite (WebSocket कार्यान्वयन) की आवश्यकता है। एक नया प्रोजेक्ट बनाएँ:

cargo new websocket_democd websocket_demo

Cargo.toml में निर्भरताएँ जोड़ें:

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

एक सरल WebSocket सर्वर बनाना

बेसिक इको सर्वर

हम एक सरल सर्वर से शुरू करते हैं जो कनेक्शन स्वीकार करता है और प्राप्त संदेशों को वापस भेजता है (इको मोड)। यह WebSocket के लिए क्लासिक "Hello, World" है।

use tokio::net::TcpListener;use tokio_tungstenite::accept_async;use tokio_tungstenite::tungstenite::Message;use futures_util::StreamExt;

#[tokio::main]async fn main() {    let addr = "127.0.0.1:8080";    let listener = TcpListener::bind(addr).await.expect("पता बाँधने में विफल");    println!("सर्वर {} पर शुरू हुआ", addr);

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

async fn handle_connection(stream: tokio::net::TcpStream) {    let ws_stream = accept_async(stream)        .await        .expect("WebSocket हैंडशेक में त्रुटि");

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

    while let Some(msg) = read.next().await {        match msg {            Ok(Message::Text(text)) => {                println!("प्राप्त: {}", text);                // यहाँ उत्तर भेजा जा सकता है, लेकिन सरलता के लिए छोड़ते हैं            }            Ok(Message::Close(_)) => break,            _ => {}        }    }}

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

संदेश भेजना जोड़ना

पूर्ण इको सर्वर बनाने के लिए, हमें स्ट्रीम को पढ़ने और लिखने में विभाजित करना होगा। हम futures_util::StreamExt और SinkExt का उपयोग करते हैं:

use futures_util::SinkExt;

async fn handle_connection(stream: tokio::net::TcpStream) {    let ws_stream = accept_async(stream)        .await        .expect("WebSocket हैंडशेक में त्रुटि");

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

    while let Some(msg) = read.next().await {        match msg {            Ok(Message::Text(text)) => {                let echo = format!("इको: {}", text);                write.send(Message::Text(echo.into())).await.unwrap();            }            Ok(Message::Close(_)) => break,            _