Web Chat · 4 de novembro de 2026 · 4 min de leitura

Três réplicas, uma conversa só: escalando WebSocket com SignalR e Redis

Os quatro problemas que aparecem quando um chat em tempo real ganha mais de uma réplica, e como o Web Chat resolve cada um.

Escalar uma API comum é quase entediante: uma requisição HTTP começa e termina, então qualquer réplica atrás do balanceador serve. WebSocket é diferente. A conexão fica aberta por horas, presa a um processo específico, e no momento em que existe mais de um processo a pergunta muda de "quem responde?" para "quem conhece quem?".

O Web Chat é um chat com três réplicas .NET/SignalR atrás de um Nginx, e um painel que anima cada mensagem pelo caminho real entre elas. Montar isso me obrigou a resolver quatro problemas que não existem com uma réplica só.

1. Cada réplica só conhece as próprias conexões

Se a Ana está conectada no Servidor A e a Bia no Servidor B, uma mensagem que chega no A não tem como chegar na Bia: o A não sabe que ela existe. A solução padrão do SignalR é um backplane, e aqui ele é o Redis. Do lado do código, é uma linha:

C# · Program.cs
builder.Services.AddSignalR()
    .AddStackExchangeRedis(redisConnection);

Toda mensagem para um grupo vira um publish num canal do Redis, e cada réplica entrega para os próprios clientes. Um detalhe que me surpreendeu: a réplica de origem também recebe a mensagem de volta do Redis antes de entregar aos clientes dela. Parece desperdício, mas é o comportamento real. Lendo o código do RedisHubLifetimeManager, o SendGroupAsync apenas publica; não existe atalho de entrega local. O visualizador desenha esse caminho, e não uma versão simplificada.

2. Round-robin desequilibra com conexão longa

Round-robin funciona porque requisições curtas terminam e liberam espaço. Conexão WebSocket não termina, então quem desconecta de um servidor não libera vaga nenhuma no rodízio, e o desequilíbrio só cresce. O Nginx tem uma estratégia feita para isso:

nginx.conf
upstream chat_backend {
    least_conn;
    server backend1:8080;
    server backend2:8080;
    server backend3:8080;
}

least_conn manda cada conexão nova para quem tem menos conexões abertas agora. Repare que não é sticky session: a escolha é por contagem, não por quem é o cliente. Prender cada pessoa a uma réplica esconderia exatamente o que o projeto quer mostrar.

Sem sticky session, porém, apareceu um problema colateral. Por padrão o cliente do SignalR faz um POST /negotiate antes de abrir o WebSocket, e o Nginx pode mandar as duas requisições para réplicas diferentes. A segunda recusa a conexão, porque o connectionId só existe na memória de quem negociou. A saída foi pular a negociação e ir direto de WebSocket:

TypeScript · chat.service.ts
this.connection = new signalR.HubConnectionBuilder()
  .withUrl(url, {
    skipNegotiation: true,
    transport: signalR.HttpTransportType.WebSockets
  })
  .withAutomaticReconnect()
  .build();

3. "Quem está online" difere entre réplicas

A lista de presença precisa ser a mesma para todo mundo, então ela também vai para o Redis. A primeira versão era um conjunto de nomes, e quebrou em dois casos: a mesma pessoa com duas abas abertas (fechar uma tirava a pessoa da lista) e o F5, em que a conexão nova pode entrar numa réplica antes de a antiga sair da outra.

A versão final é um contador por usuário: entra soma um, sai subtrai um, e o nome só some quando chega a zero. Mas "subtrair e apagar se zerou" em comandos separados deixa uma janela para outra conexão se intrometer no meio. Por isso as duas operações são scripts Lua, que o Redis executa inteiros, sem interrupção:

Lua · RedisRoomPresenceService.cs
local count = redis.call('HINCRBY', KEYS[1], ARGV[1], -1)
if count <= 0 then
    redis.call('HDEL', KEYS[1], ARGV[1])
end
redis.call('PEXPIRE', KEYS[1], ARGV[2])

4. Uma réplica cair não pode derrubar quem estava nela

Esse foi o problema que mais me ensinou, porque a primeira solução não bastou. Quando um processo morre de repente, ele não roda o OnDisconnectedAsync, e a presença de quem estava nele fica registrada sem nenhuma conexão por trás.

A primeira peça foi um sinal de vida: cada réplica se anuncia no Redis a cada cinco segundos, e as outras limpam a presença de quem parou de responder. Parecia resolvido, até eu testar. A réplica morta continua contando como viva até o sinal vencer, e a reconexão automática do cliente começa na hora. Resultado: a pessoa batia no registro que ela mesma tinha deixado e era recusada com "esse nome já está em uso".

A segunda peça foi um identificador estável por aba, enviado na conexão. Com ele, a pergunta deixa de ser "esse nome existe?" e passa a ser "esse nome pertence a outra pessoa?". Só com as duas peças juntas o failover funciona.

Provando com um teste que derruba um container

Os testes de ponta a ponta rodam com Playwright contra o docker compose de verdade, e não contra um servidor de desenvolvimento, porque o que importa verificar não existe sem a infraestrutura em volta: se duas pessoas em réplicas diferentes se enxergam, se o nome duplicado é recusado, se a conversa sobrevive ao F5.

Um deles derruba a réplica no meio da execução e confirma que a pessoa reaparece em outra sem perder a conversa. Ele usa docker compose kill, e não stop, de propósito: encerrar com educação roda o OnDisconnectedAsync e esconde justamente o caso difícil.

O que ficou de fora

Não há autenticação, o histórico é só das últimas cinquenta mensagens da sala geral, mensagem privada não tem entrega garantida e a topologia é fixa em três réplicas. São escolhas: o projeto é um estudo de escala horizontal, não um produto. Mas são as próximas perguntas que eu faria se ele precisasse ir para produção.