WebSocket auf Rust: Entwicklung von Echtzeit-Anwendungen

Online Python-Trainer für Anfänger

Lernen Sie Python einfach ohne theoretische Überlastung. Lösen Sie praktische Aufgaben mit automatischer Überprüfung und schreiben Sie Code direkt im Browser.

Kurs starten

Einführung in WebSocket mit Rust

Real-time Anwendungen sind zu einem unverzichtbaren Bestandteil des modernen Webs geworden. Chat-Systeme, Online-Spiele, Börsenkurse und Echtzeit-Benachrichtigungen – all dies erfordert einen ständigen bidirektionalen Datenaustausch zwischen Client und Server. Das WebSocket-Protokoll bietet genau diese Möglichkeit, und Rust ist dank seiner Leistungsfähigkeit und Sicherheit die ideale Sprache für die Erstellung solcher Systeme.

In diesem Artikel werden wir im Detail besprechen, wie man Real-time Anwendungen mit Rust unter Verwendung von WebSocket erstellt. Sie erfahren mehr über beliebte Crates, Architekturansätze und erhalten fertige Codebeispiele für einen schnellen Start.

Grundlagen von WebSocket und Bibliotheksauswahl

WebSocket ist ein Protokoll, das eine Vollduplex-Kommunikation über eine einzige TCP-Verbindung ermöglicht. Im Gegensatz zu HTTP, bei dem der Client eine Anfrage initiiert und der Server antwortet, erlaubt WebSocket beiden Seiten, jederzeit Daten zu senden.

Beliebte Crates für WebSocket in Rust

tokio-tungstenite – asynchroner WebSocket-Client und -Server basierend auf Tokio. Leicht und schnell.
actix-web – leistungsstarkes Web-Framework mit integrierter WebSocket-Unterstützung.
tungstenite – synchrone Version, geeignet für einfache Szenarien.
warp – ein weiteres asynchrones Framework mit WebSocket-Unterstützung.

Für die meisten Projekte empfehlen wir tokio-tungstenite oder actix-web. Ersteres für leichte Server und Clients, letzteres für vollwertige Webanwendungen.

Erstellen eines WebSocket-Servers mit Rust

Betrachten wir die Erstellung eines einfachen Echo-Servers, der Nachrichten empfängt und an den Client zurücksendet. Wir verwenden tokio-tungstenite.

Projekt einrichten

Erstellen Sie ein neues Cargo-Projekt und fügen Sie die Abhängigkeiten in Cargo.toml hinzu:

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

Basis-Echo-Server

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!("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));    }

    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();        // Sende die Nachricht zurück        write.send(msg).await.unwrap();    }}

Dieser Code erstellt einen TCP-Server auf Port 8080, akzeptiert WebSocket-Verbindungen und startet für jeden Client eine asynchrone Aufgabe, die alle eingehenden Nachrichten echo-wiederholt.

Erstellen eines WebSocket-Clients mit Rust

Jetzt schreiben wir einen Client, der sich mit unserem Server verbindet, eine Nachricht sendet und eine Antwort erhält.

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!("Mit Server verbunden");

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

    // Sende eine Nachricht    write.send("Hallo, WebSocket!".into()).await?;

    // Erhalte die Antwort    if let Some(msg) = read.next().await {        let msg = msg?;        println!("Erhalten: {}", msg.to_text().unwrap());    }

    Ok(())}