Bibliotecas WebSocket de Rust: tokio-tungstenite y async-tungstenite

Bibliotecas WebSocket de Rust: tokio-tungstenite y async-tungstenite

WebSocket es un protocolo que proporciona comunicación bidireccional entre un cliente y un servidor a través de una única conexión TCP. En el ecosistema de Rust, se utilizan dos bibliotecas principales para trabajar con WebSocket: tokio-tungstenite (asíncrona basada en Tokio) y async-tungstenite (asíncrona, pero con soporte para diferentes runtimes). Ambas están construidas sobre la biblioteca de bajo nivel tungstenite, que implementa el propio protocolo WebSocket.

¿Por qué usar WebSocket en Rust?

Rust es un lenguaje de sistemas que es ideal para crear aplicaciones de red de alta carga. Las bibliotecas WebSocket de Rust permiten:

• Crear chats, juegos, sistemas de notificaciones en tiempo real
• Manejar miles de conexiones simultáneas con un consumo mínimo de memoria
• Usar la seguridad de memoria de Rust a nivel de compilación
• Integrarse con otras bibliotecas asíncronas (por ejemplo, con servidores HTTP)

Instalación y configuración

Añada la dependencia en Cargo.toml:

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

Para async-tungstenite:

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

Creación de un cliente WebSocket en Rust

Ejemplo de un cliente simple que se conecta a un servidor y envía un mensaje:

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("Error de conexión");

    println!("Conectado al servidor");

    // Enviamos un mensaje    ws_stream.send(Message::Text("¡Hola, WebSocket!".into())).await.unwrap();

    // Recibimos la respuesta    if let Some(msg) = ws_stream.next().await {        let msg = msg.unwrap();        if let Message::Text(text) = msg {            println!("Recibido: {}", text);        }    }

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

Creación de un servidor WebSocket en Rust

Servidor que acepta conexiones y responde con eco:

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!("Servidor iniciado en ws://127.0.0.1:8080");

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

            println!("Conexión con {} cerrada", addr);        });    }}

Características principales de las bibliotecas

• Soporte TLS/SSL — conexiones seguras a través de WSS (requiere habilitar la feature tls)
• Reconexión automática — se puede implementar con bucles y temporizadores
• Frames Ping/Pong — para mantener la conexión activa
• Mensajes binarios — trabajo con Message::Binary