Design de sistemas

Como uma mensagem de chat chega a quem está offline

A Alice manda uma mensagem enquanto o celular do Bob está desligado. Se ela chega até ele, uma só vez e na ordem certa em cada dispositivo, depende de saber onde ele está: em outro servidor, em lugar nenhum, ou em dois dispositivos ao mesmo tempo. Cinco versões de um backend de chat, de um servidor até um grupo de 500.

Ir para a arquitetura final

A Alice digita “Sábado ainda está de pé?” e aperta enviar. O celular do Bob está numa gaveta, com a bateria zerada, e o notebook dele está fechado em cima da mesa. Uma hora depois ele põe o celular para carregar, e a mensagem tem que estar lá: uma única vez, no lugar certo da conversa, e também no notebook quando ele abrir.

Então, onde está o Bob? Ele pode estar conectado ao mesmo servidor da Alice, a outro, a nenhum, ou a dois ao mesmo tempo, por dois dispositivos. Cada um desses lugares exige uma forma própria de a mensagem chegar até ele, e a maior parte de um backend de chat é a soma dessas formas.

O resto deste post acompanha essa única mensagem. Cada seção abaixo é um caso que a versão anterior não resolve, em geral um lugar onde o Bob pode estar, com a menor mudança que o resolve e o que ela custa. Se você já conhece backends de chat, os títulos contam a história e o último desenho é o resultado; se não, comece pelo caso em que tudo roda em um só servidor. O Learn tem o design final, um chat em tempo real completo; este post mostra como um design assim vai surgindo.

Dois milhões de pessoas, meio milhão de sockets

O produto é um app de celular com chat individual e em grupo. Todos os números aqui são inventados para o exercício e arredondados para facilitar a conta; nenhum foi medido em um serviço real:

  • 2 milhões de usuários por dia. No pico da noite, cerca de 300.000 estão conectados ao mesmo tempo, muitos por dois dispositivos, então vamos falar em meio milhão de conexões abertas.
  • Cerca de 60 mensagens por usuário por dia: 120 milhões por dia, uns 1.400 por segundo em média, e algumas vezes isso no pico da noite, digamos 4.000 por segundo.
  • Um servidor de chat aguenta cerca de 50.000 conexões WebSocket, na maioria ociosas. É uma premissa de dimensionamento para este exercício; o número real depende da memória por conexão, do TLS e do que o servidor faz com cada uma.
  • Os grupos têm no máximo 500 membros. É um limite de produto, e está declarado como tal.
  • Uma mensagem armazenada ocupa cerca de 200 bytes com seus IDs e timestamps: uns 24 GB por dia.

Olhe a primeira e a terceira linhas juntas. Meio milhão de conexões a 50.000 por servidor dão dez servidores só para manter todo mundo conectado, antes de enviar uma única mensagem. Alguns milhares de mensagens por segundo são trabalho comum para um banco de dados. Com esses números, as conexões abertas se esgotam muito antes das mensagens por segundo.

Antes de desenhar qualquer coisa, três limites de tempo, todos premissas. A Alice deve ver “enviada” bem menos de um segundo depois de apertar enviar, e só depois que a mensagem estiver armazenada. Um Bob conectado deve vê-la em até um segundo. Um Bob offline deve ter uma notificação enviada a ele em poucos segundos e encontrar a conversa inteira ao abrir o app. O terceiro limite tem duas metades por um motivo: a notificação só avisa o Bob para olhar, e o que de fato entrega a mensagem a ele é o banco.

Todo mundo em um só servidor

Comece pelo caso em que todos estão no mesmo lugar. O celular da Alice e o do Bob mantêm, cada um, um WebSocket aberto com um único servidor de chat. Um WebSocket é uma conexão que fica aberta nos dois sentidos, então o servidor pode mandar uma mensagem ao Bob no instante em que a recebe, em vez de esperar o celular dele perguntar. No modelo comum de requisição e resposta, isso não acontece: o servidor só responde quando o cliente pede.

Quando a mensagem da Alice chega, o servidor faz três coisas, nesta ordem: grava a mensagem no banco de mensagens, confirma para a Alice (o celular dela mostra “enviada”) e escreve a mensagem no socket do Bob. A ordem é a primeira decisão de verdade do design. Se o servidor entregasse primeiro e gravasse depois, uma queda entre as duas etapas deixaria uma mensagem que o Bob já leu e que o sistema não tem mais: faltando no histórico da Alice e em qualquer dispositivo que o Bob usar em seguida. Grava primeiro, entrega depois, e toda mensagem que alguém viu é uma mensagem que o sistema ainda tem.

