WebSocket-Bibliotheken für Rust: tokio-tungstenite und async-tungstenite

WebSocket-Bibliotheken für Rust: tokio-tungstenite und async-tungstenite

WebSocket ist ein Protokoll, das eine bidirektionale Kommunikation zwischen Client und Server über eine einzige TCP-Verbindung ermöglicht. Im Rust-Ökosystem werden für die Arbeit mit WebSocket zwei Hauptbibliotheken verwendet: tokio-tungstenite (asynchron basierend auf Tokio) und async-tungstenite (asynchron, aber mit Unterstützung für verschiedene Laufzeiten). Beide basieren auf der Low-Level-Bibliothek tungstenite, die das WebSocket-Protokoll selbst implementiert.

Warum WebSocket in Rust verwenden?

Rust ist eine systemnahe Sprache, die sich ideal für die Erstellung hochbelastbarer Netzwerkanwendungen eignet. Die WebSocket-Bibliotheken für Rust ermöglichen:

• Erstellung von Chats, Spielen und Echtzeit-Benachrichtigungssystemen
• Verarbeitung tausender gleichzeitiger Verbindungen mit minimalem Speicherverbrauch
• Nutzung der Speichersicherheit von Rust auf Kompilierungsebene
• Integration mit anderen asynchronen Bibliotheken (z. B. mit HTTP-Servern)

Installation und Konfiguration

Fügen Sie die Abhängigkeit in Cargo.toml hinzu:

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

Für async-tungstenite:

[dependencies]async-tungstenite = "0.25"async-std = "1.12"

Erstellen eines WebSocket-Clients in Rust

Beispiel eines einfachen Clients, der eine Verbindung zum Server herstellt und eine Nachricht sendet:

use futures_util::{SinkExt, StreamExt};use tokio_tungstenite::{connect_async, tungstenite::Message};

#[tokio::main]async fn main() {    let url = "wss://echo.websocket.org";    let (mut ws_stream, _) = connect_async(url).await.expect("Verbindungsfehler");

    println!("Mit Server verbunden");

    // Nachricht senden    ws_stream.send(Message::Text("Hallo, WebSocket!".into())).await.unwrap();

    // Antwort empfangen    if let Some(msg) = ws_stream.next().await {        let msg = msg.unwrap();        if let Message::Text(text) = msg {            println!("Empfangen: {}", text);        }    }

    ws_stream.close(None).await.unwrap();}

Erstellen eines WebSocket-Servers in Rust

Ein Server, der Verbindungen annimmt und Echo-Antworten sendet:

use tokio::net::TcpListener;use tokio_tungstenite::accept_async;use futures_util::{SinkExt, StreamExt};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 {        tokio::spawn(async move {            println!("Neue Verbindung: {}", addr);

            let ws_stream = accept_async(stream).await.unwrap();            let (mut sender, mut receiver) = ws_stream.split();

            while let Some(msg) = receiver.next().await {                match msg {                    Ok(Message::Text(text)) => {                        println!("Nachricht von {}: {}", addr, text);                        sender.send(Message::Text(format!("Echo: {}", text))).await.unwrap();                    }                    Ok(Message::Close(_)) => break,                    _ => {}                }            }

            println!("Verbindung zu {} geschlossen", addr);        });    }}

Hauptfunktionen der Bibliotheken

• TLS/SSL-Unterstützung — gesicherte Verbindungen über WSS (erfordert Aktivierung des Features tls)
• Automatische Wiederverbindung — kann mit Schleifen und Timern implementiert werden
• Ping/Pong-Frames — zur Aufrechterhaltung der Verbindung
• Binäre Nachrichten — Arbeit mit Message::Binary