WebSocket: o que é, protocolo de comunicação full-duplex e como funciona

O que é WebSocket?

WebSocket é um protocolo de comunicação que opera sobre TCP e fornece um canal full-duplex entre um cliente e um servidor. Foi padronizado pela IETF como RFC 6455 em 2011 e é suportado por todos os navegadores modernos, plataformas móveis e frameworks de servidor.

Diferentemente do HTTP, onde o cliente inicia uma requisição e recebe uma resposta, o WebSocket permite que ambos os lados enviem mensagens a qualquer momento após o estabelecimento da conexão. Isso o torna ideal para cenários que exigem entrega instantânea de dados: chats, notificações, edição colaborativa de documentos.

O protocolo WebSocket usa a porta 80 do HTTP ou a porta 443 do HTTPS para o handshake inicial, após o qual ele muda para seu próprio protocolo com um cabeçalho mínimo — apenas 2 bytes em vez de 800+ bytes no HTTP. Essa característica proporciona uma vantagem significativa de desempenho com um grande número de mensagens.

Características principais do protocolo

Uma conexão WebSocket começa com uma requisição HTTP de upgrade (Upgrade), após a qual o protocolo muda para um formato de quadro binário. O tamanho do quadro varia de 2 bytes a 2^63 bytes, permitindo a transmissão tanto de mensagens de texto curtas quanto de grandes dados binários. O protocolo suporta fragmentação de mensagens, mascaramento de dados do cliente para o servidor e ping/pong para manter a conexão ativa.

Como funciona o WebSocket?

O processo de estabelecimento de uma conexão WebSocket consiste em duas etapas: handshake e transferência de dados. Durante o handshake, o cliente envia uma requisição HTTP com o cabeçalho Upgrade: websocket, e o servidor confirma a mudança de protocolo com o status 101 Switching Protocols. Após isso, a conexão entra em modo de transmissão full-duplex.

Cada mensagem no WebSocket é dividida em quadros. Um quadro contém um opcode (texto, dados binários, fechamento, ping/pong), comprimento do payload e uma chave de mascaramento para dados do cliente. Os quadros podem ser fragmentados — os quadros de controle (ping/pong) podem ser transmitidos entre fragmentos de mensagem, evitando o timeout da conexão durante transferências longas.

const ws = new WebSocket('wss://example.com/chat')

ws.addEventListener('open', () => {
    console.log('Conexão estabelecida')
    ws.send('Olá, servidor!')
})

ws.addEventListener('message', (event) => {
    console.log('Recebido:', event.data)
})

ws.addEventListener('close', () => {
    console.log('Conexão fechada')
})

No exemplo acima, o cliente cria um objeto WebSocket especificando a URL segura wss://. Após abrir a conexão, uma mensagem de boas-vindas é enviada, e o manipulador de mensagens recebe as respostas do servidor. Ao fechar, o manipulador de fechamento é acionado — isso é importante para reconexão em caso de interrupções de rede.

WebSocket vs HTTP: comparação

A principal diferença entre WebSocket e HTTP está no modelo de interação. O HTTP opera em um esquema de requisição-resposta: o cliente inicia uma requisição, o servidor retorna uma resposta e a conexão é fechada. O WebSocket, por outro lado, estabelece um canal persistente através do qual ambos os lados podem iniciar a transmissão a qualquer momento.

Para aplicações que exigem baixa latência e um fluxo constante de dados, o WebSocket é significativamente mais eficiente. O HTTP Long Polling — uma alternativa onde o servidor mantém a requisição aberta até que os dados estejam disponíveis — cria carga excessiva no servidor e aumenta o consumo de memória devido a múltiplas conexões simultâneas.