Etapa 1 de 5: Um servidor: grava, depois entrega
Um servidor: grava, depois entregaO celular da Alice e o do Bob mantêm, cada um, um WebSocket com um único servidor de chat. O servidor de chat grava cada mensagem no banco de mensagens, um banco relacional, e depois a envia pelo WebSocket do Bob.WebSocketCelular da AliceSPA / MóvelCLIENTES E UIServidor de chatServidor de tempo real (WebSocket / SSE)Servidor de tempo real(WebSocket / SSE)SERVIÇOS E APISBanco de mensagensArmazenamento SQL genéricoArmazenamento SQLgenéricoARMAZENAMENTOS DE DADOSCelular do BobSPA / MóvelCLIENTES E UI
Um servidor: grava, depois entregaO celular da Alice e o do Bob mantêm, cada um, um WebSocket com um único servidor de chat. O servidor de chat grava cada mensagem no banco de mensagens, um banco relacional, e depois a envia pelo WebSocket do Bob.WebSocketCelular da AliceSPA / MóvelCLIENTES E UIServidor de chatServidor de tempo real (WebSocket / SSE)Servidor de tempo real(WebSocket / SSE)SERVIÇOS E APISBanco de mensagensArmazenamento SQL genéricoArmazenamento SQLgenéricoARMAZENAMENTOS DE DADOSCelular do BobSPA / MóvelCLIENTES E UI

O servidor de chat grava a mensagem antes de escrevê-la no socket do Bob.

Saiba maisTransporte em tempo real: long-polling vs SSE vs WebSocketWebSockets em escala: gateways, roteamento e draining

O banco de mensagens pode ser um banco relacional comum: uma tabela de mensagens com a conversa, o remetente, o texto e um timestamp. E o celular morto do Bob? Nesta versão, a mensagem da Alice fica esperando no banco, e quando o Bob abrir o app, ele carrega as mensagens recentes de cada conversa. Ou seja, o Bob recebe a mensagem, mais cedo ou mais tarde, se por acaso abrir o app. Nada avisa que ele precisa abrir.

Para um lançamento com poucos milhares de pessoas online, isso basta. Um servidor guarda todos os sockets, acha o do Bob na própria memória e escreve nele. Os custos, porém, já aparecem. O servidor é um ponto único de falha: quando reinicia, todos os usuários são desconectados de uma vez. E ele tem um teto que nada tem a ver com mensagens: por volta de 50.000 conexões ele está cheio, e o nosso pico da noite precisa de dez vezes isso.

O Bob está em outro servidor

Agora são vários servidores de chat, cerca de uma dúzia para o pico da noite, o que deixa folga para perder um, com um balanceador de carga na frente escolhendo um servidor para cada nova conexão. Um WebSocket fica no servidor onde foi aberto até ser fechado, então, depois que o balanceador escolhe, é ali que o usuário mora.

Repita a mensagem da Alice, desta vez com o celular do Bob ligado. A conexão da Alice caiu em um servidor; a do Bob caiu em outro. O servidor da Alice grava a mensagem, confirma para ela, procura o socket do Bob na própria memória e não encontra nada. O Bob está conectado, só não está aqui.

Os servidores precisam de um jeito de passar mensagens uns aos outros, e o mais simples é publish/subscribe (pub/sub). Cada usuário tem um canal em um broker de pub/sub. Quando o socket do Bob abre em um servidor, esse servidor se inscreve no canal do Bob, e cancela a inscrição quando o último socket dele ali fecha. O servidor da Alice não precisa saber onde o Bob está: ele publica a mensagem no canal do Bob, o broker entrega ao servidor que estiver inscrito, e esse servidor a escreve no socket do Bob.

Etapa 2 de 5: O Bob está em outro servidor
O Bob está em outro servidorUm balanceador de carga agora distribui as conexões entre vários servidores de chat. O servidor de chat da Alice grava a mensagem e a publica no canal do Bob em um serviço de pub/sub; outro servidor de chat, o que guarda o WebSocket do Bob, está inscrito nesse canal e entrega a mensagem ao celular do Bob.ao canal do BobWebSocketCelular da AliceSPA / MóvelCLIENTES E UIBalanceador de cargaBalanceador decargaRoteador de tráfegoPLATAFORMA E RUNTIMEServidor de chatServidor de tempo real (WebSocket / SSE)Servidor de tempo real(WebSocket / SSE)SERVIÇOS E APISBanco de mensagensArmazenamento SQL genéricoArmazenamento SQLgenéricoARMAZENAMENTOS DE DADOSCanais de usuárioPublicação / assinaturaMENSAGERIA E FLUXOS DETRABALHOOutro servidor de chatOutro servidor dechatServidor de tempo real (WebSocket / SSE)Servidor de tempo real(WebSocket / SSE)SERVIÇOS E APISCelular do BobSPA / MóvelCLIENTES E UI
O Bob está em outro servidorUm balanceador de carga agora distribui as conexões entre vários servidores de chat. O servidor de chat da Alice grava a mensagem e a publica no canal do Bob em um serviço de pub/sub; outro servidor de chat, o que guarda o WebSocket do Bob, está inscrito nesse canal e entrega a mensagem ao celular do Bob.ao canal do BobWebSocketCelular da AliceSPA / MóvelCLIENTES E UIBalanceador de cargaBalanceador decargaRoteador de tráfegoPLATAFORMA E RUNTIMEServidor de chatServidor de tempo real (WebSocket / SSE)Servidor de tempo real(WebSocket / SSE)SERVIÇOS E APISBanco de mensagensArmazenamento SQL genéricoArmazenamento SQLgenéricoARMAZENAMENTOS DE DADOSCanais de usuárioPublicação / assinaturaMENSAGERIA E FLUXOS DETRABALHOOutro servidor de chatOutro servidor dechatServidor de tempo real (WebSocket / SSE)Servidor de tempo real(WebSocket / SSE)SERVIÇOS E APISCelular do BobSPA / MóvelCLIENTES E UI

