WebSocket en Rust : création d'applications en temps réel

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Introduction à WebSocket en Rust

Les applications temps réel sont devenues une partie intégrante du web moderne. Systèmes de chat, jeux en ligne, cotations boursières et notifications en temps réel — tout cela nécessite un échange de données bidirectionnel constant entre le client et le serveur. Le protocole WebSocket offre exactement cette possibilité, et Rust, grâce à ses performances et sa sécurité, est le langage idéal pour créer de tels systèmes.

Dans cet article, nous allons détailler comment créer des applications temps réel en Rust avec WebSocket. Vous découvrirez les crates populaires, les approches architecturales et obtiendrez des exemples de code prêts à l'emploi pour démarrer rapidement.

Fondamentaux de WebSocket et choix des bibliothèques

WebSocket est un protocole qui assure une communication full-duplex via une seule connexion TCP. Contrairement à HTTP, où le client initie une requête et le serveur répond, WebSocket permet aux deux parties d'envoyer des données à tout moment.

Crâtes populaires pour WebSocket en Rust

tokio-tungstenite — client et serveur WebSocket asynchrones basés sur Tokio. Léger et rapide.
actix-web — framework web puissant avec support intégré de WebSocket.
tungstenite — version synchrone, pratique pour les scénarios simples.
warp — un autre framework asynchrone avec support de WebSocket.

Pour la plupart des projets, nous recommandons tokio-tungstenite ou actix-web. Le premier pour les serveurs et clients légers, le second pour les applications web complètes.

Création d'un serveur WebSocket en Rust

Examinons la création d'un simple serveur echo qui reçoit des messages et les renvoie au client. Utilisons tokio-tungstenite.

Configuration du projet

Créez un nouveau projet Cargo et ajoutez les dépendances dans Cargo.toml :

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

Serveur echo de base

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

#[tokio::main]async fn main() -> Result<(), Box> {    let listener = TcpListener::bind("127.0.0.1:8080").await?;    println!("Serveur 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.unwrap();    let (mut write, mut read) = ws_stream.split();

    while let Some(msg) = read.next().await {        let msg = msg.unwrap();        // Renvoyer le message        write.send(msg).await.unwrap();    }}

Ce code crée un serveur TCP sur le port 8080, accepte les connexions WebSocket et lance une tâche asynchrone pour chaque client qui renvoie en echo tous les messages entrants.

Création d'un client WebSocket en Rust

Écrivons maintenant un client qui se connecte à notre serveur, envoie un message et reçoit une réponse.

use futures_util::StreamExt;use tokio_tungstenite::connect_async;

#[tokio::main]async fn main() -> Result<(), Box> {    let url = "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, WebSocket!".into()).await?;

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

    Ok(())}