Bibliotecas WebSocket Rust: Tokio-tungstenite e async-tungstenite para tempo real

Bibliotecas WebSocket Rust: Tokio-tungstenite e async-tungstenite

No desenvolvimento web moderno, o protocolo WebSocket tornou-se padrão para criar aplicações em tempo real: chats, jogos online, tickers financeiros e sistemas de notificação. O ecossistema Rust oferece ferramentas poderosas e seguras para trabalhar com WebSocket, destacando-se tokio-tungstenite e async-tungstenite. Estas bibliotecas são construídas sobre o popular runtime assíncrono Tokio e a pilha WebSocket de alto desempenho tungstenite.

O que são Tokio-tungstenite e async-tungstenite?

Tokio-tungstenite é uma biblioteca WebSocket assíncrona para Rust, integrada com o runtime Tokio. Ela fornece abstrações convenientes para criar servidores e clientes WebSocket, utilizando tipos padrão do Tokio (TcpListener, TcpStream).

Async-tungstenite é uma versão mais geral que funciona com qualquer runtime assíncrono (Tokio, async-std, smol) através das traits AsyncRead e AsyncWrite. Ambas as bibliotecas oferecem suporte completo à RFC 6455, incluindo fragmentação de mensagens, ping/pong e mascaramento.

Principais recursos

• Assíncrono — operações não bloqueantes usando async/await
• Alto desempenho — sobrecarga mínima graças ao parsing zero-copy
• Segurança de tipos — mensagens representadas como estruturas estritamente tipadas
• Flexibilidade — suporte tanto para lado servidor quanto cliente
• SSL/TLS — suporte integrado para conexões seguras via rustls ou native-tls
• Gerenciamento automático de conexões — tratamento de desconexões e reconexões

Instalação

Adicione ao Cargo.toml:

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

Exemplo: Servidor WebSocket

Vamos criar um servidor echo simples que envia de volta a mensagem recebida:

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

    while let Ok((stream, addr)) = listener.accept().await {        println!("Nova conexão: {}", addr);        tokio::spawn(handle_connection(stream));    }    Ok(())}

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

    while let Some(Ok(msg)) = read.next().await {        if msg.is_text() || msg.is_binary() {            // Envia a mensagem de volta            if let Err(e) = write.send(msg).await {                eprintln!("Erro ao enviar: {}", e);                break;            }        }    }    println!("Conexão fechada");}

Exemplo: Cliente WebSocket

Conectamos ao servidor e enviamos uma saudação:

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!("Conectado ao servidor");

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

    // Envia mensagem    write.send("Olá, mundo!".into()).await?;    println!("Enviado: Olá, mundo!");

    // Lê resposta    if let S