O servidor da Alice publica no canal do Bob; o servidor que guarda o socket do Bob está inscrito nele.

Saiba maisBalanceamento de carga e escalonamento horizontalPub/sub: tópicos, assinaturas e replay

Um broker simples, como o Redis Pub/Sub, não guarda nada: entrega a quem estiver inscrito naquele instante, e um servidor cuja ligação cai por dois segundos perde esses dois segundos para sempre. Isso parece alarmante e aqui é aceitável, pelo mesmo motivo que já valia na versão com um servidor: a mensagem foi gravada antes de ser publicada. O broker é um caminho rápido até um Bob conectado, não o lugar onde as mensagens dele ficam. O que exige cuidado é como o Bob recupera o que o caminho rápido deixou cair.

O que acontece quando um servidor de chat morre com 50.000 sockets? Todos esses clientes percebem em poucos segundos e reconectam pelo balanceador de carga aos outros servidores, que se inscrevem de novo nos canais deles. As mensagens publicadas nesses canais durante o intervalo não chegaram a ninguém, mas estão no banco, e cada celular carrega o que perdeu quando reconecta. Um detalhe decide se isso funciona: um celular que reconecta deve se inscrever primeiro e consultar o banco depois. Na ordem inversa, uma mensagem gravada entre os dois passos não está na resposta nem foi entregue ao vivo.

A própria reconexão é o segundo custo de ter vários servidores. Cinquenta mil celulares reconectando no mesmo segundo, cada um abrindo uma conexão criptografada (TLS), verificando um token e pedindo ao banco o que perdeu, podem sobrecarregar os servidores que continuam de pé; se eles ficarem lentos, os handshakes estouram o tempo, os celulares tentam de novo, e a carga se alimenta sozinha. Os clientes esperam um atraso aleatório e crescente antes de reconectar (backoff com jitter), e os deploys fecham os sockets em lotes, em vez de todos de uma vez (draining). Essa falha tem um post próprio neste blog, linkado no final. Ela também explica por que são uma dúzia de servidores e não dez: os sobreviventes precisam de folga para as conexões de um servidor.

O Bob está offline

Agora o caso com que o post começou. O celular do Bob está desligado. O servidor da Alice grava a mensagem, confirma para ela e publica no canal do Bob. Ninguém está inscrito, então o broker não entrega a ninguém, e acabou. Nada neste design registra que o Bob está offline, então nada avisa a ele que há uma mensagem esperando. A mensagem está segura no banco e invisível até ele abrir o app por conta própria.

Para notificar o Bob, o servidor precisa saber que ele não está conectado em lugar nenhum. Esse é o trabalho de um registro de conexões: um armazenamento chave-valor rápido que mapeia cada usuário aos servidores de chat que guardam um socket dele. Um servidor escreve a entrada do Bob quando o primeiro socket dele abre ali e a remove quando o último fecha. Um servidor que cai não remove nada, e um celular que fica sem bateria não fecha nada, então toda entrada tem um tempo de vida (TTL) que o servidor só renova enquanto o celular continua respondendo aos heartbeats; quando um dos dois fica em silêncio, as entradas expiram em segundos. O mesmo registro pode responder “o Bob está online?” para a bolinha verde que os outros usuários veem, embora uma bolinha confiável precise de heartbeats e de um período de tolerância, que o artigo do Learn sobre presença cobre.

Com o registro, o servidor da Alice consegue distinguir os dois casos. Se o Bob tem uma entrada, a publicação deve chegar a ele, e nenhum push é necessário. Se não tem, o servidor coloca um job de push em uma fila de entrega, e um serviço de notificações tira os jobs da fila e envia uma notificação push pelo serviço de push da plataforma do celular: o Apple Push Notification service (APNs) para iPhones, o Firebase Cloud Messaging (FCM) para Android. A aresta tracejada até o celular do Bob no desenho representa esse salto pela Apple ou pelo Google.

