Alice écrit « On est toujours partants pour samedi ? » et appuie sur envoyer. Le téléphone de Bob est dans un tiroir, batterie vide, et son ordinateur portable est fermé sur le bureau. Une heure plus tard, il branche son téléphone et le message doit être là : une seule fois, à la bonne place dans la conversation, et aussi sur l'ordinateur quand il l'ouvrira.
Alors, où est Bob ? Il peut être connecté au même serveur qu'Alice, à un autre, à aucun, ou à deux à la fois avec deux appareils. Chacun de ces cas demande sa propre façon de faire arriver le message, et l'essentiel d'un backend de chat est la somme de ces façons.
La suite de cet article suit ce seul message. Chaque section ci-dessous est un cas que la version précédente ne sait pas gérer, le plus souvent un endroit où Bob peut se trouver, puis le plus petit changement qui le gère, avec son coût. Si vous connaissez les backends de chat, les titres racontent l'histoire et le dernier schéma est le résultat ; sinon, commencez là où tout tourne sur un seul serveur. Learn propose la conception finale, un chat en temps réel détaillé ; cet article raconte comment on arrive à une telle conception.
Deux millions de personnes, un demi-million de sockets
Le produit est un chat individuel et de groupe dans une application mobile. Tous les chiffres ici sont inventés pour l'exercice et arrondis pour garder des calculs simples ; aucun n'a été mesuré sur un vrai service :
- 2 millions d'utilisateurs par jour. Au pic du soir, environ 300 000 sont connectés en même temps, beaucoup avec deux appareils, soit un demi-million de connexions ouvertes.
- Environ 60 messages par utilisateur et par jour : 120 millions par jour, soit environ 1 400 par seconde en moyenne, et plusieurs fois plus au pic du soir, disons 4 000 par seconde.
- Un serveur de chat tient environ 50 000 connexions WebSocket, pour la plupart inactives. C'est une hypothèse de dimensionnement pour cet exercice ; le chiffre réel dépend de la mémoire par connexion, de TLS et de ce que le serveur fait de chacune.
- Un groupe compte 500 membres au maximum. C'est une limite du produit, posée comme telle.
- Un message stocké occupe environ 200 octets avec ses identifiants et ses horodatages : près de 24 Go par jour.
Regardez la première et la troisième ligne ensemble. Un demi-million de connexions à 50 000 par serveur, cela fait dix serveurs rien que pour garder tout le monde connecté, avant même d'envoyer un seul message. Quelques milliers de messages par seconde, c'est un travail ordinaire pour une base de données. Avec ces chiffres, les connexions ouvertes atteignent leur limite bien avant les messages par seconde.
Avant de dessiner quoi que ce soit, trois limites de temps, toutes des hypothèses. Alice doit voir « envoyé » bien moins d'une seconde après avoir appuyé sur envoyer, et seulement une fois le message stocké. Un Bob connecté doit le voir en moins d'une seconde. Pour un Bob hors ligne, une notification doit partir en quelques secondes, et il doit retrouver toute la conversation en ouvrant l'application. La troisième limite a deux moitiés, et pour une raison : la notification dit seulement à Bob d'aller voir, et c'est le stockage qui lui remet vraiment le message.
Tout le monde sur un seul serveur
Commençons par le cas où tout le monde est au même endroit. Le téléphone d'Alice et celui de Bob gardent chacun une WebSocket ouverte vers un seul serveur de chat. Une WebSocket est une connexion qui reste ouverte dans les deux sens, si bien que le serveur peut envoyer un message à Bob dès qu'il en a un, au lieu d'attendre que son téléphone le demande. Une requête et une réponse ordinaires ne le permettent pas : le serveur ne répond que lorsque le client demande.
Quand le message d'Alice arrive, le serveur fait trois choses, dans cet ordre : il écrit le message dans le stockage des messages, il envoie un accusé de réception à Alice (son téléphone affiche « envoyé »), puis il écrit le message sur la socket de Bob. Cet ordre est la première vraie décision de la conception. Si le serveur livrait d'abord et stockait ensuite, un plantage entre les deux laisserait un message que Bob a déjà lu et que le système n'a plus : absent de l'historique d'Alice, et de tout appareil que Bob utilisera ensuite. On stocke d'abord, on livre ensuite, et tout message que quelqu'un a vu est un message que le système possède encore.
Le serveur de chat stocke le message avant de l'écrire sur la socket de Bob.
En savoir plusTransport temps réel : long-polling vs SSE vs WebSocketWebSockets à grande échelle : passerelles, routage et drainage
Le stockage des messages peut être une base de données relationnelle ordinaire : une table de messages avec la conversation, l'expéditeur, le texte et un horodatage. Et le téléphone éteint de Bob ? Dans cette version, le message d'Alice attend dans le stockage, et quand Bob ouvrira l'application, elle chargera les messages récents de chaque conversation. Bob le recevra donc un jour, s'il lui arrive d'ouvrir l'application. Rien ne le prévient.
Pour un lancement avec quelques milliers de personnes en ligne, cela suffit. Un serveur tient toutes les sockets, trouve celle de Bob dans sa propre mémoire et y écrit. Les coûts sont pourtant déjà visibles. Le serveur est un point de défaillance unique : quand il redémarre, tous les utilisateurs sont déconnectés d'un coup. Et il a un plafond qui n'a rien à voir avec les messages : vers 50 000 connexions, il est plein, alors que notre pic du soir en demande dix fois plus.
Bob est sur un autre serveur
Il y a donc maintenant plusieurs serveurs de chat, une douzaine pour le pic du soir, ce qui laisse de la marge pour en perdre un, avec un répartiteur de charge devant, qui choisit un serveur pour chaque nouvelle connexion. Une WebSocket reste sur le serveur où elle a été ouverte jusqu'à sa fermeture : une fois le choix fait par le répartiteur de charge, c'est là que vit l'utilisateur.
Rejouons le message d'Alice, avec cette fois le téléphone de Bob allumé. La connexion d'Alice a atterri sur un serveur ; celle de Bob sur un autre. Le serveur d'Alice stocke le message, lui envoie l'accusé de réception, cherche la socket de Bob dans sa propre mémoire et ne trouve rien. Bob est connecté, mais pas ici.
Les serveurs ont besoin d'un moyen de se passer des messages, et le plus simple est la publication/abonnement (pub/sub). Chaque utilisateur a un canal sur un broker pub/sub. Quand la socket de Bob s'ouvre sur un serveur, ce serveur s'abonne au canal de Bob, et il se désabonne quand sa dernière socket s'y ferme. Le serveur d'Alice n'a pas besoin de savoir où est Bob : il publie le message sur le canal de Bob, le broker le remet au serveur abonné, quel qu'il soit, et ce serveur l'écrit sur la socket de Bob.
Le serveur d'Alice publie sur le canal de Bob ; le serveur qui tient la socket de Bob y est abonné.
En savoir plusRépartition de charge et mise à l'échelle horizontalePub/sub : topics, abonnements et rejeu
Un broker simple comme Redis Pub/Sub ne conserve rien : il livre à ceux qui sont abonnés à cet instant, et un serveur dont la liaison coupe deux secondes perd ces deux secondes pour de bon. Cela semble alarmant et reste acceptable ici, pour la raison que la version à un serveur donnait déjà : le message a été stocké avant d'être publié. Le broker est un chemin rapide vers un Bob connecté, pas l'endroit où vivent ses messages. Ce qui demande de l'attention, c'est la façon dont Bob récupère ce qu'un chemin rapide a laissé tomber.
Que se passe-t-il quand un serveur de chat meurt avec 50 000 sockets ? Chacun de ces clients s'en aperçoit en quelques secondes et se reconnecte, via le répartiteur de charge, aux autres serveurs, qui se réabonnent à leurs canaux. Les messages publiés sur ces canaux pendant l'intervalle n'ont atteint personne, mais ils sont dans le stockage, et chaque téléphone charge ce qu'il a manqué en se reconnectant. Un détail décide si cela marche : un téléphone qui se reconnecte doit s'abonner d'abord et interroger le stockage ensuite. Dans l'ordre inverse, un message stocké entre les deux étapes n'est ni dans la réponse ni livré en direct.
La reconnexion elle-même est le deuxième coût d'avoir plusieurs serveurs. Cinquante mille téléphones qui se reconnectent tous dans la même seconde, chacun ouvrant une connexion chiffrée (TLS), vérifiant un jeton et demandant au stockage ce qu'il a manqué, peuvent surcharger les serveurs encore debout ; s'ils ralentissent, les handshakes expirent, les téléphones réessaient, et la charge s'auto-entretient. Les clients attendent un délai aléatoire et croissant avant de se reconnecter (backoff avec jitter), et les déploiements ferment les sockets par lots plutôt que toutes à la fois (draining). Cette panne a son propre article sur ce blog, lié à la fin. Cela explique aussi la douzaine de serveurs plutôt que dix : les survivants ont besoin de marge pour absorber les connexions d'un serveur.
Bob est hors ligne
Voici le cas par lequel l'article a commencé. Le téléphone de Bob est éteint. Le serveur d'Alice stocke le message, lui envoie l'accusé de réception et publie sur le canal de Bob. Personne n'y est abonné, donc le broker ne le livre à personne, et c'est tout. Rien dans cette conception n'enregistre que Bob est hors ligne, donc rien ne lui dit qu'un message l'attend. Le message est en sécurité dans le stockage et invisible jusqu'à ce que Bob ouvre l'application de lui-même.
Pour notifier Bob, le serveur doit savoir qu'il n'est connecté nulle part. C'est le rôle d'un registre de connexions : un magasin clé-valeur rapide qui associe chaque utilisateur aux serveurs de chat qui tiennent une socket pour lui. Un serveur écrit l'entrée de Bob quand sa première socket s'y ouvre et la supprime quand la dernière se ferme. Un serveur qui plante ne supprime rien, et un téléphone dont la batterie meurt ne ferme rien, donc chaque entrée porte une durée de vie (TTL) que le serveur ne renouvelle que tant que le téléphone répond à ses heartbeats ; quand l'un des deux se tait, ses entrées expirent en quelques secondes. Le même registre peut répondre à « Bob est-il en ligne ? » pour le point vert que voient les autres utilisateurs, même si un point vraiment fiable demande des heartbeats et un délai de grâce, ce que couvre l'article de Learn sur la présence.
Grâce au registre, le serveur d'Alice peut distinguer les deux cas. Si Bob a une entrée, la publication devrait l'atteindre et aucun push n'est nécessaire. S'il n'en a pas, le serveur place un job de push dans une file de livraison, et un service de notifications prend les jobs dans la file et envoie une notification push via le service de push de la plateforme du téléphone : Apple Push Notification service (APNs) pour les iPhone, Firebase Cloud Messaging (FCM) pour Android. L'arête en pointillés vers le téléphone de Bob dans le schéma représente ce détour par Apple ou Google.
Pas d'entrée dans le registre, donc pas de socket nulle part : le serveur met un job de push en file.
En savoir plusPrésence et état éphémèreNotifications et messagerie transactionnelleFiles de messages et workers asynchrones
Pourquoi une file entre le serveur de chat et le service de notifications ? Parce que le service de push appartient à quelqu'un d'autre, avec sa propre latence et ses mauvais jours, et qu'Alice ne doit jamais l'attendre. Son message est stocké et acquitté, qu'Apple réponde vite ou non.
Le push dit à Bob d'aller voir, mais il ne livre pas la conversation. APNs et FCM ne promettent pas que chaque notification arrive : un téléphone resté éteint des heures peut en recevoir certaines en retard, plusieurs fusionnées en une, ou aucune. La livraison reste donc là où elle était. Quand Bob ouvre l'application, son téléphone demande au stockage tous les messages postérieurs au dernier qu'il possède. Dans cette version, le serveur de chat marque chaque message avec sa propre horloge quand il le stocke, et « le dernier » désigne l'horodatage du message le plus récent sur le téléphone. Gardez un œil sur ce curseur ; la section suivante le démonte.
Les nouvelles briques tombent en panne de façons qui méritent d'être nommées :
- Le service de push est lent ou en panne. Les jobs s'accumulent dans la file et les notifications arrivent en retard. Le chat lui-même n'est pas touché, et Bob reçoit quand même tout en ouvrant l'application.
- Le registre est périmé. Pendant quelques secondes après le plantage d'un serveur de chat, l'entrée de Bob pointe encore vers lui. Un message envoyé dans cette fenêtre est publié sur le canal de Bob, auquel plus aucun serveur actif n'est abonné, et aucun push ne part, puisque le registre disait qu'il était connecté. Quand son téléphone se reconnecte et se met à jour, le message est là. Un registre périmé coûte une notification, pas un message.
- Le registre est en panne. Le serveur ne peut plus distinguer connecté et hors ligne, et doit parier dans un sens. Cette conception traite tout le monde comme hors ligne : elle publie quand même sur le canal du destinataire, et met aussi un push en file. Le coût, ce sont des notifications redondantes pour des gens qui ont déjà vu le message ; l'autre pari coûterait des notifications manquées pour des gens qui ne l'ont pas vu, ce qui est pire. La livraison en direct ne consulte jamais le registre, elle continue donc.
Bob sur deux appareils, et un message envoyé deux fois
Bob a aussi un ordinateur portable. Certains soirs, les deux appareils sont connectés en même temps, et le routage gère déjà cela : dans le schéma, l'ordinateur est sur le même serveur que le téléphone, qui s'est abonné au canal de Bob à l'arrivée de sa première socket ; sur tout autre serveur, ce serveur s'abonnerait lui aussi à son canal. Ce soir, c'est l'autre cas : l'ordinateur était ouvert plus tôt dans la soirée, alors que le téléphone était déjà mort dans le tiroir. Ce qui casse maintenant est plus subtil : trois façons pour le même message d'atteindre Bob de travers, et chacune se corrige par une règle plutôt que par une nouvelle brique.
Deux fois. Le message d'Alice est stocké, mais l'accusé de réception n'atteint jamais son téléphone ; elle est entrée dans un tunnel. Son téléphone fait ce qu'il doit et renvoie le message, et Bob le voit deux fois. La correction commence sur le téléphone d'Alice : il donne un identifiant à chaque message quand elle appuie sur envoyer, et un renvoi porte le même identifiant. Le stockage refuse un second message dont l'identifiant existe déjà dans cette conversation et répond au renvoi avec l'accusé de réception de l'original, et chaque client ignore un message dont il affiche déjà l'identifiant. Renvoyer jusqu'à recevoir un accusé de réception donne une livraison au moins une fois ; la déduplication par identifiant la transforme en affichage une seule fois.
Dans le désordre, ou avec des trous. Le curseur d'horodatage du cas hors ligne perd des messages, et pas rarement. Les horloges de deux serveurs de chat diffèrent de quelques millisecondes, si bien qu'un message stocké plus tard peut porter un horodatage plus ancien. Deux messages peuvent partager la même milliseconde. Et un message dont l'écriture met un peu plus de temps à être validée peut apparaître dans le stockage après que le téléphone de Bob a déjà lu au-delà de son horodatage ; demander « tout ce qui suit l'horodatage le plus récent que j'ai » le saute alors pour toujours.
La correction est un numéro de séquence par conversation, attribué par le stockage dans la même écriture que celle qui stocke le message : 41, 42, 43, sans que deux messages en partagent un. Dans un stockage relationnel, cela peut être un compteur sur la ligne de la conversation, incrémenté dans la même transaction que l'insertion du message, de sorte que les écritures concurrentes dans une conversation prennent leurs numéros l'une après l'autre. Chaque conversation a ainsi exactement une autorité pour son ordre. Nous supposons que même un groupe actif envoie bien moins de messages par seconde qu'une ligne ne peut encaisser de mises à jour, donc attendre cette ligne ne coûte rien de perceptible avec ces chiffres.
Chaque appareil garde ensuite son propre « dernier numéro de séquence que j'ai » pour chaque conversation. Le téléphone de Bob est mort en connaissant jusqu'à 40 ; l'ordinateur, ouvert plus tôt dans la soirée, connaît jusqu'à 41, le dernier message avant la question d'Alice. Quand le téléphone se reconnecte, il demande tout ce qui suit 40 dans cette conversation ; quand l'ordinateur est ouvert, il demande tout ce qui suit 41. Les deux se mettent à jour indépendamment, puisque chacun a pu manquer des messages différents.
Un trou pendant la connexion. Le broker peut perdre un message alors que les sockets de Bob restent ouvertes, si bien que son téléphone ne se reconnecte jamais et ne se met jamais à jour. Les numéros de séquence rendent cela visible : un appareil qui reçoit 41 puis 43 sait que 42 existe, le demande au stockage et garde son curseur à 41 jusqu'à l'arrivée de 42 ; un curseur qui aurait sauté à 43 ignorerait 42 pour de bon si l'appareil mourait avant. Un trou tout à la fin d'une conversation calme n'a pas de message suivant pour le révéler, donc les clients demandent aussi de temps en temps au stockage le dernier numéro de séquence de chaque conversation.
Aucun nouveau service : identifiants de message, numéros de séquence par conversation et un curseur par appareil.
En savoir plusMessage DeduplicationIdempotence et illusions de l'exactement-une-fois
Le numéro de séquence dit aussi comment le stockage va grandir. À 24 Go par jour, soit environ 9 To par an, il finira tôt ou tard par dépasser une seule base de données, et à ce moment-là, la conversation est la clé de partition naturelle : chaque rattrapage ci-dessus lit une conversation, et l'autorité de séquence d'une conversation vit dans la même partition que ses messages. C'est une étape future, pas celle-ci, donc le schéma garde une seule brique.
Une question que cela laisse au produit : quand Bob est connecté sur l'ordinateur et que son téléphone est éteint, le téléphone doit-il aussi recevoir une notification ? Dans cette conception, non, parce qu'on demande au registre si Bob a une socket quelque part, pas sur chaque appareil. Les applications de messagerie répondent différemment à cette question, et les deux réponses fonctionnent avec le reste de la conception.
Alice écrit à 500 personnes
Alice pose la même question dans le groupe de son quartier, 500 membres : « On est toujours partants pour samedi ? » Passez cela dans la conception actuelle et le chemin d'envoi devient une boucle : pour chacun des 499 autres membres, le chercher dans le registre, publier sur son canal et mettre un push en file pour chacun de ceux qui sont hors ligne. Le travail du serveur de chat par message croît maintenant avec la taille du groupe, sur les mêmes serveurs qui tiennent les sockets de tout le monde. Pire, le serveur acquitte Alice une fois le message stocké, avant la fin de cette boucle ; un serveur qui plante au milieu a déjà dit « envoyé » à Alice, et les pushes qu'il n'avait pas encore mis en file sont tout simplement perdus. Cette faille existait déjà dans la conception individuelle, entre le stockage d'un message et la mise en file de son push ; un groupe étire la fenêtre sur le travail de 499 membres.
La solution est de sortir le fan-out du chemin d'envoi. Le serveur de chat stocke le message et, dans la même transaction de base de données, enregistre un job : livrer le message 42 de ce groupe. Un petit relais dans les serveurs de chat déplace les jobs enregistrés vers la file de livraison. Écrire le job dans la même transaction que le message est ce qui rend l'accusé de réception sûr : si le message est stocké, son job existe, même si le serveur meurt à l'instant suivant. C'est le pattern outbox transactionnel, et il coûte une table de plus dans une base où le serveur écrit déjà. Il referme aussi la faille du cas individuel, puisque le job de chaque message est désormais enregistré ainsi.
Il répond aussi à une question que la file de livraison avait soulevée à son arrivée : et si la file est en panne ? Le relais ne peut plus déplacer les jobs, qui attendent donc dans la table outbox. Alice continue d'envoyer pendant que la table outbox grossit, et les notifications et les messages de groupe arrivent quand la file revient. Les messages individuels, qui gardent aussi une publication directe, arrivent toujours en direct.
Les workers de fan-out prennent les jobs dans la file et font la boucle loin des serveurs qui tiennent les sockets. Le job ne porte que le message et le groupe. Un worker lit la liste des membres dans le stockage, publie le message sur le canal de chaque membre, demande au registre en une seule requête groupée quels membres n'ont pas de socket, et les passe au service de notifications. Un worker n'acquitte un job qu'une fois sa boucle terminée et les pushes à envoyer enregistrés par le service de notifications, et le relais ne marque un job comme déplacé qu'une fois que la file l'a enregistré, si bien qu'un plantage d'un côté ou de l'autre répète le travail au lieu de le perdre : un membre peut recevoir le message deux fois, ce que son identifiant absorbe, ou une seconde notification. Ces lectures et la consultation du registre ne sont pas dessinées, pour éviter des lignes qui se croisent. Interroger le registre à l'exécution du job, plutôt qu'à l'envoi d'Alice, signifie aussi qu'un worker en retard décide d'après qui est connecté maintenant, pas d'après qui l'était à l'envoi du message. La liste des membres fonctionne à l'inverse : le worker lit le groupe tel qu'il était au message 42 (chaque appartenance enregistre les numéros de séquence où elle commence et se termine), si bien que quelqu'un qui rejoint une seconde après l'envoi d'Alice ne reçoit pas un message antérieur à son arrivée. Les jobs de push des messages individuels suivent maintenant le même chemin, comme des jobs à un seul destinataire, si bien que les serveurs de chat cessent de lire le registre : ils n'écrivent que les entrées des sockets qu'ils tiennent, et ce sont les workers qui lisent.
Un job durable par message ; les workers font le travail par membre.
En savoir plusFan-out : push vs pullTransactional OutboxConception résolue : un chat en temps réel
Les messages individuels gardent leur publication directe sur le canal du destinataire, donc le cas courant n'est pas plus lent. Les messages de groupe mettent quelques millisecondes de plus à atteindre les membres connectés, parce qu'ils passent d'abord par la file et un worker. En échange, la file devient l'endroit où un retard se voit : si les workers prennent du retard, les messages de groupe et les notifications arrivent tard, alors que les messages individuels arrivent toujours en direct.
Les workers publient une fois par membre. Un système plus grand regrouperait les membres par serveur d'après le registre et publierait une fois par serveur, bien moins de messages pour le broker ; en contrepartie, le registre passe sur le chemin en direct, et une panne du registre arrête alors la livraison en direct au lieu de causer seulement des notifications en trop. À 500 membres, cette conception garde le registre hors du chemin en direct : une panne du registre ne coûte toujours que des notifications en trop.
Il existe une taille au-delà de laquelle pousser une copie à chaque membre n'a plus aucun sens : un canal suivi par des centaines de milliers de personnes. Là, les lecteurs récupèrent les messages du canal en l'ouvrant, au lieu de recevoir chacun une copie. C'est un autre produit, avec ses propres compromis entre push et pull, et cette conception n'en a pas besoin à 500 membres.
Où le message d'Alice peut encore rester bloqué
Une dernière fois, la question d'Alice, à travers tout le schéma. Son téléphone lui donne un identifiant et l'envoie par le répartiteur de charge à un serveur de chat. Le serveur la stocke sous le numéro 42 de la conversation, enregistre son job de livraison dans la même transaction et dit « envoyé » à Alice. Il publie sur le canal de Bob ; personne n'y est abonné. Un worker prend le job, ne trouve aucune entrée pour Bob dans le registre et passe un push au service de notifications, et Apple le transmet quand le téléphone de Bob est rallumé, ou pas. Une heure plus tard, le téléphone se reconnecte, s'abonne et demande tout ce qui suit 40. L'ordinateur, ouvert le lendemain matin, demande tout ce qui suit 41. Le message s'affiche une fois sur chaque appareil, à sa place, et rien sur son trajet n'avait besoin de marcher du premier coup, sauf le stockage.
Douze briques : trois sont le téléphone d'Alice, et le téléphone et l'ordinateur portable de Bob, et les deux serveurs de chat en représentent une douzaine. Voici ce qui se passe quand chacune des autres tombe en panne, et qui s'en aperçoit :
- Un serveur de chat meurt → ses utilisateurs sont déconnectés, se reconnectent avec un backoff et du jitter aux autres serveurs, se réabonnent et se mettent à jour grâce aux numéros de séquence. Les messages envoyés entre-temps ont été stockés ; personne n'en perd un.
- Le répartiteur de charge tombe → les téléphones ne peuvent plus joindre aucun serveur de chat. Utilisez-en un géré et redondant, ou faites-en tourner deux.
- Le broker prend du retard ou perd des messages → la livraison en direct est tardive ou lacunaire. La détection des trous et la synchronisation périodique récupèrent les messages manquants dans le stockage.
- Le registre est périmé → une notification peut être manquée. Le registre est en panne → tout le monde est traité comme hors ligne : des notifications en trop, livraison en direct inchangée.
- La file de livraison est en panne, ou les workers prennent du retard ou plantent → les jobs attendent dans l'outbox ou la file, et le job d'un worker planté est rejoué ; les notifications et les messages de groupe sont en retard, les messages individuels arrivent toujours en direct, et Alice continue d'envoyer.
- Le service de notifications, ou le service de push derrière lui, est lent ou en panne → les notifications sont en retard ou manquantes ; tout est dans l'application à son ouverture.
- Le stockage des messages est en panne → l'envoi s'arrête. Le téléphone d'Alice garde le message et réessaie avec le même identifiant. C'est la seule dépendance que le chemin d'envoi ne peut pas contourner, parce que chaque garantie de cette conception commence par « le message est stocké ». Faites-le tourner en réplication, chaque écriture étant sur une seconde machine avant qu'Alice voie « envoyé », sinon un failover peut perdre des messages dont on lui avait dit qu'ils étaient envoyés.
À part le répartiteur de charge, qui doit seulement être redondant, le stockage est la seule brique dont la panne empêche Alice d'envoyer, et aucune panne de la liste ne peut perdre un message dont on lui a dit qu'il était envoyé. Le broker et le service de push sont des chemins rapides qui ont le droit de tomber en panne, parce que derrière chacun d'eux le stockage détient toujours le message, et que chaque appareil sait le lui demander.
Hors du périmètre de cette conception
- Le chiffrement de bout en bout. Le routage décrit ici y résiste ; ce qui change, c'est ce que le serveur peut lire, ce que couvrent la conception de chat détaillée dans Learn et le Défi Messagerie Chiffrée de Bout en Bout.
- Les accusés de lecture et les indicateurs de saisie. Les deux sont un état éphémère à propos d'une conversation plutôt que des messages qu'elle contient. Un indicateur de saisie peut être perdu sans dommage ; un accusé de lecture est plus proche d'un message et est généralement stocké.
- Les photos, les vidéos et les fichiers. Les pièces jointes vont dans un stockage d'objets, et le message porte une référence vers elles, pas les octets.
- Les appels vocaux et vidéo, qui sont des flux média en temps réel avec leurs propres protocoles.
- La recherche dans l'historique des messages, un index séparé alimenté depuis le stockage.
- Plusieurs régions. Bob et Alice sont ici sur le même continent.
À vous de le dessiner
Le Défi Système de chat demande cette architecture. Sa palette nomme des produits (MongoDB, Redis, Kafka, un fournisseur de push) là où cet article dessine des briques génériques ; un topic Kafka peut jouer le rôle de la file de livraison. Dessinez-la, puis envoyez la question d'Alice à un Bob dont le téléphone est éteint.