Bibliothèques WebSocket Rust : Tokio-tungstenite et async-tungstenite pour le temps réel

Bibliothèques WebSocket Rust : Tokio-tungstenite et async-tungstenite

Dans le développement web moderne, le protocole WebSocket est devenu la norme pour créer des applications temps réel : chats, jeux en ligne, tickers financiers et systèmes de notifications. L'écosystème Rust propose des outils puissants et sécurisés pour travailler avec WebSocket, parmi lesquels se distinguent tokio-tungstenite et async-tungstenite. Ces bibliothèques sont construites sur la base du runtime asynchrone populaire Tokio et de la pile WebSocket haute performance tungstenite.

Que sont Tokio-tungstenite et async-tungstenite ?

Tokio-tungstenite est une bibliothèque WebSocket asynchrone pour Rust, intégrée au runtime Tokio. Elle fournit des abstractions pratiques pour créer des serveurs et clients WebSocket, en utilisant les types standards de Tokio (TcpListener, TcpStream).

Async-tungstenite est une version plus générale qui fonctionne avec n'importe quel runtime asynchrone (Tokio, async-std, smol) via les traits AsyncRead et AsyncWrite. Les deux bibliothèques assurent une prise en charge complète de la RFC 6455, incluant la fragmentation des messages, le ping/pong et le masquage.

Fonctionnalités clés

• Asynchrone — opérations non bloquantes utilisant async/await
• Haute performance — surcharge minimale grâce à l'analyse zero-copy
• Sécurité des types — les messages sont représentés comme des structures fortement typées
• Flexibilité — prise en charge des côtés serveur et client
• SSL/TLS — prise en charge intégrée des connexions sécurisées via rustls ou native-tls
• Gestion automatique des connexions — traitement des interruptions et reconnexions

Installation

Ajoutez dans Cargo.toml :

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

Exemple : Serveur WebSocket

Créons un simple serveur echo qui renvoie le message reçu :

use tokio::net::TcpListener;use tokio_tungstenite::accept_async;use futures_util::{SinkExt, StreamExt};use std::error::Error;

#[tokio::main]async fn main() -> Result<(), Box> {    let listener = TcpListener::bind("127.0.0.1:8080").await?;    println!("Serveur WebSocket démarré sur ws://127.0.0.1:8080");

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

async fn handle_connection(stream: tokio::net::TcpStream) {    let ws_stream = accept_async(stream).await.expect("Erreur handshake");    let (mut write, mut read) = ws_stream.split();

    while let Some(Ok(msg)) = read.next().await {        if msg.is_text() || msg.is_binary() {            // Renvoyer le message            if let Err(e) = write.send(msg).await {                eprintln!("Erreur d'envoi : {}", e);                break;            }        }    }    println!("Connexion fermée");}

Exemple : Client WebSocket

Connectons-nous au serveur et envoyons un message de bienvenue :

use tokio_tungstenite::connect_async;use futures_util::{SinkExt, StreamExt};use url::Url;

#[tokio::main]async fn main() -> Result<(), Box> {    let url = Url::parse("ws://127.0.0.1:8080")?;    let (ws_stream, _) = connect_async(url).await?;    println!("Connecté au serveur");

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

    // Envoyer un message    write.send("Bonjour le monde !".into()).await?;    println!("Envoyé : Bonjour le monde !");

    // Lire la réponse    if let S