Etapa 3 de 5: O Bob está offline
O Bob está offlineUm registro de conexões, um armazenamento chave-valor, agora guarda qual servidor de chat mantém os sockets de cada usuário; o servidor que guarda o socket do Bob escreve a entrada dele. O servidor de chat da Alice consulta o Bob ali e, quando ele não tem entrada, coloca um job de push em uma fila de entrega. Um serviço de notificações pega o job e envia uma notificação push ao celular do Bob pelo serviço de push da plataforma do celular.ao canal do BobWebSocketjob de pushCelular da AliceSPA / MóvelCLIENTES E UIBalanceador de cargaBalanceador decargaRoteador de tráfegoPLATAFORMA E RUNTIMEServidor de chatServidor de tempo real (WebSocket / SSE)Servidor de tempo real(WebSocket / SSE)SERVIÇOS E APISBanco de mensagensArmazenamento SQL genéricoArmazenamento SQLgenéricoARMAZENAMENTOS DE DADOSFila de entregaFilaMENSAGERIA E FLUXOS DETRABALHOCanais de usuárioPublicação / assinaturaMENSAGERIA E FLUXOS DETRABALHORegistro de conexõesRegistro deconexõesConsultas KV genéricasARMAZENAMENTOS DE DADOSOutro servidor de chatOutro servidor dechatServidor de tempo real (WebSocket / SSE)Servidor de tempo real(WebSocket / SSE)SERVIÇOS E APISServiço de notificaçõesServiço denotificaçõesPush / E-mailSERVIÇOS E APISCelular do BobSPA / MóvelCLIENTES E UI
O Bob está offlineUm registro de conexões, um armazenamento chave-valor, agora guarda qual servidor de chat mantém os sockets de cada usuário; o servidor que guarda o socket do Bob escreve a entrada dele. O servidor de chat da Alice consulta o Bob ali e, quando ele não tem entrada, coloca um job de push em uma fila de entrega. Um serviço de notificações pega o job e envia uma notificação push ao celular do Bob pelo serviço de push da plataforma do celular.ao canal do BobWebSocketjob de pushCelular da AliceSPA / MóvelCLIENTES E UIBalanceador de cargaBalanceador decargaRoteador de tráfegoPLATAFORMA E RUNTIMEServidor de chatServidor de tempo real (WebSocket / SSE)Servidor de tempo real(WebSocket / SSE)SERVIÇOS E APISBanco de mensagensArmazenamento SQL genéricoArmazenamento SQLgenéricoARMAZENAMENTOS DE DADOSFila de entregaFilaMENSAGERIA E FLUXOS DETRABALHOCanais de usuárioPublicação / assinaturaMENSAGERIA E FLUXOS DETRABALHORegistro de conexõesRegistro deconexõesConsultas KV genéricasARMAZENAMENTOS DE DADOSOutro servidor de chatOutro servidor dechatServidor de tempo real (WebSocket / SSE)Servidor de tempo real(WebSocket / SSE)SERVIÇOS E APISServiço de notificaçõesServiço denotificaçõesPush / E-mailSERVIÇOS E APISCelular do BobSPA / MóvelCLIENTES E UI

Sem entrada no registro, não há socket em lugar nenhum: o servidor enfileira um job de push.

Saiba maisPresença e estado efêmeroNotificações e mensagens transacionaisFilas de mensagens e workers assíncronos

Por que uma fila entre o servidor de chat e o serviço de notificações? Porque o serviço de push é de outra empresa, com a latência dele e os dias ruins dele, e a Alice nunca deve esperar por ele. A mensagem dela é gravada e confirmada, quer a Apple responda rápido, quer não.

O push avisa o Bob para olhar, mas não entrega a conversa. O APNs e o FCM não prometem que toda notificação chega: um celular que ficou desligado por horas pode receber algumas atrasadas, várias agrupadas em uma, ou nenhuma. Por isso a entrega continua onde já estava. Quando o Bob abre o app, o celular pede ao banco todas as mensagens depois da última que ele tem. Nesta versão, o servidor de chat carimba cada mensagem com o próprio relógio ao gravá-la, e “a última” significa o timestamp da mensagem mais nova no celular. Fique de olho nesse cursor; a próxima seção o desmonta.

As novas peças falham de jeitos que vale nomear:

  • O serviço de push está lento ou fora do ar. Os jobs se acumulam na fila e as notificações chegam atrasadas. O chat em si não é afetado, e o Bob ainda recebe tudo quando abre o app.
  • O registro está desatualizado. Por alguns segundos depois da queda de um servidor de chat, a entrada do Bob ainda aponta para ele. Uma mensagem enviada nessa janela é publicada no canal do Bob, no qual nenhum servidor vivo está mais inscrito, e nenhum push sai, porque o registro dizia que ele estava conectado. Quando o celular dele reconecta e se atualiza, a mensagem está lá. Um registro desatualizado custa uma notificação, não uma mensagem.
  • O registro está fora do ar. O servidor não consegue distinguir conectado de offline e precisa apostar em um dos lados. Este design trata todo mundo como offline: ele ainda publica no canal do destinatário e também enfileira um push. O custo são notificações redundantes para quem já viu a mensagem; a outra aposta custaria notificações perdidas para quem não viu, o que é pior. A entrega ao vivo nunca consulta o registro, então segue funcionando.

O Bob em dois dispositivos, e uma mensagem enviada duas vezes

