WebSocket em Rust: aplicações em tempo real do A ao Z

Introdução ao WebSocket em Rust: por que é a escolha dos profissionais

As aplicações web modernas exigem transmissão instantânea de dados. Seja um chat online, terminal de bolsa de valores, jogo multijogador ou sistema de monitoramento — o protocolo WebSocket tornou-se o padrão para comunicação em tempo real. Rust, com seu foco em desempenho e segurança de memória, é a plataforma ideal para criar tais sistemas.

Neste artigo, abordaremos a criação de aplicações WebSocket em Rust do zero. Você aprenderá como funcionam as principais bibliotecas, como lidar com múltiplas conexões e como construir sistemas escaláveis em tempo real. O material é voltado para desenvolvedores familiarizados com os fundamentos de Rust e programação assíncrona.

1. Fundamentos do WebSocket em Rust: escolhendo a biblioteca

O ecossistema Rust oferece várias soluções maduras para trabalhar com WebSocket. As mais populares:

• tokio-tungstenite — WebSocket assíncrono baseado em tokio, de baixo nível e flexível
• warp — framework web com suporte integrado a WebSocket
• actix-web — framework poderoso com suporte a WebSocket

Para nosso guia, escolheremos tokio-tungstenite como a solução mais versátil.

Instalação das dependências

Crie um novo projeto e adicione ao Cargo.toml:

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

Servidor WebSocket básico

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

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

#[tokio::main]async fn main() {    let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();    println!("Servidor 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));    }}

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(Ok(msg)) = read.next().await {        if let Message::Text(text) = msg {            println!("Recebido: {}", text);            let response = format!("Echo: {}", text);            write.send(Message::Text(response.into())).await.unwrap();        }    }}

Este código demonstra a estrutura básica: um servidor TCP assíncrono, aceitação de conexões WebSocket e processamento de mensagens em tarefas separadas.

2. Arquitetura de um chat em tempo real em Rust

Agora vamos construir um chat completo, onde as mensagens de um cliente são enviadas para todos os usuários conectados. Para isso, precisaremos de um estado compartilhado — uma lista de conexões ativas.

Implementação com estado compartilhado

use std::collections::HashMap;use std::sync::Arc;use tokio::sync::{Mutex, broadcast};

type Tx = broadcast::Sender<String>;type Clients = Arc<Mutex<HashMap<String, Tx>>>;

#[tokio::main]async fn main() {    let clients: Clients = Arc::new(Mutex::new(HashMap::new()));    let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();

    while let Ok((stream, addr)) = listener.accept().await {        let clients = clients.clone();        tokio::spawn(handle_client(stream, addr, clients));    }}

async fn handle_client(    stream: tokio::net::TcpStream,    addr: std::net::SocketAddr,    clients: Clients) {    let ws_stream = accept_async(stream).await.unwrap();    let (mut write, mut read) = ws_stream.split();

    // Criando um canal para broadcast