De acordo com High Performance Browser Networking (Grigorik, O'Reilly), o WebSocket reduz a latência de rede em cenários em tempo real em 40-60% em comparação com HTTP Long Polling, enquanto a carga do servidor é reduzida em 3-5 vezes devido à eliminação de handshakes repetidos.

Onde o WebSocket é usado?

Graças à sua baixa latência e comunicação bidirecional, o WebSocket é usado em uma ampla gama de aplicações. Os cenários principais incluem mensagens instantâneas, sincronização de estado em jogos e transmissão de dados de mercado em sistemas financeiros.

Chats e mensageiros

O WebSocket se tornou o padrão de facto para aplicações de chat. Plataformas como Slack, Telegram Web e WhatsApp Web usam WebSocket para entrega instantânea de mensagens. O protocolo permite enviar tanto mensagens de texto quanto arquivos através de um único canal, enquanto o mecanismo ping/pong mantém a conexão ativa mesmo durante períodos de inatividade.

Jogos online

Jogos multiplayer de navegador e dispositivos móveis exigem latência mínima para sincronizar os estados dos jogadores. O WebSocket transmite coordenadas, ações e eventos em tempo real sem os atrasos das requisições HTTP. Frameworks como Socket.IO e Colyseus abstraem as operações de baixo nível do protocolo, adicionando reconexão automática e salas.

Aplicações financeiras

Terminais de trading e plataformas de negociação usam WebSocket para receber cotações em tempo real. Um atraso de alguns milissegundos pode custar milhões de dólares, por isso as APIs financeiras — como Binance WebSocket Streams, Coinbase Pro — fornecem interfaces WebSocket para dados de mercado.

Aplicações móveis e IoT

No desenvolvimento móvel, o WebSocket é usado através de APIs nativas: URLSessionWebSocketTask no iOS e OkHttp WebSocket no Android. Para Flutter, existe a biblioteca web_socket_channel, e para React Native — react-native-websocket. Dispositivos IoT usam WebSocket para transmitir telemetria e receber comandos de controle, pois o protocolo consome menos energia do que o HTTP polling constante.

Exemplos de código WebSocket

Vejamos um exemplo do lado do servidor usando Node.js com a biblioteca ws — a implementação mais popular de WebSocket para JavaScript. O servidor aceita conexões, processa mensagens e as transmite para todos os clientes conectados.

const WebSocket = require('ws')
const wss = new WebSocket.Server({ port: 8080 })

wss.on('connection', (ws) => {
    console.log('Novo cliente conectado')

    ws.on('message', (data) => {
        console.log('Recebido:', data.toString())
        ws.send('O servidor recebeu sua mensagem')
    })

    ws.on('close', () => {
        console.log('Cliente desconectado')
    })
})

console.log('Servidor WebSocket iniciado na porta 8080')

O servidor cria uma instância de WebSocket.Server na porta 8080 e aguarda conexões. Cada novo cliente recebe um objeto ws separado através do qual o servidor pode enviar mensagens individuais. A transmissão de mensagens para todos os clientes é implementada iterando pela matriz de conexões. Com um grande número de clientes (mais de 1000), é recomendado usar bibliotecas com suporte a clustering, como Socket.IO, que adicionam escalabilidade baseada em Redis e reconexão automática.

Enviar mensagens para todos os clientes

wss.clients.forEach((client) => {
    if (client.readyState === WebSocket.OPEN) {
        client.send('Mensagem para todos os participantes')
    }
})

Verificar o readyState antes de enviar é obrigatório: se o cliente já se desconectou, chamar send lançará um erro. A flag WebSocket.OPEN garante que a conexão está ativa e que a mensagem será entregue.

Para aplicações móveis iOS, o WebSocket é implementado através do URLSessionWebSocketTask, disponível desde o iOS 13. A sessão cria uma tarefa com uma URL de protocolo wss://, após o que os métodos send e receive são chamados. O recebimento de mensagens pode ser organizado através de recursão contínua de receive, que aguarda a próxima mensagem após processar a anterior, garantindo recepção constante de dados sem reconexão. Para Android, é usado o OkHttp WebSocket, que fornece uma interface semelhante com callbacks onOpen, onMessage, onClosing e onClosed, bem como reconexão automática em caso de perda de conexão.

Ao trabalhar com WebSocket em aplicações móveis, é importante considerar o gerenciamento do ciclo de vida: quando o aplicativo vai para segundo plano, o sistema pode encerrar a conexão. No iOS, a conexão deve ser restabelecida ao retornar ao primeiro plano através do delegate sceneDidBecomeActive. No Android, devem ser usados componentes Lifecycle-aware ou um Service para manter a conexão. Adicionalmente, recomenda-se implementar um backoff exponencial para reconexão — aumentar o intervalo entre tentativas de 1 a 30 segundos — para evitar criar carga excessiva no servidor durante problemas temporários de rede.