O Bob também tem um notebook. Em algumas noites os dois dispositivos ficam conectados ao mesmo tempo, e o roteamento já dá conta disso: no desenho, o notebook está no mesmo servidor do celular, que se inscreveu no canal do Bob quando o primeiro socket chegou; em qualquer outro servidor, esse servidor também se inscreveria no canal dele. Esta noite é o outro caso: o notebook ficou aberto mais cedo, quando o celular já estava morto na gaveta. O que quebra agora é mais sutil: três jeitos de a mesma mensagem chegar errada ao Bob, e cada um se resolve com uma regra, não com uma caixa nova.

Duas vezes. A mensagem da Alice é gravada, mas a confirmação nunca chega ao celular dela; ela entrou num túnel. O celular dela faz o que deve e envia a mensagem de novo, e o Bob a vê duas vezes. A solução começa no celular da Alice: ele dá um ID a cada mensagem quando ela aperta enviar, e um reenvio leva o mesmo ID. O banco recusa uma segunda mensagem com um ID que já tem naquela conversa e responde ao reenvio com a confirmação da original, e todo cliente ignora uma mensagem cujo ID já está na tela. Reenviar até chegar uma confirmação torna a entrega ao menos uma vez (at least once); a deduplicação por ID faz cada mensagem aparecer uma única vez.

Fora de ordem, ou com buracos. O cursor por timestamp do caso offline perde mensagens, e não raramente. Os relógios de dois servidores de chat diferem por alguns milissegundos, então uma mensagem gravada depois pode ter um timestamp anterior. Duas mensagens podem cair no mesmo milissegundo. E uma mensagem cuja gravação demora um pouco mais para ser confirmada pode aparecer no banco depois que o celular do Bob já leu além do timestamp dela; pedir “tudo depois do timestamp mais novo que eu tenho” faz então essa mensagem ser pulada para sempre.

A solução é um número de sequência por conversa, atribuído pelo banco na mesma escrita que grava a mensagem: 41, 42, 43, sem que duas mensagens compartilhem um. Num banco relacional, isso pode ser um contador na linha da conversa, incrementado na mesma transação que insere a mensagem, de modo que escritas concorrentes na mesma conversa recebem seus números uma após a outra. Isso dá a cada conversa exatamente uma autoridade sobre a sua ordem. Supomos que mesmo um grupo movimentado envia muito menos mensagens por segundo do que uma linha consegue receber de atualizações, então esperar por essa linha não custa nada perceptível nesses números.

Cada dispositivo passa a guardar o seu próprio “último número de sequência que eu tenho” para cada conversa. O celular do Bob morreu sabendo até o 40; o notebook, aberto mais cedo na noite, sabe até o 41, a última mensagem antes da pergunta da Alice. Quando o celular reconecta, ele pede tudo depois do 40 naquela conversa; quando o notebook é aberto, pede tudo depois do 41. Os dois se atualizam de forma independente, já que cada um pode ter perdido mensagens diferentes.

Um buraco com o Bob conectado. O broker pode perder uma mensagem enquanto os sockets do Bob continuam abertos, então o celular dele nunca reconecta e nunca se atualiza. Os números de sequência tornam isso visível: um dispositivo que recebe o 41 e depois o 43 sabe que o 42 existe, pede o 42 ao banco e mantém o cursor no 41 até ele chegar; um cursor que pulasse para o 43 ignoraria o 42 para sempre se o dispositivo morresse antes. Um buraco no final de uma conversa quieta não tem mensagem seguinte que o revele, então os clientes também perguntam ao banco, de tempos em tempos, o último número de sequência de cada conversa.

