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

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

WebSocket est un protocole assurant une communication bidirectionnelle entre un client et un serveur via une seule connexion TCP. Dans l'écosystème Rust, deux bibliothèques principales sont utilisées pour travailler avec WebSocket : tokio-tungstenite (asynchrone basée sur Tokio) et async-tungstenite (asynchrone, mais avec prise en charge de différents runtimes). Les deux sont construites sur la base de la bibliothèque de bas niveau tungstenite, qui implémente le protocole WebSocket lui-même.

Pourquoi utiliser WebSocket en Rust ?

Rust est un langage système idéal pour créer des applications réseau à forte charge. Les bibliothèques WebSocket Rust permettent de :

• Créer des chats, des jeux, des systèmes de notification en temps réel
• Gérer des milliers de connexions simultanées avec une consommation mémoire minimale
• Utiliser la sécurité mémoire de Rust au niveau de la compilation
• S'intégrer avec d'autres bibliothèques asynchrones (par exemple, avec des serveurs HTTP)

Installation et configuration

Ajoutez la dépendance dans Cargo.toml :

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

Pour async-tungstenite :

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

Création d'un client WebSocket en Rust

Exemple d'un client simple qui se connecte au serveur et envoie un message :

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("Erreur de connexion");

    println!("Connecté au serveur");

    // Envoyer un message    ws_stream.send(Message::Text("Bonjour, WebSocket!".into())).await.unwrap();

    // Recevoir la réponse    if let Some(msg) = ws_stream.next().await {        let msg = msg.unwrap();        if let Message::Text(text) = msg {            println!("Reçu : {}", text);        }    }

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

Création d'un serveur WebSocket en Rust

Serveur qui accepte les connexions et répond en écho :

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!("Serveur démarré sur ws://127.0.0.1:8080");

    while let Ok((stream, addr)) = listener.accept().await {        tokio::spawn(async move {            println!("Nouvelle connexion : {}", 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!("Message de {} : {}", addr, text);                        sender.send(Message::Text(format!("Écho : {}", text))).await.unwrap();                    }                    Ok(Message::Close(_)) => break,                    _ => {}                }            }

            println!("Connexion avec {} fermée", addr);        });    }}

Fonctionnalités principales des bibliothèques

• Prise en charge TLS/SSL — connexions sécurisées via WSS (nécessite l'activation de la fonctionnalité tls)
• Reconnexion automatique — peut être implémentée à l'aide de boucles et de temporisateurs
• Trames Ping/Pong — pour maintenir la connexion
• Messages binaires — travail avec Message::Binary