WebSocket in Rust: Echtzeitanwendungen von A bis Z

Einführung in WebSocket in Rust: Warum Profis sich dafür entscheiden

Moderne Webanwendungen erfordern eine sofortige Datenübertragung. Ob Online-Chat, Börsenterminal, Mehrspieler-Spiel oder Überwachungssystem – das WebSocket-Protokoll ist zum Standard für Echtzeitkommunikation geworden. Rust mit seinem Fokus auf Leistung und Speichersicherheit ist die ideale Plattform für die Erstellung solcher Systeme.

In diesem Artikel werden wir die Erstellung von WebSocket-Anwendungen in Rust von Grund auf behandeln. Sie erfahren, wie die wichtigsten Bibliotheken funktionieren, wie man mehrere Verbindungen verwaltet und wie man skalierbare Echtzeitsysteme aufbaut. Das Material richtet sich an Entwickler, die mit den Grundlagen von Rust und asynchroner Programmierung vertraut sind.

1. Grundlagen von WebSocket in Rust: Die richtige Bibliothek wählen

Das Rust-Ökosystem bietet mehrere ausgereifte Lösungen für die Arbeit mit WebSocket. Die beliebtesten sind:

• tokio-tungstenite – asynchrones WebSocket auf Basis von tokio, low-level und flexibel
• warp – Web-Framework mit integrierter WebSocket-Unterstützung
• actix-web – leistungsstarkes Framework mit WebSocket-Unterstützung

Für unser Tutorial wählen wir tokio-tungstenite als die vielseitigste Lösung.

Abhängigkeiten installieren

Erstellen Sie ein neues Projekt und fügen Sie in Cargo.toml hinzu:

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

Basis-WebSocket-Server

Schreiben wir einen einfachen Echo-Server, der die empfangene Nachricht zurücksendet:

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

#[tokio::main]async fn main() {    let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();    println!("Server gestartet auf ws://127.0.0.1:8080");

    while let Ok((stream, addr)) = listener.accept().await {        println!("Neue Verbindung: {}", addr);        tokio::spawn(handle_connection(stream));    }}

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(Ok(msg)) = read.next().await {        if let Message::Text(text) = msg {            println!("Empfangen: {}", text);            let response = format!("Echo: {}", text);            write.send(Message::Text(response.into())).await.unwrap();        }    }}

Dieser Code zeigt die grundlegende Struktur: ein asynchroner TCP-Server, Annahme von WebSocket-Verbindungen und Verarbeitung von Nachrichten in separaten Tasks.

2. Architektur eines Echtzeit-Chats in Rust

Jetzt bauen wir einen vollwertigen Chat, bei dem Nachrichten von einem Client an alle verbundenen Benutzer gesendet werden. Dazu benötigen wir einen gemeinsamen Zustand – eine Liste der aktiven Verbindungen.

Implementierung mit shared state

use std::collections::HashMap;use std::sync::Arc;use tokio::sync::{Mutex, broadcast};

type Tx = broadcast::Sender<String>;type Clients = Arc<Mutex<HashMap<String, Tx>>>;

#[tokio::main]async fn main() {    let clients: Clients = Arc::new(Mutex::new(HashMap::new()));    let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();

    while let Ok((stream, addr)) = listener.accept().await {        let clients = clients.clone();        tokio::spawn(handle_client(stream, addr, clients));    }}

async fn handle_client(    stream: tokio::net::TcpStream,    addr: std::net::SocketAddr,    clients: Clients) {    let ws_stream = accept_async(stream).await.unwrap();    let (mut write, mut read) = ws_stream.split();

    // Erstellen eines Kanals für die Verteilung