Etapa 4 de 5: Uma vez, em ordem, em cada dispositivo
Uma vez, em ordem, em cada dispositivoO notebook do Bob agora mantém um WebSocket com o mesmo servidor de chat do celular, que entrega cada mensagem aos dois. O resto do sistema não muda; esta etapa acrescenta regras, não componentes: IDs de mensagem gerados pelo cliente, números de sequência por conversa atribuídos pelo banco de mensagens e um cursor de atualização mantido por cada dispositivo.ao canal do BobWebSocketjob de pushCelular da AliceSPA / MóvelCLIENTES E UIBalanceador de cargaBalanceador decargaRoteador de tráfegoPLATAFORMA E RUNTIMEServidor de chatServidor de tempo real (WebSocket / SSE)Servidor de tempo real(WebSocket / SSE)SERVIÇOS E APISBanco de mensagensArmazenamento SQL genéricoArmazenamento SQLgenéricoARMAZENAMENTOS DE DADOSFila de entregaFilaMENSAGERIA E FLUXOS DETRABALHOCanais de usuárioPublicação / assinaturaMENSAGERIA E FLUXOS DETRABALHORegistro de conexõesRegistro deconexõesConsultas KV genéricasARMAZENAMENTOS DE DADOSOutro servidor de chatOutro servidor dechatServidor de tempo real (WebSocket / SSE)Servidor de tempo real(WebSocket / SSE)SERVIÇOS E APISNotebook do BobSPA / MóvelCLIENTES E UIServiço de notificaçõesServiço denotificaçõesPush / E-mailSERVIÇOS E APISCelular do BobSPA / MóvelCLIENTES E UI
Uma vez, em ordem, em cada dispositivoO notebook do Bob agora mantém um WebSocket com o mesmo servidor de chat do celular, que entrega cada mensagem aos dois. O resto do sistema não muda; esta etapa acrescenta regras, não componentes: IDs de mensagem gerados pelo cliente, números de sequência por conversa atribuídos pelo banco de mensagens e um cursor de atualização mantido por cada dispositivo.ao canal do BobWebSocketjob de pushCelular da AliceSPA / MóvelCLIENTES E UIBalanceador de cargaBalanceador decargaRoteador de tráfegoPLATAFORMA E RUNTIMEServidor de chatServidor de tempo real (WebSocket / SSE)Servidor de tempo real(WebSocket / SSE)SERVIÇOS E APISBanco de mensagensArmazenamento SQL genéricoArmazenamento SQLgenéricoARMAZENAMENTOS DE DADOSFila de entregaFilaMENSAGERIA E FLUXOS DETRABALHOCanais de usuárioPublicação / assinaturaMENSAGERIA E FLUXOS DETRABALHORegistro de conexõesRegistro deconexõesConsultas KV genéricasARMAZENAMENTOS DE DADOSOutro servidor de chatOutro servidor dechatServidor de tempo real (WebSocket / SSE)Servidor de tempo real(WebSocket / SSE)SERVIÇOS E APISNotebook do BobSPA / MóvelCLIENTES E UIServiço de notificaçõesServiço denotificaçõesPush / E-mailSERVIÇOS E APISCelular do BobSPA / MóvelCLIENTES E UI

Nenhum serviço novo: IDs de mensagem, números de sequência por conversa e um cursor por dispositivo.

Saiba maisMessage DeduplicationIdempotência e as ilusões do exatamente-uma-vez

O número de sequência também diz como o banco vai crescer. Com 24 GB por dia, cerca de 9 TB por ano, ele vai passar do tamanho de um banco só mais cedo ou mais tarde, e quando isso acontecer, a conversa é a chave de partição natural: todas as atualizações acima leem uma conversa, e a autoridade de sequência de uma conversa fica na mesma partição que as mensagens dela. Isso é um passo futuro, não este, então o desenho mantém uma caixa só.

Uma pergunta que isto deixa para o produto: quando o Bob está conectado no notebook e o celular está desligado, o celular também deve receber uma notificação? Neste design, não, porque o registro responde se o Bob tem um socket em algum lugar, não em cada dispositivo. Apps de mensagem respondem isso de formas diferentes, e qualquer resposta funciona com o resto do design.

A Alice escreve para 500 pessoas

A Alice faz a mesma pergunta no grupo do bairro, com 500 membros: “Sábado ainda está de pé?” Passe isso pelo design até aqui e o caminho de envio vira um laço: para cada um dos outros 499 membros, consultar o registro, publicar no canal e enfileirar um push para cada um que esteja offline. O trabalho do servidor de chat por mensagem passa a crescer com o tamanho do grupo, nos mesmos servidores que guardam os sockets de todo mundo. Pior: o servidor confirma para a Alice assim que a mensagem é gravada, antes de esse laço terminar; um servidor que cai no meio dele já disse “enviada” à Alice, e os pushes que ainda não tinha enfileirado simplesmente somem. Essa brecha já existia no design individual, entre gravar uma mensagem e enfileirar o push dela; um grupo estende a janela por todo o trabalho de 499 membros.

A solução é tirar o fan-out do caminho de envio. O servidor de chat grava a mensagem e, na mesma transação do banco, registra um job: entregar a mensagem 42 deste grupo. Um pequeno relay dentro dos servidores de chat move os jobs registrados para a fila de entrega. Escrever o job na mesma transação da mensagem é o que torna a confirmação segura: se a mensagem está gravada, o job dela existe, mesmo que o servidor morra no instante seguinte. Esse é o padrão transactional outbox, e custa mais uma tabela em um banco em que o servidor já escreve. Ele fecha também a brecha do caso individual, porque o job de toda mensagem agora é registrado assim.

Ele também responde a uma pergunta que a fila de entrega levantou quando apareceu: e se a fila cair? O relay não consegue mover os jobs, então eles esperam na tabela outbox. A Alice continua enviando enquanto a tabela outbox cresce, e as notificações e as mensagens de grupo chegam quando a fila voltar. As mensagens individuais, que também mantêm uma publicação direta, continuam chegando ao vivo.

