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:
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:
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:
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:
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.