WebSocket in Rust: Echtzeit-Anwendungen erstellen

Einführung: Warum WebSocket auf Rust ein leistungsstarkes Duo ist

Moderne Webanwendungen erfordern zunehmend sofortige Datenübertragung: Chats, Online-Spiele, Börsenkurse, Benachrichtigungen. Traditionelles HTTP mit seinem Anfrage-Antwort-Modell ist hier ineffizient – es erzeugt unnötige Last und Verzögerungen. Hier kommt das WebSocket-Protokoll zur Hilfe, das eine permanente bidirektionale Verbindung zwischen Client und Server herstellt.

Die Sprache Rust mit ihrem Fokus auf Leistung, Speichersicherheit und Zero-Cost-Abstraktionen ist ideal für die Erstellung hochbelastbarer Echtzeitsysteme. In diesem Artikel werden wir aufbauen, wie man einen WebSocket-Server in Rust mit der Bibliothek tokio-tungstenite erstellt, und die wichtigsten Patterns für Echtzeitanwendungen betrachten.

Grundlagen von WebSocket und Umgebungsvorbereitung

Was ist WebSocket?

WebSocket ist ein Protokoll, das über TCP arbeitet. Es ermöglicht Server und Client, in Echtzeit Nachrichten auszutauschen, ohne wiederholte HTTP-Handshakes. Die Verbindung beginnt als HTTP-Anfrage mit einem Upgrade auf WebSocket, wonach Daten in Frames übertragen werden.

Abhängigkeiten installieren

Für die Arbeit benötigen wir tokio (asynchrone Laufzeitumgebung) und tokio-tungstenite (WebSocket-Implementierung). Erstellen Sie ein neues Projekt:

cargo new websocket_democd websocket_demo

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

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

Erstellung eines einfachen WebSocket-Servers

Basis-Echo-Server

Beginnen wir mit einem einfachen Server, der Verbindungen annimmt und empfangene Nachrichten zurücksendet (Echo-Modus). Dies ist das klassische „Hello, World“ für WebSocket.

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("Konnte Adresse nicht binden");    println!("Server gestartet auf {}", addr);

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

async fn handle_connection(stream: tokio::net::TcpStream) {    let ws_stream = accept_async(stream)        .await        .expect("Fehler beim WebSocket-Handshake");

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

    while let Some(msg) = read.next().await {        match msg {            Ok(Message::Text(text)) => {                println!("Empfangen: {}", text);                // Hier könnte eine Antwort gesendet werden, aber der Einfachheit halber überspringen wir das            }            Ok(Message::Close(_)) => break,            _ => {}        }    }}

Dieser Code startet einen TCP-Server auf Port 8080. Für jede neue Verbindung wird eine asynchrone Aufgabe handle_connection erstellt, die den WebSocket-Handshake durchführt und eingehende Nachrichten liest.

Nachrichtensenden hinzufügen

Um einen vollwertigen Echo-Server zu erstellen, müssen wir den Stream in Lese- und Schreibvorgänge aufteilen. Wir verwenden futures_util::StreamExt und SinkExt:

use futures_util::SinkExt;

async fn handle_connection(stream: tokio::net::TcpStream) {    let ws_stream = accept_async(stream)        .await        .expect("Fehler beim WebSocket-Handshake");

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

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