Os workers de fan-out tiram jobs da fila e fazem o laço longe dos servidores que guardam os sockets. O job carrega só a mensagem e o grupo. Um worker lê a lista de membros no banco, publica a mensagem no canal de cada membro, pergunta ao registro, em uma única consulta em lote, quais membros não têm socket, e entrega esses ao serviço de notificações. Um worker só confirma um job quando termina o laço e o serviço de notificações já gravou os pushes que vai enviar, e o relay só marca um job como movido quando a fila já o gravou, então uma queda de qualquer lado repete trabalho em vez de perdê-lo: um membro pode receber a mensagem duas vezes, o que o ID dela absorve, ou receber uma segunda notificação. Essas leituras e a consulta ao registro não estão desenhadas, para manter o desenho sem linhas cruzadas. Consultar o registro quando o job roda, e não quando a Alice envia, também significa que um worker atrasado decide com base em quem está conectado agora, não em quem estava conectado quando a mensagem foi enviada. A lista de membros funciona ao contrário: o worker lê o grupo como ele era na mensagem 42 (cada participação registra os números de sequência em que começa e termina), então quem entra um segundo depois de a Alice enviar não recebe uma mensagem de antes de entrar. Os jobs de push das mensagens individuais agora seguem o mesmo caminho, como jobs com um único destinatário, de modo que os servidores de chat deixam de ler o registro: só escrevem as entradas dos sockets que guardam, e os workers fazem a leitura.

Etapa 5 de 5: Fan-out fora do caminho de envio
Fan-out fora do caminho de envioA arquitetura final. Para uma mensagem de grupo, o servidor de chat grava a mensagem e um job de entrega, que chega à fila de entrega. Os workers de fan-out pegam cada job, publicam a mensagem no canal de cada membro no serviço de pub/sub e passam os membros sem conexão aberta ao serviço de notificações, que envia as notificações push.ao canal do BobWebSocketum job por mensagemmembros offlineCelular da AliceSPA / MóvelCLIENTES E UIBalanceador de cargaBalanceador decargaRoteador de tráfegoPLATAFORMA E RUNTIMEServidor de chatServidor de tempo real (WebSocket / SSE)Servidor de tempo real(WebSocket / SSE)SERVIÇOS E APISBanco de mensagensArmazenamento SQL genéricoArmazenamento SQLgenéricoARMAZENAMENTOS DE DADOSFila de entregaFilaMENSAGERIA E FLUXOS DETRABALHOCanais de usuárioPublicação / assinaturaMENSAGERIA E FLUXOS DETRABALHORegistro de conexõesRegistro deconexõesConsultas KV genéricasARMAZENAMENTOS DE DADOSWorkers de fan-outConsumidorMENSAGERIA E FLUXOS DETRABALHOOutro servidor de chatOutro servidor dechatServidor de tempo real (WebSocket / SSE)Servidor de tempo real(WebSocket / SSE)SERVIÇOS E APISNotebook do BobSPA / MóvelCLIENTES E UIServiço de notificaçõesServiço denotificaçõesPush / E-mailSERVIÇOS E APISCelular do BobSPA / MóvelCLIENTES E UI
Fan-out fora do caminho de envioA arquitetura final. Para uma mensagem de grupo, o servidor de chat grava a mensagem e um job de entrega, que chega à fila de entrega. Os workers de fan-out pegam cada job, publicam a mensagem no canal de cada membro no serviço de pub/sub e passam os membros sem conexão aberta ao serviço de notificações, que envia as notificações push.ao canal do BobWebSocketum job por mensagemmembros offlineCelular da AliceSPA / MóvelCLIENTES E UIBalanceador de cargaBalanceador decargaRoteador de tráfegoPLATAFORMA E RUNTIMEServidor de chatServidor de tempo real (WebSocket / SSE)Servidor de tempo real(WebSocket / SSE)SERVIÇOS E APISBanco de mensagensArmazenamento SQL genéricoArmazenamento SQLgenéricoARMAZENAMENTOS DE DADOSFila de entregaFilaMENSAGERIA E FLUXOS DETRABALHOCanais de usuárioPublicação / assinaturaMENSAGERIA E FLUXOS DETRABALHORegistro de conexõesRegistro deconexõesConsultas KV genéricasARMAZENAMENTOS DE DADOSWorkers de fan-outConsumidorMENSAGERIA E FLUXOS DETRABALHOOutro servidor de chatOutro servidor dechatServidor de tempo real (WebSocket / SSE)Servidor de tempo real(WebSocket / SSE)SERVIÇOS E APISNotebook do BobSPA / MóvelCLIENTES E UIServiço de notificaçõesServiço denotificaçõesPush / E-mailSERVIÇOS E APISCelular do BobSPA / MóvelCLIENTES E UI

Um job durável por mensagem; os workers fazem o trabalho por membro.

Saiba maisFan-out: push vs pullTransactional OutboxDesign resolvido: um chat em tempo real

As mensagens individuais mantêm a publicação direta no canal do destinatário, então o caso comum não fica mais lento. As mensagens de grupo levam alguns milissegundos a mais para chegar aos membros conectados, porque passam antes pela fila e por um worker. Em troca, a fila passa a ser o lugar onde um acúmulo aparece: se os workers ficam para trás, as mensagens de grupo e as notificações chegam atrasadas, enquanto as mensagens individuais continuam chegando ao vivo.

