A Alice escreve “Ainda estamos combinados para sábado?” e carrega em enviar. O telemóvel do Bob está numa gaveta, sem bateria, e o portátil está fechado em cima da secretária. Uma hora depois ele liga o telemóvel ao carregador e a mensagem deve lá estar: uma só vez, no sítio certo da conversa, e também no portátil quando ele o abrir.
Então, onde está o Bob? Pode estar ligado ao mesmo servidor que a Alice, a outro, a nenhum, ou a dois ao mesmo tempo, com dois dispositivos. Cada um desses sítios precisa de uma maneira própria de a mensagem lhe chegar, e a maior parte de um backend de chat é a soma dessas maneiras.
O resto deste artigo segue essa mensagem. Cada secção a seguir é um caso que a versão anterior não consegue tratar, quase sempre um sítio onde o Bob pode estar, e a mudança mais pequena que o resolve, com o respetivo custo. Se já conhece backends de chat, os títulos contam a história e o último desenho é o resultado; se não, comece onde tudo corre num só servidor. O Learn tem o desenho final, um chat em tempo real explicado em pormenor; este artigo é sobre como um desenho assim nasce.
Dois milhões de pessoas, meio milhão de sockets
O produto é chat individual e de grupo numa aplicação móvel. Todos os números aqui são inventados para o exercício e arredondados para facilitar as contas; nenhum foi medido num serviço real:
- 2 milhões de utilizadores diários. No pico da noite cerca de 300 000 estão ligados em simultâneo, muitos com dois dispositivos, pelo que podemos falar em meio milhão de ligações abertas.
- Cerca de 60 mensagens por utilizador por dia: 120 milhões por dia, uns 1400 por segundo em média, e algumas vezes isso no pico da noite, digamos 4000 por segundo.
- Um servidor de chat aguenta cerca de 50 000 ligações WebSocket, na maioria inativas. É um pressuposto de dimensionamento para este exercício; o valor real depende da memória por ligaçã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, assumido como tal.
- Uma mensagem guardada ocupa cerca de 200 bytes com os seus IDs e carimbos de data/hora: perto de 24 GB por dia.
Veja a primeira e a terceira linhas em conjunto. Meio milhão de ligações a 50 000 por servidor são dez servidores só para manter toda a gente ligada, antes de se enviar uma única mensagem. Alguns milhares de mensagens por segundo é trabalho normal para uma base de dados. Com estes números, as ligações abertas esgotam-se muito antes das mensagens por segundo.
Antes de desenhar o que quer que seja, três limites de tempo, todos eles pressupostos. A Alice deve ver “enviada” bastante menos de um segundo depois de carregar em enviar, e só depois de a mensagem estar guardada. Um Bob ligado deve vê-la em menos de um segundo. Para um Bob offline, deve ser-lhe enviada uma notificação em poucos segundos, e ele deve encontrar a conversa toda quando abrir a aplicação. O terceiro limite tem duas metades por uma razão: a notificação só diz ao Bob para ir ver, e é o armazenamento que realmente lhe entrega a mensagem.
Toda a gente num só servidor
Comecemos pelo caso em que toda a gente está no mesmo sítio. O telemóvel da Alice e o do Bob mantêm cada um um WebSocket aberto para um servidor de chat. Um WebSocket é uma ligação que fica aberta nos dois sentidos, para que o servidor possa enviar uma mensagem ao Bob assim que a tem, em vez de esperar que o telemóvel dele pergunte. Um pedido e resposta normais não conseguem fazer isso: o servidor só responde quando o cliente pergunta.
Quando a mensagem da Alice chega, o servidor faz três coisas, por esta ordem: grava a mensagem no armazenamento de mensagens, confirma a receção à Alice (o telemóvel dela mostra “enviada”) e escreve a mensagem no socket do Bob. A ordem é a primeira decisão a sério do desenho. Se o servidor entregasse primeiro e guardasse depois, uma falha entre os dois passos deixaria uma mensagem que o Bob já leu e que o sistema já não tem: em falta no histórico da Alice e em qualquer dispositivo que o Bob use a seguir. Guardar primeiro e entregar depois garante que toda a mensagem que alguém viu é uma mensagem que o sistema ainda tem.
O servidor de chat guarda a mensagem antes de a escrever no socket do Bob.
Saiba maisTransporte em tempo real: long-polling vs SSE vs WebSocketWebSockets à escala: gateways, encaminhamento e draining
O armazenamento de mensagens pode ser uma base de dados relacional normal: uma tabela de mensagens com a conversa, o remetente, o texto e um carimbo de data/hora. E o telemóvel desligado do Bob? Nesta versão, a mensagem da Alice fica à espera no armazenamento e, quando o Bob abrir a aplicação, esta carrega as mensagens mais recentes de cada conversa. Ou seja, o Bob acaba por a receber, se por acaso abrir a aplicação. Nada o avisa.
Para um lançamento com alguns milhares de pessoas online, isto chega. Um servidor tem todos os sockets, encontra o do Bob na sua própria memória e escreve nele. Os custos, no entanto, já se veem. O servidor é um ponto único de falha: quando reinicia, todos os utilizadores são desligados de uma vez. E tem um limite que nada tem a ver com mensagens: perto das 50 000 ligações está cheio, e o nosso pico da noite precisa de dez vezes isso.
O Bob está noutro servidor
Passamos então a ter vários servidores de chat, cerca de uma dúzia para o pico da noite, o que deixa margem para perder um, com um balanceador de carga à frente a escolher um servidor para cada nova ligação. Um WebSocket fica no servidor onde foi aberto até fechar, por isso, depois de o balanceador escolher, é aí que o utilizador “vive”.
Repita-se a mensagem da Alice, desta vez com o telemóvel do Bob ligado. A ligação da Alice caiu num servidor; a do Bob caiu noutro. O servidor da Alice guarda a mensagem, confirma-lha, procura o socket do Bob na sua própria memória e não encontra nada. O Bob está ligado, só não está aqui.
Os servidores precisam de uma forma de passar mensagens uns aos outros, e a mais simples é o publish/subscribe (pub/sub). Cada utilizador tem um canal num broker de pub/sub. Quando o socket do Bob abre num servidor, esse servidor subscreve o canal do Bob, e cancela a subscrição quando o último socket dele aí fecha. O servidor da Alice não precisa de saber onde o Bob está: publica a mensagem no canal do Bob, o broker entrega-a ao servidor que o tiver subscrito, e esse servidor escreve-a no socket do Bob.
O servidor da Alice publica no canal do Bob; o servidor que tem o socket do Bob subscreveu-o.
Saiba maisBalanceamento de carga e escalabilidade horizontalPub/sub: tópicos, subscrições e replay
Um broker simples como o Redis Pub/Sub não guarda nada: entrega a quem estiver subscrito nesse instante, e um servidor cuja ligação caia dois segundos perde esses dois segundos para sempre. Parece alarmante e aqui é aceitável, pela razão que a versão com um só servidor já deu: a mensagem foi guardada antes de ser publicada. O broker é um caminho rápido para um Bob ligado, não o sítio onde as mensagens dele vivem. 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? Cada um desses clientes dá por isso em segundos e volta a ligar-se através do balanceador de carga aos outros servidores, que voltam a subscrever os respetivos canais. As mensagens publicadas nesses canais durante o intervalo não chegaram a ninguém, mas estão no armazenamento, e cada telemóvel carrega o que perdeu quando volta a ligar-se. Um pormenor decide se isto funciona: um telemóvel que se volta a ligar deve subscrever primeiro e consultar o armazenamento depois. Na ordem inversa, uma mensagem guardada entre os dois passos não está na resposta nem foi entregue em direto.
A própria reconexão é o segundo custo de ter vários servidores. Cinquenta mil telemóveis a voltarem a ligar-se no mesmo segundo, cada um a abrir uma ligação cifrada (TLS), a verificar um token e a pedir ao armazenamento o que perdeu, podem sobrecarregar os servidores que ainda estão de pé; se estes abrandarem, os handshakes expiram, os telemóveis tentam de novo e a carga alimenta-se a si própria. Os clientes esperam um atraso aleatório e crescente antes de voltarem a ligar-se (backoff com jitter), e as atualizações fecham os sockets por lotes em vez de todos de uma vez (draining). Essa falha tem um artigo próprio neste blogue, indicado no fim. Explica também a dúzia de servidores em vez de dez: os que sobram precisam de margem para as ligações de um servidor.
O Bob está offline
Agora o caso com que o artigo começou. O telemóvel do Bob está desligado. O servidor da Alice guarda a mensagem, confirma-lha e publica no canal do Bob. Ninguém está subscrito, por isso o broker não a entrega a ninguém, e fica por aí. Nada neste desenho regista que o Bob está offline, por isso nada o avisa de que há uma mensagem à espera. A mensagem está segura no armazenamento e invisível até ele abrir a aplicação por iniciativa própria.
Para notificar o Bob, o servidor tem de saber que ele não está ligado em lado nenhum. É essa a função de um registo de ligações: um armazenamento chave-valor rápido que associa cada utilizador aos servidores de chat que têm um socket seu. Um servidor escreve a entrada do Bob quando o primeiro socket dele abre aí e remove-a quando o último fecha. Um servidor que falha não remove nada, e um telemóvel cuja bateria morre não fecha nada, por isso cada entrada tem um tempo de vida (TTL) que o servidor só renova enquanto o telemóvel continuar a responder aos heartbeats; quando um dos dois deixa de responder, as entradas expiram em segundos. O mesmo registo pode responder a “o Bob está online?” para a bolinha verde que os outros utilizadores veem, embora uma bolinha de confiança precise de heartbeats e de um período de tolerância, que o artigo do Learn sobre presença explica.
Com o registo, o servidor da Alice consegue distinguir os dois casos. Se o Bob tem uma entrada, a publicação deve chegar-lhe e não é preciso push. Se não tem, o servidor coloca um trabalho de push numa fila de entrega, e um serviço de notificações retira os trabalhos da fila e envia uma notificação push através do serviço de push da plataforma do telemóvel: o Apple Push Notification service (APNs) para iPhones, o Firebase Cloud Messaging (FCM) para Android. A aresta tracejada até ao telemóvel do Bob no desenho representa esse salto pela Apple ou pela Google.
Sem entrada no registo não há socket em lado nenhum: o servidor coloca um trabalho de push na fila.
Saiba maisPresença e estado efémeroNotificações e mensagens transacionaisFilas de mensagens e workers assíncronos
Porquê uma fila entre o servidor de chat e o serviço de notificações? Porque o serviço de push pertence a outra entidade, com a sua própria latência e os seus dias maus, e a Alice nunca deve ficar à espera dele. A mensagem dela fica guardada e confirmada, quer a Apple responda depressa ou não.
O push diz ao Bob para ir ver, mas não entrega a conversa. O APNs e o FCM não prometem que todas as notificações chegam: um telemóvel que esteve desligado durante horas pode receber algumas tarde, várias fundidas numa só, ou nenhuma. Por isso a entrega continua onde já estava. Quando o Bob abre a aplicação, o telemóvel pede ao armazenamento todas as mensagens posteriores à última que tem. Nesta versão, o servidor de chat carimba cada mensagem com o seu próprio relógio ao guardá-la, e “a última” quer dizer o carimbo da mensagem mais recente que está no telemóvel. Fique de olho nesse cursor; a secção seguinte desmonta-o.
As novas caixas falham de maneiras que vale a pena nomear:
- O serviço de push está lento ou em baixo. Os trabalhos acumulam-se na fila e as notificações chegam tarde. O chat em si não é afetado, e o Bob continua a receber tudo quando abrir a aplicação.
- O registo está desatualizado. Durante alguns segundos depois de um servidor de chat falhar, a entrada do Bob ainda aponta para ele. Uma mensagem enviada nessa janela é publicada no canal do Bob, que já nenhum servidor ativo tem subscrito, e não sai nenhum push, porque o registo dizia que ele estava ligado. Quando o telemóvel dele volta a ligar-se e se atualiza, a mensagem lá está. Um registo desatualizado custa uma notificação, não uma mensagem.
- O registo está em baixo. O servidor não consegue distinguir ligado de offline e tem de apostar num lado. Este desenho trata toda a gente como offline: continua a publicar no canal do destinatário e coloca também um push na fila. O custo são notificações redundantes para quem já viu a mensagem; apostar no outro lado custaria notificações perdidas a quem não a viu, o que é pior. A entrega em direto nunca consulta o registo, por isso continua.
O Bob em dois dispositivos, e uma mensagem enviada duas vezes
O Bob também tem um portátil. Algumas noites os dois dispositivos estão ligados ao mesmo tempo, e o encaminhamento já trata disso: no desenho, o portátil está no mesmo servidor que o telemóvel, que subscreveu o canal do Bob quando chegou o primeiro socket dele; noutro servidor qualquer, esse servidor subscreveria também o canal dele. Esta noite é o outro caso: o portátil esteve aberto mais cedo, quando o telemóvel já estava morto na gaveta. O que falha agora é mais subtil: três maneiras de a mesma mensagem chegar mal ao Bob, e cada uma resolve-se com uma regra e não com uma caixa nova.
Duas vezes. A mensagem da Alice está guardada, mas a confirmação nunca chega ao telemóvel dela; entrou num túnel. O telemóvel faz o que deve e envia a mensagem de novo, e o Bob vê-a duas vezes. A solução começa no telemóvel da Alice: dá a cada mensagem um ID quando ela carrega em enviar, e um reenvio leva o mesmo ID. O armazenamento recusa uma segunda mensagem com um ID que já tem naquela conversa e responde ao reenvio com a confirmação da original, e todos os clientes ignoram uma mensagem cujo ID já mostram. Reenviar até chegar uma confirmação dá entrega pelo menos uma vez; a deduplicação por ID transforma isso em mostrada uma só vez.
Fora de ordem, ou com buracos. O cursor por carimbo de data/hora do caso offline perde mensagens, e não raramente. Os relógios de dois servidores de chat diferem alguns milissegundos, por isso uma mensagem guardada mais tarde pode ter um carimbo anterior. Duas mensagens podem partilhar o mesmo milissegundo. E uma mensagem cuja escrita demora um pouco mais a ser confirmada pode aparecer no armazenamento depois de o telemóvel do Bob já ter lido para além do seu carimbo; pedir “tudo o que vem depois do carimbo mais recente que tenho” ignora-a então para sempre.
A solução é um número de sequência por conversa, atribuído pelo armazenamento na mesma escrita que guarda a mensagem: 41, 42, 43, sem que duas mensagens partilhem um. Num armazenamento relacional, pode ser um contador na linha da conversa, incrementado na mesma transação que insere a mensagem, de modo que as escritas concorrentes numa conversa recebam os seus números uma a seguir à outra. Isto dá a cada conversa exatamente uma autoridade para a sua ordem. Assumimos que até um grupo movimentado envia muito menos mensagens por segundo do que as atualizações que uma linha aguenta, pelo que esperar por essa linha não custa nada de notável a estes números.
Cada dispositivo guarda então o seu próprio “último número de sequência que tenho” para cada conversa. O telemóvel do Bob morreu a saber até ao 40; o portátil, aberto mais cedo nessa noite, sabe até ao 41, a última mensagem antes da pergunta da Alice. Quando o telemóvel volta a ligar-se, pede tudo o que vem depois do 40 nessa conversa; quando o portátil for aberto, pede tudo o que vem depois do 41. Os dois atualizam-se de forma independente, já que cada um pode ter perdido mensagens diferentes.
Um buraco com a ligação ativa. O broker pode largar uma mensagem enquanto os sockets do Bob continuam abertos, de modo que o telemóvel dele nunca volta a ligar-se 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 ao armazenamento e mantém o cursor no 41 até o 42 chegar; um cursor que saltasse para o 43 ignoraria o 42 para sempre se o dispositivo morresse antes. Um buraco mesmo no fim de uma conversa parada não tem mensagem seguinte que o revele, por isso os clientes também perguntam de vez em quando ao armazenamento qual é o último número de sequência de cada conversa.
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 diz também como o armazenamento vai crescer. Com 24 GB por dia, cerca de 9 TB por ano, mais cedo ou mais tarde vai ultrapassar uma só base de dados 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 vive na mesma partição das suas mensagens. É um passo futuro, não este, por isso o desenho mantém uma só caixa.
Fica uma pergunta para o produto: quando o Bob está ligado no portátil e o telemóvel está desligado, o telemóvel deve receber também uma notificação? Neste desenho não recebe, porque se pergunta ao registo se o Bob tem um socket em algum lado, não em cada dispositivo. As aplicações de mensagens respondem a isto de maneiras diferentes, e qualquer das respostas funciona com o resto do desenho.
A Alice escreve a 500 pessoas
A Alice faz a mesma pergunta no grupo do bairro, com 500 membros: “Ainda estamos combinados para sábado?” Passe-se isso pelo desenho até aqui e o caminho de envio torna-se um ciclo: para cada um dos outros 499 membros, consultá-lo no registo, publicar no canal dele e pôr um push na fila 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 têm os sockets de toda a gente. Pior, o servidor confirma à Alice assim que a mensagem fica guardada, antes de o ciclo terminar; um servidor que falhe a meio já disse à Alice “enviada”, e os pushes que ainda não tinha posto na fila perdem-se simplesmente. Essa falha já existia no desenho individual, entre guardar uma mensagem e pôr o respetivo push na fila; um grupo estica a janela ao trabalho de 499 membros.
A solução é tirar o fan-out do caminho de envio. O servidor de chat guarda a mensagem e, na mesma transação da base de dados, regista um trabalho: entregar a mensagem 42 deste grupo. Um pequeno relay nos servidores de chat move os trabalhos registados para a fila de entrega. Escrever o trabalho na mesma transação que a mensagem é o que torna a confirmação segura: se a mensagem está guardada, o trabalho existe, mesmo que o servidor morra no instante seguinte. É o padrão outbox transacional, e custa mais uma tabela numa base de dados onde o servidor já escreve. Fecha também a falha do caso individual, porque o trabalho de cada mensagem passa a ser registado assim.
Responde ainda a uma pergunta que a fila de entrega levantou quando chegou: e se a fila estiver em baixo? O relay não consegue mover trabalhos, por isso estes esperam na tabela outbox. A Alice continua a enviar enquanto a tabela outbox cresce, e as notificações e as mensagens de grupo chegam quando a fila voltar. As mensagens individuais, que mantêm também uma publicação direta, continuam a chegar em direto.
Os workers de fan-out retiram trabalhos da fila e fazem o ciclo longe dos servidores que têm os sockets. O trabalho leva apenas a mensagem e o grupo. Um worker lê a lista de membros do armazenamento, publica a mensagem no canal de cada membro, pergunta ao registo, numa única consulta em lote, quais os membros sem socket e entrega esses ao serviço de notificações. Um worker só confirma um trabalho quando o ciclo termina e o serviço de notificações guardou os pushes que vai enviar, e o relay só marca um trabalho como movido quando a fila o guardou, de modo que uma falha de qualquer dos lados repete trabalho em vez de o perder: 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 registo não estão desenhadas, para manter o desenho livre de linhas cruzadas. Consultar o registo quando o trabalho corre, e não quando a Alice envia, significa também que um worker atrasado decide com base em quem está ligado agora, não em quem estava ligado quando a mensagem foi enviada. Com a lista de membros passa-se o contrário: o worker lê o grupo tal como estava na mensagem 42 (cada participação regista os números de sequência em que começa e acaba), pelo que quem entra um segundo depois de a Alice enviar não recebe uma mensagem anterior à sua entrada. Os pushes das mensagens individuais seguem agora o mesmo caminho, como trabalhos com um único destinatário, pelo que os servidores de chat deixam de ler o registo: só escrevem entradas para os sockets que têm, e são os workers que fazem a leitura.
Um trabalho durável por mensagem; os workers tratam do que é por membro.
Saiba maisFan-out: push vs pullTransactional OutboxDesenho resolvido: um chat em tempo real
As mensagens individuais mantêm a publicação direta no canal do destinatário, pelo que o caso comum não fica mais lento. As mensagens de grupo demoram alguns milissegundos a mais a chegar aos membros ligados, porque passam primeiro pela fila e por um worker. Em troca, a fila passa a ser o sítio onde se vê um atraso acumulado: se os workers ficarem para trás, as mensagens de grupo e as notificações chegam tarde, enquanto as mensagens individuais continuam a chegar em direto.
Os workers publicam uma vez por membro. Um sistema maior agruparia os membros pelo servidor que o registo diz que os tem e publicaria uma vez por servidor, muito menos mensagens para o broker; o preço é que o registo passa para o caminho em direto, e uma falha do registo passa então a parar a entrega em direto, em vez de causar apenas notificações a mais. Com 500 membros, este desenho mantém o registo fora do caminho em direto: uma falha do registo continua a custar apenas notificações a mais.
Há 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. Aí, os leitores vão buscar as mensagens do canal quando o abrem, em vez de cada um receber uma cópia. É um produto diferente, com os seus próprios compromissos entre push e pull, e este desenho não precisa dele com 500 membros.
Onde a mensagem da Alice ainda pode ficar presa
Uma última vez, a pergunta da Alice, por todo o desenho. O telemóvel dela atribui-lhe um ID e envia-a através do balanceador de carga para um servidor de chat. O servidor guarda-a como número 42 da conversa, regista o respetivo trabalho de entrega na mesma transação e diz à Alice “enviada”. Publica no canal do Bob; ninguém está subscrito. Um worker apanha o trabalho, não encontra entrada do Bob no registo e entrega um push ao serviço de notificações, e a Apple transmite-o quando o telemóvel do Bob voltar a ligar, ou não. Uma hora depois o telemóvel volta a ligar-se, subscreve e pede tudo o que vem depois do 40. O portátil, aberto na manhã seguinte, pede tudo o que vem depois do 41. A mensagem aparece uma vez em cada dispositivo, no seu lugar, e nada no percurso dela tinha de funcionar à primeira, exceto o armazenamento.
Doze caixas: três são o telemóvel da Alice e o telemóvel e o portátil do Bob, e os dois servidores de chat representam uma dúzia. Eis o que acontece quando cada uma das outras falha, e quem dá por isso:
- Um servidor de chat morre → os seus utilizadores são desligados, voltam a ligar-se com backoff com jitter aos outros servidores, subscrevem de novo e atualizam-se por número de sequência. As mensagens enviadas entretanto foram guardadas; ninguém perde nenhuma.
- O balanceador de carga falha → os telemóveis deixam de chegar a qualquer servidor de chat. Use um gerido e redundante, ou ponha dois.
- O broker atrasa-se ou larga mensagens → a entrega em direto fica tardia ou irregular. A deteção de buracos e a sincronização periódica vão buscar ao armazenamento as mensagens em falta.
- O registo está desatualizado → pode perder-se uma notificação. O registo está em baixo → toda a gente é tratada como offline: notificações a mais, entrega em direto sem alterações.
- A fila de entrega está em baixo, ou os workers atrasam-se ou falham → os trabalhos esperam no outbox ou na fila, e o trabalho de um worker que falhou volta a correr; as notificações e as mensagens de grupo chegam tarde, as mensagens individuais continuam a chegar em direto, e a Alice continua a enviar.
- O serviço de notificações, ou o serviço de push por trás dele, está lento ou em baixo → as notificações chegam tarde ou não chegam; tudo está na aplicação quando ela abrir.
- O armazenamento de mensagens está em baixo → o envio para. O telemóvel 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 todas as garantias deste desenho começam em “a mensagem está guardada”. Corra-o replicado, com cada escrita numa segunda máquina antes de a Alice ver “enviada”, ou um failover pode perder mensagens que lhe disseram estarem enviadas.
Além do balanceador de carga, que só tem de ser redundante, o armazenamento é a única caixa cuja falha impede a Alice de enviar, e nenhuma falha da lista pode perder uma mensagem que lhe disseram estar enviada. O broker e o serviço de push são caminhos rápidos a que é permitido falhar, porque por trás de cada um deles o armazenamento continua a ter a mensagem, e todos os dispositivos sabem pedi-la.
Fora deste desenho
- Cifragem de ponta a ponta. O encaminhamento deste artigo sobrevive-lhe; o que muda é o que o servidor consegue ler, matéria que o desenho de chat explicado no Learn e o Desafio Mensagens com Cifra Ponta a Ponta tratam.
- Confirmações de leitura e indicadores de escrita. Ambos são estado efémero sobre uma conversa e não mensagens dentro dela. Um indicador de escrita pode perder-se sem prejuízo; uma confirmação de leitura está mais próxima de uma mensagem e costuma ser guardada.
- Fotografias, vídeo e ficheiros. Os anexos vão para armazenamento de objetos, e a mensagem leva uma referência para eles, não os bytes.
- Chamadas de voz e de vídeo, que são multimédia em tempo real com os seus próprios protocolos.
- Pesquisa no histórico de mensagens, um índice à parte alimentado a partir do armazenamento.
- Várias regiões. O Bob e a Alice estão aqui no mesmo continente.
Desenhe-o você mesmo
O Desafio Sistema de Chat pede esta arquitetura. A sua paleta nomeia produtos (MongoDB, Redis, Kafka, um fornecedor de push) onde este artigo desenha caixas genéricas; um tópico Kafka pode fazer de fila de entrega. Desenhe-a e depois envie a pergunta da Alice a um Bob com o telemóvel desligado.