WebSocket sur Rust : créer des applications en temps réel

Introduction : pourquoi WebSocket sur Rust est un tandem puissant

Les applications web modernes exigent de plus en plus souvent un transfert instantané de données : chats, jeux en ligne, cotations boursières, notifications. Le HTTP traditionnel avec son modèle requête-réponse est inefficace ici — il crée une charge et des latences inutiles. Le protocole WebSocket vient à la rescousse, en établissant une connexion bidirectionnelle permanente entre le client et le serveur.

Le langage Rust, avec son accent sur la performance, la sécurité mémoire et le coût zéro des abstractions, est idéal pour créer des systèmes temps réel à forte charge. Dans cet article, nous allons voir comment construire un serveur WebSocket en Rust en utilisant la bibliothèque tokio-tungstenite, et examiner les motifs clés pour les applications temps réel.

Bases de WebSocket et préparation de l'environnement

Qu'est-ce que WebSocket ?

WebSocket est un protocole fonctionnant au-dessus de TCP. Il permet au serveur et au client d'échanger des messages en temps réel sans nécessité de poignées de main HTTP répétées. La connexion commence comme une requête HTTP avec une mise à niveau vers WebSocket, après quoi les données sont transmises en trames.

Installation des dépendances

Pour travailler, nous aurons besoin de tokio (runtime asynchrone) et tokio-tungstenite (implémentation WebSocket). Créez un nouveau projet :

cargo new websocket_democd websocket_demo

Ajoutez les dépendances dans Cargo.toml :

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

Création d'un serveur WebSocket simple

Serveur echo de base

Commençons par un serveur simple qui accepte les connexions et renvoie les messages reçus (mode echo). C'est le classique « Hello, World » pour 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("Impossible de lier l'adresse");    println!("Serveur démarré sur {}", addr);

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

async fn handle_connection(stream: tokio::net::TcpStream) {    let ws_stream = accept_async(stream)        .await        .expect("Erreur lors de la poignée de main WebSocket");

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

    while let Some(msg) = read.next().await {        match msg {            Ok(Message::Text(text)) => {                println!("Reçu : {}", text);                // Ici on pourrait envoyer une réponse, mais pour simplifier on saute            }            Ok(Message::Close(_)) => break,            _ => {}        }    }}

Ce code lance un serveur TCP sur le port 8080. Pour chaque nouvelle connexion, une tâche asynchrone handle_connection est créée, qui effectue la poignée de main WebSocket et lit les messages entrants.

Ajout de l'envoi de messages

Pour faire un serveur echo complet, nous devons diviser le flux en lecture et écriture. Utilisons futures_util::StreamExt et SinkExt :

use futures_util::SinkExt;

async fn handle_connection(stream: tokio::net::TcpStream) {    let ws_stream = accept_async(stream)        .await        .expect("Erreur lors de la poignée de main WebSocket");

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

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