Os workers publicam uma vez por membro. Um sistema maior agruparia os membros pelo servidor que o registro diz que os guarda e publicaria uma vez por servidor, bem menos mensagens para o broker; o preço é que o registro passa a fazer parte do caminho ao vivo, e uma queda do registro então interrompe a entrega ao vivo, em vez de só causar notificações extras. Com 500 membros, este design mantém o registro fora do caminho ao vivo: uma queda do registro ainda custa só notificações extras.

Existe um tamanho a partir do qual empurrar uma cópia para cada membro deixa de fazer sentido: um canal seguido por centenas de milhares de pessoas. Ali, os leitores buscam as mensagens do canal quando o abrem, em vez de cada um receber uma cópia. É outro produto, com seus próprios trade-offs entre push e pull, e este design não precisa disso com 500 membros.

Onde a mensagem da Alice ainda pode travar

Mais uma vez, a pergunta da Alice, passando pelo desenho inteiro. O celular dela dá um ID à mensagem e a envia pelo balanceador de carga a um servidor de chat. O servidor a grava como número 42 da conversa, registra o job de entrega dela na mesma transação e diz “enviada” à Alice. Ele publica no canal do Bob; ninguém está inscrito. Um worker pega o job, não encontra entrada do Bob no registro e entrega um push ao serviço de notificações, e a Apple repassa a notificação quando o celular do Bob for ligado de novo, ou não. Uma hora depois o celular reconecta, se inscreve e pede tudo depois do 40. O notebook, aberto na manhã seguinte, pede tudo depois do 41. A mensagem aparece uma vez em cada dispositivo, no seu lugar, e nada no caminho dela precisou funcionar de primeira, exceto o banco.

Doze caixas: três são o celular da Alice e o celular e o notebook do Bob, e os dois servidores de chat representam uma dúzia. Veja o que acontece quando cada uma das outras falha, e quem percebe:

  • Um servidor de chat cai → os usuários dele são desconectados, reconectam com backoff com jitter aos outros servidores, se inscrevem de novo e se atualizam pelo número de sequência. As mensagens enviadas nesse meio-tempo foram gravadas; ninguém perde uma.
  • O balanceador de carga falha → os celulares não alcançam mais nenhum servidor de chat. Use um gerenciado e redundante, ou rode dois.
  • O broker atrasa ou perde mensagens → a entrega ao vivo fica atrasada ou falha. A detecção de buracos e a sincronização periódica buscam no banco as mensagens que faltam.
  • O registro está desatualizado → uma notificação pode se perder. O registro está fora do ar → todos são tratados como offline: notificações extras, entrega ao vivo intacta.
  • A fila de entrega está fora do ar, ou os workers ficam para trás ou caem → os jobs esperam no outbox ou na fila, e o job de um worker que caiu roda de novo; as notificações e as mensagens de grupo atrasam, as mensagens individuais continuam chegando ao vivo, e a Alice continua enviando.
  • O serviço de notificações, ou o serviço de push por trás dele, está lento ou fora do ar → as notificações atrasam ou não chegam; tudo está no app quando ele abre.
  • O banco de mensagens está fora do ar → o envio para. O celular da Alice guarda a mensagem e tenta de novo com o mesmo ID. É a única dependência que o caminho de envio não consegue contornar, porque toda garantia deste design começa com “a mensagem está gravada”. Ele precisa rodar replicado, com cada gravação já em uma segunda máquina antes de a Alice ver “enviada”; senão, um failover pode perder mensagens que ela viu como enviadas.

Além do balanceador de carga, que só precisa ser redundante, o banco é a única caixa cuja falha impede a Alice de enviar, e nenhuma falha da lista pode perder uma mensagem que lhe disseram ter sido enviada. O broker e o serviço de push são caminhos rápidos que podem falhar, porque atrás de cada um deles o banco ainda guarda a mensagem, e todo dispositivo sabe como pedi-la.

Fora deste design

  • Criptografia de ponta a ponta. O roteamento deste post sobrevive a ela; o que muda é o que o servidor consegue ler, assunto do design de chat completo no Learn e do Desafio Mensageria com Criptografia Ponta a Ponta.
  • Confirmações de leitura e indicadores de digitação. Ambos são estado de curta duração sobre uma conversa, e não mensagens dentro dela. Um indicador de digitação pode se perder sem dano; uma confirmação de leitura está mais perto de uma mensagem e costuma ser gravada.
  • Fotos, vídeos e arquivos. Os anexos vão para um object storage, e a mensagem leva uma referência a eles, não os bytes.
  • Chamadas de voz e vídeo, que são mídia em tempo real com protocolos próprios.
  • Busca no histórico de mensagens, um índice separado, alimentado a partir do banco.
  • Várias regiões. Aqui, o Bob e a Alice estão no mesmo continente.

Desenhe você mesmo

O Desafio Sistema de Chat pede esta arquitetura. A paleta dele nomeia produtos (MongoDB, Redis, Kafka, um provedor de push) onde este post desenha caixas genéricas; um tópico do Kafka pode fazer o papel da fila de entrega. Desenhe e depois envie a pergunta da Alice para um Bob de celular desligado.