1. Conceitos fundamentais de WebSocket

WebSocket é um protocolo de comunicação bidirecional e full-duplex que funciona sobre TCP. Diferente do HTTP tradicional, o WebSocket estabelece uma conexão persistente entre cliente e servidor, permitindo envio de mensagens a qualquer momento, com baixa latência.

Principais pontos:

• Handshake: inicia como uma requisição HTTP, porém com a intenção de upgrade para o protocolo WebSocket.
• Frames: os dados são enviados em frames, com suporte a texto e binário, além de ping/pong para manter a conexão viva.
• Segurança: ws (não criptografado) vs. wss (criptografado via TLS).
• Casos de uso: chat em tempo real, dashboards, jogos multiplayer, notificações ao vivo, streams de dados.

Metodologia: entenda o fluxo completo — handshake, frames, fechamentos — antes de enfrentar a implementação prática.

2. Handshake, protocolo e fluxo de comunicação

O handshake é o passo crucial que transforma HTTP em WebSocket. A partir do handshake, entram em jogo o protocolo de frames com opcodes (texto, binário, ping, pong e close).

• O cliente envia uma requisição HTTP com: Upgrade: websocket e Connection: Upgrade, além de Sec-WebSocket-Key e Sec-WebSocket-Version.
• O servidor responde com 101 Switching Protocols, incluindo Sec-WebSocket-Accept (resultado da chave recebida concatenada com o GUID padrão e hashed com SHA-1, base64).
• Após o handshake, o canal é binário e pode transportar mensagens em texto ou binário, com suporte a subprotocolos e extensões (ex.: permessage-deflate).

Dicas rápidas:

• Sempre valide a origem para proteger seus serviços de conexões indesejadas.
• Considere o uso de TLS (wss) em produção para evitar interceptação de dados.
• Implemente keep-alive com pings/pongs para detectar conexões inativas.

3. Prática do lado do cliente: conectando e gerenciando mensagens

Do lado do cliente, a interface WebSocket expõe eventos simples que ajudam a gerenciar o ciclo de vida da conexão: onopen, onmessage, onerror e onclose. A seguir, um modelo rápido de uso:

Exemplo básico (apenas para referência — adapte para o seu domínio e ambiente): const ws = new WebSocket('wss://exemplo.com/socket'); Quando a conexão é aberta, você pode enviar mensagens com ws.send('Olá, servidor!') e tratar as respostas com ws.onmessage.

Boas práticas:

• Trate reconexões com backoff exponencial em caso de falhas.
• Defina um protocolo de mensagens claro (por exemplo, JSON com tipo e payload).
• Monitore o tempo de vida da conexão e implemente limites de retry.

4. Exemplo prático do servidor com Node.js (ws)

A seguir, um servidor WebSocket simples usando a biblioteca ws. Ele aceita conexões, faz echo das mensagens recebidas e envia uma mensagem de confirmação assim que a conexão é estabelecida. Em produção, complemente com TLS, autenticação e handling de origem.

// Servidor WebSocket simples com ws (Node.js)

const http = require('http');
const WebSocket = require('ws');

// HTTP básico (pode ser usado para servir páginas, se desejar)
const server = http.createServer((req, res) => {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Servidor WebSocket pronto.\\n');
});

// WebSocket sobre o mesmo servidor HTTP
const wss = new WebSocket.Server({ server });

wss.on('connection', (ws, req) => {
  const ip = req.socket.remoteAddress;
  ws.send(`Conectado de ${ip}`);

  ws.on('message', (message) => {
    console.log(`Recebido de ${ip}: ${message}`);
    ws.send(`Echo: ${message}`);
  });

  ws.on('close', () => {
    console.log(`Conexão encerrada com ${ip}`);
  });
});

// Porta de escuta
server.listen(8080, () => {
  console.log('WS server listening on 8080');
});

Notas adicionais: para produção, utilize TLS (TLS termination com um servidor HTTPS ou um balancer), implemente autenticação de usuário, valide origem e aplique políticas de scale-out (clusters, partitioning, ou ferramentas como Nginx + WebSocket module).