Rust पर WebSocket: real-time एप्लिकेशन A से Z तक

Rust पर WebSocket का परिचय: यह पेशेवरों की पसंद क्यों है

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

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

1. Rust में WebSocket की मूल बातें: लाइब्रेरी चुनना

Rust का इकोसिस्टम WebSocket के साथ काम करने के लिए कई परिपक्व समाधान प्रदान करता है। सबसे लोकप्रिय:

\n
• tokio-tungstenite — tokio पर आधारित अतुल्यकालिक WebSocket, निम्न-स्तरीय और लचीला
\n
• warp — अंतर्निहित WebSocket समर्थन वाला वेब फ्रेमवर्क
\n
• actix-web — WebSocket समर्थन वाला शक्तिशाली फ्रेमवर्क
\n

हमारी गाइड के लिए, हम tokio-tungstenite को सबसे बहुमुखी समाधान के रूप में चुनेंगे।

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

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

[dependencies]\ntokio = { version = "1", features = ["full"] }\ntokio-tungstenite = "0.21"\nfutures-util = "0.3"\nserde = { version = "1", features = ["derive"] }\nserde_json = "1"\n

बेसिक WebSocket सर्वर

एक सरल इको सर्वर लिखते हैं जो प्राप्त संदेश को वापस भेजता है:

use futures_util::{SinkExt, StreamExt};\nuse tokio::net::TcpListener;\nuse tokio_tungstenite::accept_async;\nuse tokio_tungstenite::tungstenite::Message;\n\n#[tokio::main]\nasync fn main() {\n    let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();\n    println!("सर्वर ws://127.0.0.1:8080 पर शुरू हुआ");\n\n    while let Ok((stream, addr)) = listener.accept().await {\n        println!("नया कनेक्शन: {}", addr);\n        tokio::spawn(handle_connection(stream));\n    }\n}\n\nasync fn handle_connection(stream: tokio::net::TcpStream) {\n    let ws_stream = accept_async(stream).await.unwrap();\n    let (mut write, mut read) = ws_stream.split();\n\n    while let Some(Ok(msg)) = read.next().await {\n        if let Message::Text(text) = msg {\n            println!("प्राप्त: {}", text);\n            let response = format!("इको: {}", text);\n            write.send(Message::Text(response.into())).await.unwrap();\n        }\n    }\n}\n

यह कोड मूल संरचना प्रदर्शित करता है: एक अतुल्यकालिक TCP सर्वर, WebSocket कनेक्शन स्वीकार करना, और अलग-अलग कार्यों में संदेशों को संभालना।

2. Rust पर real-time चैट की आर्किटेक्चर

अब हम एक पूर्ण चैट बनाएंगे, जहाँ एक क्लाइंट के संदेश सभी जुड़े उपयोगकर्ताओं को भेजे जाते हैं। इसके लिए हमें एक साझा स्थिति की आवश्यकता होगी — सक्रिय कनेक्शनों की सूची।

shared state के साथ कार्यान्वयन

use std::collections::HashMap;\nuse std::sync::Arc;\nuse tokio::sync::{Mutex, broadcast};\n\ntype Tx = broadcast::Sender<String>;\ntype Clients = Arc<Mutex<HashMap<String, Tx>>>;\n\n#[tokio::main]\nasync fn main() {\n    let clients: Clients = Arc::new(Mutex::new(HashMap::new()));\n    let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();\n\n    while let Ok((stream, addr)) = listener.accept().await {\n        let clients = clients.clone();\n        tokio::spawn(handle_client(stream, addr, clients));\n    }\n}\n\nasync fn handle_client(\n    stream: tokio::net::TcpStream,\n    addr: std::net::SocketAddr,\n    clients: Clients\n) {\n    let ws_stream = accept_async(stream).await.unwrap();\n    let (mut write, mut read) = ws_stream.split();\n\n    // प्रसारण के लिए चैनल बनाएँ\n