Systemdesign

Wie eine Chat-Nachricht jemanden erreicht, der offline ist

Alice schickt eine Nachricht, während Bobs Handy aus ist. Ob sie ihn erreicht, genau einmal und in der richtigen Reihenfolge auf jedem Gerät, hängt davon ab, zu wissen, wo er ist: auf einem anderen Server, nirgends oder auf zwei Geräten gleichzeitig. Fünf Versionen eines Chat-Backends, von einem Server bis zu einer Gruppe mit 500 Mitgliedern.

Zur finalen Architektur springen

Alice tippt „Bleibt es bei Samstag?“ und drückt auf Senden. Bobs Handy liegt mit leerem Akku in der Schublade, sein Laptop ist zugeklappt und steht auf dem Schreibtisch. Eine Stunde später steckt er das Handy ans Ladekabel, und die Nachricht sollte da sein: genau einmal, an der richtigen Stelle im Gespräch, und auch auf dem Laptop, sobald er ihn aufklappt.

Wo ist Bob also? Er kann mit demselben Server verbunden sein wie Alice, mit einem anderen, mit keinem oder von zwei Geräten aus mit zwei Servern gleichzeitig. Für jeden dieser Orte braucht die Nachricht einen eigenen Weg zu ihm, und ein Chat-Backend ist zum größten Teil die Summe dieser Wege.

Der Rest dieses Beitrags folgt genau dieser einen Nachricht. Jeder Abschnitt ist ein Fall, den die Version davor nicht abdeckt, meistens ein Ort, an dem Bob sein kann, und die kleinste Änderung, die ihn abdeckt, samt ihrem Preis. Wenn du Chat-Backends kennst, erzählen die Überschriften die Geschichte, und die letzte Zeichnung ist das Ergebnis; wenn nicht, fang dort an, wo alles auf einem Server läuft. In Learn gibt es das fertige Design, einen durchgearbeiteten Realtime-Chat; in diesem Beitrag geht es darum, wie ein solches Design entsteht.

Zwei Millionen Menschen, eine halbe Million Sockets

Das Produkt ist Einzel- und Gruppenchat in einer mobilen App. Alle Zahlen hier sind für die Übung ausgedacht und gerundet, damit sich leicht rechnen lässt; keine ist an einem echten Dienst gemessen:

  • 2 Millionen tägliche Nutzer. In der Abendspitze sind etwa 300.000 gleichzeitig verbunden, viele von zwei Geräten aus, also rechnen wir mit einer halben Million offener Verbindungen.
  • Etwa 60 Nachrichten pro Nutzer und Tag: 120 Millionen am Tag, im Schnitt rund 1.400 pro Sekunde und in der Abendspitze ein Mehrfaches davon, sagen wir 4.000 pro Sekunde.
  • Ein Chat-Server hält etwa 50.000 meist ruhende WebSocket-Verbindungen. Das ist eine Dimensionierungsannahme für diese Übung; die reale Zahl hängt vom Speicher pro Verbindung, von TLS und davon ab, was der Server mit jeder Verbindung macht.
  • Gruppen haben höchstens 500 Mitglieder. Das ist eine Produktgrenze und als solche gesetzt.
  • Eine gespeicherte Nachricht braucht etwa 200 Byte mit IDs und Zeitstempeln: rund 24 GB am Tag.

Schau dir die erste und die dritte Zeile zusammen an. Eine halbe Million Verbindungen bei 50.000 pro Server sind zehn Server, nur um alle verbunden zu halten, noch bevor eine einzige Nachricht verschickt wurde. Ein paar tausend Nachrichten pro Sekunde sind für eine Datenbank normale Arbeit. Mit diesen Zahlen gehen die offenen Verbindungen aus, lange bevor die Nachrichten pro Sekunde zum Problem werden.

Bevor wir etwas zeichnen, drei Zeitgrenzen, alle angenommen. Alice sollte „gesendet“ deutlich unter einer Sekunde nach dem Senden sehen, und erst, wenn die Nachricht gespeichert ist. Ein verbundener Bob sollte sie innerhalb einer Sekunde sehen. Für einen Offline-Bob sollte innerhalb von Sekunden eine Benachrichtigung rausgehen, und er sollte das ganze Gespräch vorfinden, wenn er die App öffnet. Die dritte Grenze hat aus gutem Grund zwei Hälften: Die Benachrichtigung sagt Bob nur, dass er nachsehen soll, und der Speicher ist es, der ihm die Nachricht tatsächlich übergibt.

Alle auf einem Server

Wir beginnen mit dem Fall, in dem alle am selben Ort sind. Alices Handy und Bobs Handy halten jeweils eine WebSocket-Verbindung zu einem Chat-Server offen. Ein WebSocket ist eine Verbindung, die in beide Richtungen offen bleibt, sodass der Server Bob eine Nachricht schicken kann, sobald er eine hat, statt zu warten, bis sein Handy nachfragt. Ein gewöhnliches Request-Response-Muster kann das nicht: Der Server antwortet nur, wenn der Client fragt.

Wenn Alices Nachricht eintrifft, macht der Server drei Dinge, in dieser Reihenfolge: Er schreibt die Nachricht in den Nachrichtenspeicher, er bestätigt sie Alice (ihr Handy zeigt „gesendet“) und er schreibt sie auf Bobs Socket. Die Reihenfolge ist die erste echte Entscheidung im Design. Würde der Server erst zustellen und dann speichern, hinterließe ein Absturz dazwischen eine Nachricht, die Bob schon gelesen hat und die das System nicht mehr kennt: Sie fehlt in Alices Verlauf und auf jedem Gerät, das Bob als Nächstes benutzt. Erst speichern, dann zustellen, und jede Nachricht, die jemand gesehen hat, ist eine Nachricht, die das System noch hat.

Schritt 1 von 5: Ein Server: erst speichern, dann zustellen
Ein Server: erst speichern, dann zustellenAlices Handy und Bobs Handy halten je einen WebSocket zu einem einzigen Chat-Server. Der Chat-Server schreibt jede Nachricht in den Nachrichtenspeicher, eine relationale Datenbank, und schickt sie dann über Bobs WebSocket.WebSocketAlices HandySPA / MobilCLIENTS & UIChat-ServerEchtzeitserver (WebSocket / SSE)Echtzeitserver(WebSocket / SSE)DIENSTE & APISNachrichten-DBGenerischer SQL-SpeicherDATENSPEICHERBobs HandySPA / MobilCLIENTS & UI
Ein Server: erst speichern, dann zustellenAlices Handy und Bobs Handy halten je einen WebSocket zu einem einzigen Chat-Server. Der Chat-Server schreibt jede Nachricht in den Nachrichtenspeicher, eine relationale Datenbank, und schickt sie dann über Bobs WebSocket.WebSocketAlices HandySPA / MobilCLIENTS & UIChat-ServerEchtzeitserver (WebSocket / SSE)Echtzeitserver(WebSocket / SSE)DIENSTE & APISNachrichten-DBGenerischer SQL-SpeicherDATENSPEICHERBobs HandySPA / MobilCLIENTS & UI

Der Chat-Server speichert die Nachricht, bevor er sie auf Bobs Socket schreibt.

Mehr erfahrenEchtzeit-Transport: Long-Polling vs. SSE vs. WebSocketWebSockets im großen Maßstab: Gateways, Routing und Draining

Der Nachrichtenspeicher kann eine gewöhnliche relationale Datenbank sein: eine Tabelle mit Nachrichten, in der Konversation, Absender, Text und Zeitstempel stehen. Und Bobs leeres Handy? In dieser Version wartet Alices Nachricht im Speicher, und wenn Bob die App das nächste Mal öffnet, lädt sie die letzten Nachrichten jeder Konversation. Bob bekommt sie also irgendwann, falls er die App von sich aus öffnet. Nichts sagt ihm Bescheid.

Für einen Start mit ein paar tausend Leuten online reicht das. Ein Server hält alle Sockets, findet Bobs in seinem eigenen Speicher und schreibt darauf. Die Kosten sind aber schon sichtbar. Der Server ist ein Single Point of Failure: Wenn er neu startet, werden alle Nutzer auf einmal getrennt. Und er hat eine Obergrenze, die mit Nachrichten nichts zu tun hat: Bei etwa 50.000 Verbindungen ist er voll, und unsere Abendspitze braucht das Zehnfache.

Bob ist auf einem anderen Server

Es gibt jetzt also mehrere Chat-Server, für die Abendspitze etwa ein Dutzend, was Spielraum lässt, einen zu verlieren, und davor einen Lastverteiler, der für jede neue Verbindung einen Server auswählt. Ein WebSocket bleibt auf dem Server, auf dem er geöffnet wurde, bis er geschlossen wird; hat der Lastverteiler einmal gewählt, wohnt der Nutzer also dort.

Spielen wir Alices Nachricht noch einmal durch, diesmal mit eingeschaltetem Handy bei Bob. Alices Verbindung ist auf einem Server gelandet, Bobs auf einem anderen. Alices Server speichert die Nachricht, bestätigt sie ihr, sucht Bobs Socket in seinem eigenen Speicher und findet nichts. Bob ist verbunden, nur nicht hier.

Die Server brauchen eine Möglichkeit, Nachrichten aneinander weiterzugeben, und die einfachste ist Publish/Subscribe (Pub/Sub). Jeder Nutzer bekommt einen Kanal auf einem Pub/Sub-Broker. Wenn Bobs Socket auf einem Server aufgeht, abonniert dieser Server Bobs Kanal, und er beendet das Abonnement, wenn Bobs letzter Socket dort geschlossen wird. Alices Server muss nicht wissen, wo Bob ist: Er veröffentlicht die Nachricht auf Bobs Kanal, der Broker gibt sie an den Server weiter, der abonniert hat, und dieser schreibt sie auf Bobs Socket.

Schritt 2 von 5: Bob ist auf einem anderen Server
Bob ist auf einem anderen ServerEin Lastverteiler verteilt die Verbindungen jetzt auf mehrere Chat-Server. Alices Chat-Server speichert die Nachricht und veröffentlicht sie dann auf Bobs Kanal in einem Pub/Sub-Dienst; ein anderer Chat-Server, der Bobs WebSocket hält, hat diesen Kanal abonniert und stellt die Nachricht auf Bobs Handy zu.an Bobs KanalWebSocketAlices HandySPA / MobilCLIENTS & UILoad BalancerVerkehrs-RouterPLATTFORM & RUNTIMEChat-ServerEchtzeitserver (WebSocket / SSE)Echtzeitserver(WebSocket / SSE)DIENSTE & APISNachrichten-DBGenerischer SQL-SpeicherDATENSPEICHERNutzerkanälePublizieren / AbonnierenMESSAGING & WORKFLOWSWeiterer Chat-ServerWeitererChat-ServerEchtzeitserver (WebSocket / SSE)Echtzeitserver(WebSocket / SSE)DIENSTE & APISBobs HandySPA / MobilCLIENTS & UI
Bob ist auf einem anderen ServerEin Lastverteiler verteilt die Verbindungen jetzt auf mehrere Chat-Server. Alices Chat-Server speichert die Nachricht und veröffentlicht sie dann auf Bobs Kanal in einem Pub/Sub-Dienst; ein anderer Chat-Server, der Bobs WebSocket hält, hat diesen Kanal abonniert und stellt die Nachricht auf Bobs Handy zu.an Bobs KanalWebSocketAlices HandySPA / MobilCLIENTS & UILoad BalancerVerkehrs-RouterPLATTFORM & RUNTIMEChat-ServerEchtzeitserver (WebSocket / SSE)Echtzeitserver(WebSocket / SSE)DIENSTE & APISNachrichten-DBGenerischer SQL-SpeicherDATENSPEICHERNutzerkanälePublizieren / AbonnierenMESSAGING & WORKFLOWSWeiterer Chat-ServerWeitererChat-ServerEchtzeitserver (WebSocket / SSE)Echtzeitserver(WebSocket / SSE)DIENSTE & APISBobs HandySPA / MobilCLIENTS & UI

Alices Server veröffentlicht auf Bobs Kanal; der Server mit Bobs Socket hat ihn abonniert.

Mehr erfahrenLastverteilung und horizontale SkalierungPub/Sub: Topics, Subscriptions und Replay

Ein einfacher Broker wie Redis Pub/Sub behält nichts: Er liefert an alle, die in diesem Augenblick abonniert haben, und ein Server, dessen Verbindung zwei Sekunden lang abreißt, verpasst diese zwei Sekunden für immer. Das klingt alarmierend und ist hier hinnehmbar, aus dem Grund, den schon die Ein-Server-Version nannte: Die Nachricht wurde gespeichert, bevor sie veröffentlicht wurde. Der Broker ist ein schneller Weg zu einem verbundenen Bob, nicht der Ort, an dem seine Nachrichten leben. Sorgfalt braucht eher die Frage, wie Bob zurückbekommt, was der schnelle Weg verloren hat.

Was passiert, wenn ein Chat-Server mit 50.000 Sockets stirbt? Jeder dieser Clients merkt es innerhalb von Sekunden und verbindet sich über den Lastverteiler neu mit den anderen Servern, die ihre Kanäle wieder abonnieren. Nachrichten, die in der Lücke auf diesen Kanälen veröffentlicht wurden, erreichten niemanden, aber sie liegen im Speicher, und jedes Handy lädt beim Wiederverbinden nach, was es verpasst hat. Ein Detail entscheidet, ob das klappt: Ein Handy, das sich neu verbindet, sollte erst abonnieren und dann den Speicher fragen. In der umgekehrten Reihenfolge ist eine Nachricht, die zwischen den beiden Schritten gespeichert wird, weder in der Antwort noch live zugestellt.

Das Wiederverbinden selbst ist der zweite Preis mehrerer Server. Fünfzigtausend Handys, die sich in derselben Sekunde neu verbinden, jedes mit einer verschlüsselten (TLS-)Verbindung, einer Token-Prüfung und einer Anfrage an den Speicher, was es verpasst hat, können die Server überlasten, die noch stehen; werden diese langsam, laufen Handshakes in Timeouts, Handys versuchen es erneut, und die Last nährt sich selbst. Clients warten vor dem Wiederverbinden eine zufällige, wachsende Zeit (Backoff mit Jitter), und Deployments schließen Sockets in Etappen statt alle auf einmal (Draining). Dieser Ausfall hat in diesem Blog einen eigenen Beitrag, der am Ende verlinkt ist. Er erklärt auch, warum es ein Dutzend Server sind und nicht zehn: Die übrigen brauchen Platz für die Verbindungen eines Servers.

Bob ist offline

Jetzt der Fall, mit dem der Beitrag begonnen hat. Bobs Handy ist aus. Alices Server speichert die Nachricht, bestätigt sie ihr und veröffentlicht auf Bobs Kanal. Niemand hat abonniert, also liefert der Broker an niemanden, und damit ist es vorbei. Nichts in diesem Design hält fest, dass Bob offline ist, also sagt auch nichts ihm, dass eine Nachricht auf ihn wartet. Die Nachricht ist im Speicher sicher und unsichtbar, bis er die App von sich aus öffnet.

Um Bob zu benachrichtigen, muss der Server wissen, dass er nirgends verbunden ist. Das ist die Aufgabe einer Verbindungsregistry: eines schnellen Key-Value-Stores, der jeden Nutzer auf die Chat-Server abbildet, die einen Socket für ihn halten. Ein Server schreibt Bobs Eintrag, wenn dort sein erster Socket aufgeht, und entfernt ihn, wenn der letzte schließt. Ein Server, der abstürzt, entfernt nichts, und ein Handy, dessen Akku leer wird, schließt nichts; deshalb hat jeder Eintrag eine Lebensdauer (Time to live, TTL), die der Server nur verlängert, solange das Handy seine Heartbeats beantwortet. Wird eines von beidem still, laufen seine Einträge innerhalb von Sekunden ab. Dieselbe Registry kann auch „Ist Bob online?“ für den grünen Punkt beantworten, den andere Nutzer sehen, wobei ein verlässlicher Punkt Heartbeats und eine Karenzzeit braucht, was Learns Artikel zu Presence behandelt.

Mit der Registry kann Alices Server die beiden Fälle unterscheiden. Hat Bob einen Eintrag, sollte die Veröffentlichung ihn erreichen, und ein Push ist nicht nötig. Hat er keinen, legt der Server einen Push-Job in eine Zustellqueue, und ein Benachrichtigungsdienst nimmt Jobs aus der Queue und schickt eine Push-Benachrichtigung über den Push-Dienst der Handy-Plattform: Apple Push Notification service (APNs) für iPhones, Firebase Cloud Messaging (FCM) für Android. Die gestrichelte Kante zu Bobs Handy in der Zeichnung steht für diesen Umweg über Apple oder Google.

Schritt 3 von 5: Bob ist offline
Bob ist offlineEine Verbindungsregistry, ein Key-Value-Store, hält jetzt fest, welcher Chat-Server die Sockets eines Nutzers hält; der Server mit Bobs Socket schreibt seinen Eintrag. Alices Chat-Server schlägt Bob dort nach, und hat er keinen Eintrag, legt der Server einen Push-Job in eine Zustellqueue. Ein Benachrichtigungsdienst nimmt den Job und schickt über den Push-Dienst der Handy-Plattform eine Push-Benachrichtigung an Bobs Handy.an Bobs KanalWebSocketPush-JobAlices HandySPA / MobilCLIENTS & UILoad BalancerVerkehrs-RouterPLATTFORM & RUNTIMEChat-ServerEchtzeitserver (WebSocket / SSE)Echtzeitserver(WebSocket / SSE)DIENSTE & APISNachrichten-DBGenerischer SQL-SpeicherDATENSPEICHERZustellqueueWarteschlangeMESSAGING & WORKFLOWSNutzerkanälePublizieren / AbonnierenMESSAGING & WORKFLOWSVerbindungsregistryGenerische KV-AbfragenDATENSPEICHERWeiterer Chat-ServerWeitererChat-ServerEchtzeitserver (WebSocket / SSE)Echtzeitserver(WebSocket / SSE)DIENSTE & APISBenachrichtigungenPush / E-MailDIENSTE & APISBobs HandySPA / MobilCLIENTS & UI
Bob ist offlineEine Verbindungsregistry, ein Key-Value-Store, hält jetzt fest, welcher Chat-Server die Sockets eines Nutzers hält; der Server mit Bobs Socket schreibt seinen Eintrag. Alices Chat-Server schlägt Bob dort nach, und hat er keinen Eintrag, legt der Server einen Push-Job in eine Zustellqueue. Ein Benachrichtigungsdienst nimmt den Job und schickt über den Push-Dienst der Handy-Plattform eine Push-Benachrichtigung an Bobs Handy.an Bobs KanalWebSocketPush-JobAlices HandySPA / MobilCLIENTS & UILoad BalancerVerkehrs-RouterPLATTFORM & RUNTIMEChat-ServerEchtzeitserver (WebSocket / SSE)Echtzeitserver(WebSocket / SSE)DIENSTE & APISNachrichten-DBGenerischer SQL-SpeicherDATENSPEICHERZustellqueueWarteschlangeMESSAGING & WORKFLOWSNutzerkanälePublizieren / AbonnierenMESSAGING & WORKFLOWSVerbindungsregistryGenerische KV-AbfragenDATENSPEICHERWeiterer Chat-ServerWeitererChat-ServerEchtzeitserver (WebSocket / SSE)Echtzeitserver(WebSocket / SSE)DIENSTE & APISBenachrichtigungenPush / E-MailDIENSTE & APISBobs HandySPA / MobilCLIENTS & UI

Kein Eintrag in der Registry heißt: nirgends ein Socket. Der Server legt stattdessen einen Push-Job in die Queue.

Mehr erfahrenPresence und ephemerer ZustandBenachrichtigungen und transaktionale NachrichtenNachrichtenwarteschlangen und asynchrone Worker

Warum eine Queue zwischen Chat-Server und Benachrichtigungsdienst? Weil der Push-Dienst jemand anderem gehört, mit eigener Latenz und eigenen schlechten Tagen, und Alice nie darauf warten sollte. Ihre Nachricht wird gespeichert und bestätigt, egal ob Apple schnell antwortet.

Der Push sagt Bob, dass er nachsehen soll, stellt das Gespräch aber nicht zu. APNs und FCM versprechen nicht, dass jede Benachrichtigung ankommt: Ein Handy, das stundenlang aus war, kann manche verspätet bekommen, mehrere zu einer zusammengefasst oder gar keine. Die Zustellung bleibt also dort, wo sie schon war. Wenn Bob die App öffnet, fragt sein Handy den Speicher nach jeder Nachricht nach der letzten, die es hat. In dieser Version versieht der Chat-Server jede Nachricht beim Speichern mit seiner eigenen Uhrzeit, und „die letzte“ bedeutet den Zeitstempel der neuesten Nachricht auf dem Handy. Behalte diesen Cursor im Auge; der nächste Abschnitt nimmt ihn auseinander.

Die neuen Kästchen fallen auf Arten aus, die es wert sind, benannt zu werden:

  • Der Push-Dienst ist langsam oder down. Die Jobs stauen sich in der Queue, und Benachrichtigungen kommen verspätet. Der Chat selbst ist nicht betroffen, und Bob bekommt trotzdem alles, wenn er die App öffnet.
  • Die Registry ist veraltet. Einige Sekunden nach dem Absturz eines Chat-Servers zeigt Bobs Eintrag noch auf ihn. Eine Nachricht, die in diesem Fenster gesendet wird, wird auf Bobs Kanal veröffentlicht, den kein lebender Server mehr abonniert hat, und es geht kein Push raus, weil die Registry sagte, er sei verbunden. Wenn sich sein Handy neu verbindet und nachlädt, ist die Nachricht da. Eine veraltete Registry kostet eine Benachrichtigung, keine Nachricht.
  • Die Registry ist down. Der Server kann verbunden nicht von offline unterscheiden und muss in eine Richtung raten. Dieses Design behandelt alle als offline: Es veröffentlicht weiterhin auf dem Kanal des Empfängers und legt zusätzlich einen Push in die Queue. Der Preis sind überflüssige Benachrichtigungen für Leute, die die Nachricht schon gesehen haben; die andere Annahme würde Leute, die sie nicht gesehen haben, um ihre Benachrichtigung bringen, und das ist schlimmer. Die Live-Zustellung fragt die Registry nie und läuft weiter.

Bob auf zwei Geräten, und eine Nachricht, die doppelt gesendet wird

Bob hat auch einen Laptop. An manchen Abenden sind beide Geräte gleichzeitig verbunden, und das Routing deckt das schon ab: In der Zeichnung hängt der Laptop am selben Server wie das Handy, der Bobs Kanal abonniert hat, als sein erster Socket kam; auf jedem anderen Server würde dieser Server Bobs Kanal ebenfalls abonnieren. Heute Abend ist es der andere Fall: Der Laptop war früher am Abend offen, als das Handy schon leer in der Schublade lag. Was jetzt kaputtgeht, ist subtiler: drei Arten, wie dieselbe Nachricht Bob falsch erreichen kann, und jede wird durch eine Regel behoben, nicht durch ein neues Kästchen.

Doppelt. Alices Nachricht ist gespeichert, aber die Bestätigung erreicht ihr Handy nie; sie ist in einen Tunnel gefahren. Ihr Handy tut, was es soll, und sendet die Nachricht noch einmal, und Bob sieht sie zweimal. Die Lösung beginnt auf Alices Handy: Es gibt jeder Nachricht beim Senden eine ID, und ein erneutes Senden trägt dieselbe ID. Der Speicher weist eine zweite Nachricht mit einer ID ab, die er in dieser Konversation schon hat, und beantwortet das erneute Senden mit der Bestätigung des Originals, und jeder Client ignoriert eine Nachricht, deren ID er schon anzeigt. Erneutes Senden bis zur Bestätigung ergibt Zustellung mindestens einmal; Deduplizierung per ID macht daraus einmal angezeigt.

Falsche Reihenfolge oder Lücken. Der Zeitstempel-Cursor aus dem Offline-Fall verliert Nachrichten, und nicht selten. Die Uhren zweier Chat-Server weichen um ein paar Millisekunden ab, sodass eine später gespeicherte Nachricht einen früheren Zeitstempel tragen kann. Zwei Nachrichten können dieselbe Millisekunde haben. Und eine Nachricht, deren Schreibvorgang etwas länger zum Commit braucht, kann im Speicher auftauchen, nachdem Bobs Handy ihren Zeitstempel schon überlesen hat; die Frage „alles nach dem neuesten Zeitstempel, den ich habe“ überspringt sie dann für immer.

Die Lösung ist eine Sequenznummer pro Konversation, die der Speicher im selben Schreibvorgang vergibt, der die Nachricht speichert: 41, 42, 43, keine zwei Nachrichten mit derselben. In einem relationalen Speicher kann das ein Zähler in der Zeile der Konversation sein, der in derselben Transaktion erhöht wird, die die Nachricht einfügt, sodass gleichzeitige Schreibvorgänge in einer Konversation ihre Nummern nacheinander bekommen. So hat jede Konversation genau eine Instanz, die ihre Reihenfolge bestimmt. Wir nehmen an, dass selbst eine rege Gruppe weit weniger Nachrichten pro Sekunde sendet, als eine Zeile an Updates verkraftet, sodass das Warten auf diese Zeile bei diesen Zahlen nichts Spürbares kostet.

Jedes Gerät merkt sich dann für jede Konversation seine eigene „letzte Sequenznummer, die ich habe“. Bobs Handy ist mit dem Stand 40 gestorben; der Laptop, früher am Abend offen, steht bei 41, der letzten Nachricht vor Alices Frage. Wenn sich das Handy neu verbindet, fragt es nach allem nach 40 in dieser Konversation; wird der Laptop geöffnet, fragt er nach allem nach 41. Beide holen unabhängig voneinander auf, denn jedes kann andere Nachrichten verpasst haben.

Eine Lücke bei bestehender Verbindung. Der Broker kann eine Nachricht verlieren, während Bobs Sockets offen bleiben, sodass sein Handy sich nie neu verbindet und nie nachlädt. Sequenznummern machen das sichtbar: Ein Gerät, das 41 und dann 43 erhält, weiß, dass es 42 gibt, fragt den Speicher danach und lässt seinen Cursor auf 41, bis 42 eintrifft; ein Cursor, der auf 43 gesprungen wäre, würde 42 für immer überspringen, falls das Gerät vorher ausfällt. Eine Lücke ganz am Ende einer ruhigen Konversation hat keine nächste Nachricht, die sie verrät, deshalb fragen Clients den Speicher ab und zu auch nach der neuesten Sequenznummer jeder Konversation.

Schritt 4 von 5: Einmal, geordnet, auf jedem Gerät
Einmal, geordnet, auf jedem GerätBobs Laptop hält jetzt einen WebSocket zum selben Chat-Server wie sein Handy, und dieser stellt jede Nachricht an beide zu. Der Rest des Systems bleibt unverändert; diese Stufe fügt Regeln hinzu, keine Komponenten: Nachrichten-IDs vom Client, vom Nachrichtenspeicher vergebene Sequenznummern pro Konversation und ein Nachlade-Cursor, den jedes Gerät führt.an Bobs KanalWebSocketPush-JobAlices HandySPA / MobilCLIENTS & UILoad BalancerVerkehrs-RouterPLATTFORM & RUNTIMEChat-ServerEchtzeitserver (WebSocket / SSE)Echtzeitserver(WebSocket / SSE)DIENSTE & APISNachrichten-DBGenerischer SQL-SpeicherDATENSPEICHERZustellqueueWarteschlangeMESSAGING & WORKFLOWSNutzerkanälePublizieren / AbonnierenMESSAGING & WORKFLOWSVerbindungsregistryGenerische KV-AbfragenDATENSPEICHERWeiterer Chat-ServerWeitererChat-ServerEchtzeitserver (WebSocket / SSE)Echtzeitserver(WebSocket / SSE)DIENSTE & APISBobs LaptopSPA / MobilCLIENTS & UIBenachrichtigungenPush / E-MailDIENSTE & APISBobs HandySPA / MobilCLIENTS & UI
Einmal, geordnet, auf jedem GerätBobs Laptop hält jetzt einen WebSocket zum selben Chat-Server wie sein Handy, und dieser stellt jede Nachricht an beide zu. Der Rest des Systems bleibt unverändert; diese Stufe fügt Regeln hinzu, keine Komponenten: Nachrichten-IDs vom Client, vom Nachrichtenspeicher vergebene Sequenznummern pro Konversation und ein Nachlade-Cursor, den jedes Gerät führt.an Bobs KanalWebSocketPush-JobAlices HandySPA / MobilCLIENTS & UILoad BalancerVerkehrs-RouterPLATTFORM & RUNTIMEChat-ServerEchtzeitserver (WebSocket / SSE)Echtzeitserver(WebSocket / SSE)DIENSTE & APISNachrichten-DBGenerischer SQL-SpeicherDATENSPEICHERZustellqueueWarteschlangeMESSAGING & WORKFLOWSNutzerkanälePublizieren / AbonnierenMESSAGING & WORKFLOWSVerbindungsregistryGenerische KV-AbfragenDATENSPEICHERWeiterer Chat-ServerWeitererChat-ServerEchtzeitserver (WebSocket / SSE)Echtzeitserver(WebSocket / SSE)DIENSTE & APISBobs LaptopSPA / MobilCLIENTS & UIBenachrichtigungenPush / E-MailDIENSTE & APISBobs HandySPA / MobilCLIENTS & UI

Kein neuer Dienst: Nachrichten-IDs, Sequenznummern pro Konversation und ein Cursor pro Gerät.

Mehr erfahrenMessage DeduplicationIdempotenz und Exactly-once-Illusionen

Die Sequenznummer verrät auch, wie der Speicher wachsen wird. Bei 24 GB am Tag, etwa 9 TB im Jahr, wächst er früher oder später aus einer Datenbank heraus, und dann ist die Konversation der natürliche Partitionsschlüssel: Jedes Nachladen oben liest eine Konversation, und die Instanz für die Sequenz einer Konversation liegt in derselben Partition wie ihre Nachrichten. Das ist ein späterer Schritt, nicht dieser, deshalb bleibt es in der Zeichnung bei einem Kästchen.

Eine Frage überlässt das dem Produkt: Wenn Bob auf dem Laptop verbunden ist und sein Handy aus ist, sollte das Handy dann auch eine Benachrichtigung bekommen? In diesem Design nicht, weil die Registry gefragt wird, ob Bob irgendwo einen Socket hat, nicht auf jedem Gerät. Messaging-Apps beantworten diese Frage unterschiedlich, und beide Antworten funktionieren mit dem Rest des Designs.

Alice schreibt an 500 Leute

Alice stellt dieselbe Frage in ihrer Nachbarschaftsgruppe mit 500 Mitgliedern: „Bleibt es bei Samstag?“ Spielt man das durch das bisherige Design, wird der Sendepfad zu einer Schleife: Für jedes der 499 anderen Mitglieder in der Registry nachschlagen, auf seinem Kanal veröffentlichen und für jedes, das offline ist, einen Push in die Queue legen. Die Arbeit des Chat-Servers pro Nachricht wächst jetzt mit der Gruppengröße, auf denselben Servern, die die Sockets aller halten. Schlimmer noch: Der Server bestätigt Alice, sobald die Nachricht gespeichert ist, bevor diese Schleife fertig ist; ein Server, der mittendrin abstürzt, hat Alice schon „gesendet“ gesagt, und die Pushes, die er noch nicht eingereiht hatte, sind einfach weg. Diese Lücke gab es im Einzelchat schon, zwischen dem Speichern einer Nachricht und dem Einreihen ihres Push; eine Gruppe dehnt das Fenster über die Arbeit für 499 Mitglieder.

Die Lösung ist, das Fan-out vom Sendepfad zu nehmen. Der Chat-Server speichert die Nachricht und hält in derselben Datenbanktransaktion einen Job fest: Nachricht 42 dieser Gruppe zustellen. Ein kleines Relay in den Chat-Servern schiebt festgehaltene Jobs in die Zustellqueue. Dass der Job in derselben Transaktion wie die Nachricht geschrieben wird, macht die Bestätigung sicher: Ist die Nachricht gespeichert, existiert ihr Job, auch wenn der Server im nächsten Augenblick stirbt. Das ist das Transactional-Outbox-Muster, und es kostet eine weitere Tabelle in einer Datenbank, in die der Server ohnehin schreibt. Es schließt auch die Lücke im Einzelchat, denn der Job jeder Nachricht wird jetzt so festgehalten.

Es beantwortet auch eine Frage, die die Zustellqueue bei ihrem Auftauchen aufwarf: Was, wenn die Queue down ist? Das Relay kann keine Jobs verschieben, also warten sie in der Outbox-Tabelle. Alice sendet weiter, während die Outbox-Tabelle wächst, und Benachrichtigungen und Gruppennachrichten kommen an, sobald die Queue zurück ist. Einzelnachrichten, die zusätzlich direkt veröffentlicht werden, kommen weiterhin live an.

Fan-out-Worker nehmen Jobs aus der Queue und erledigen die Schleife abseits der Server, die die Sockets halten. Der Job enthält nur die Nachricht und die Gruppe. Ein Worker liest die Mitgliederliste aus dem Speicher, veröffentlicht die Nachricht auf dem Kanal jedes Mitglieds, fragt die Registry in einer gebündelten Abfrage, welche Mitglieder keinen Socket haben, und übergibt diese an den Benachrichtigungsdienst. Ein Worker bestätigt einen Job erst, wenn seine Schleife fertig ist und der Benachrichtigungsdienst die Pushes gespeichert hat, die er senden wird, und das Relay markiert einen Job erst als verschoben, wenn die Queue ihn gespeichert hat; ein Absturz auf einer der beiden Seiten wiederholt also Arbeit, statt sie zu verlieren: Ein Mitglied bekommt die Nachricht womöglich zweimal, was seine ID auffängt, oder eine zweite Benachrichtigung. Diese Lesezugriffe und die Registry-Abfrage sind nicht eingezeichnet, damit die Zeichnung frei von sich kreuzenden Linien bleibt. Die Registry zu fragen, wenn der Job läuft, statt wenn Alice sendet, bedeutet außerdem: Ein Worker, der hinterherhinkt, entscheidet danach, wer jetzt verbunden ist, nicht wer beim Senden der Nachricht verbunden war. Mit der Mitgliederliste ist es umgekehrt: Der Worker liest die Gruppe so, wie sie bei Nachricht 42 war (jede Mitgliedschaft hält die Sequenznummern fest, bei denen sie beginnt und endet), sodass jemand, der eine Sekunde nach Alices Senden beitritt, keine Nachricht aus der Zeit vor seinem Beitritt bekommt. Push-Jobs für Einzelnachrichten laufen jetzt genauso, als Jobs mit einem einzigen Empfänger, sodass die Chat-Server die Registry nicht mehr lesen: Sie schreiben nur Einträge für die Sockets, die sie halten, und die Worker lesen.

Schritt 5 von 5: Fan-out abseits des Sendepfads
Fan-out abseits des SendepfadsDie endgültige Architektur. Bei einer Gruppennachricht speichert der Chat-Server die Nachricht und einen Zustelljob, der in die Zustellqueue gelangt. Fan-out-Worker nehmen jeden Job, veröffentlichen die Nachricht auf dem Kanal jedes Mitglieds im Pub/Sub-Dienst und geben die Mitglieder ohne offene Verbindung an den Benachrichtigungsdienst weiter, der die Push-Benachrichtigungen sendet.an Bobs KanalWebSocketein Job pro NachrichtOffline-MitgliederAlices HandySPA / MobilCLIENTS & UILoad BalancerVerkehrs-RouterPLATTFORM & RUNTIMEChat-ServerEchtzeitserver (WebSocket / SSE)Echtzeitserver(WebSocket / SSE)DIENSTE & APISNachrichten-DBGenerischer SQL-SpeicherDATENSPEICHERZustellqueueWarteschlangeMESSAGING & WORKFLOWSNutzerkanälePublizieren / AbonnierenMESSAGING & WORKFLOWSVerbindungsregistryGenerische KV-AbfragenDATENSPEICHERFan-out-WorkerKonsumentMESSAGING & WORKFLOWSWeiterer Chat-ServerWeitererChat-ServerEchtzeitserver (WebSocket / SSE)Echtzeitserver(WebSocket / SSE)DIENSTE & APISBobs LaptopSPA / MobilCLIENTS & UIBenachrichtigungenPush / E-MailDIENSTE & APISBobs HandySPA / MobilCLIENTS & UI
Fan-out abseits des SendepfadsDie endgültige Architektur. Bei einer Gruppennachricht speichert der Chat-Server die Nachricht und einen Zustelljob, der in die Zustellqueue gelangt. Fan-out-Worker nehmen jeden Job, veröffentlichen die Nachricht auf dem Kanal jedes Mitglieds im Pub/Sub-Dienst und geben die Mitglieder ohne offene Verbindung an den Benachrichtigungsdienst weiter, der die Push-Benachrichtigungen sendet.an Bobs KanalWebSocketein Job pro NachrichtOffline-MitgliederAlices HandySPA / MobilCLIENTS & UILoad BalancerVerkehrs-RouterPLATTFORM & RUNTIMEChat-ServerEchtzeitserver (WebSocket / SSE)Echtzeitserver(WebSocket / SSE)DIENSTE & APISNachrichten-DBGenerischer SQL-SpeicherDATENSPEICHERZustellqueueWarteschlangeMESSAGING & WORKFLOWSNutzerkanälePublizieren / AbonnierenMESSAGING & WORKFLOWSVerbindungsregistryGenerische KV-AbfragenDATENSPEICHERFan-out-WorkerKonsumentMESSAGING & WORKFLOWSWeiterer Chat-ServerWeitererChat-ServerEchtzeitserver (WebSocket / SSE)Echtzeitserver(WebSocket / SSE)DIENSTE & APISBobs LaptopSPA / MobilCLIENTS & UIBenachrichtigungenPush / E-MailDIENSTE & APISBobs HandySPA / MobilCLIENTS & UI

Ein dauerhafter Job pro Nachricht; die Worker erledigen die Arbeit pro Mitglied.

Mehr erfahrenFan-out: Push vs. PullTransactional OutboxDurchgearbeiteter Entwurf: ein Echtzeit-Chat

Einzelnachrichten behalten ihre direkte Veröffentlichung auf dem Kanal des Empfängers, sodass der häufige Fall nicht langsamer wird. Gruppennachrichten brauchen ein paar Millisekunden länger bis zu verbundenen Mitgliedern, weil sie zuerst durch die Queue und einen Worker laufen. Dafür wird die Queue zum Ort, an dem sich ein Rückstau zeigt: Fallen die Worker zurück, kommen Gruppennachrichten und Benachrichtigungen verspätet an, während Einzelnachrichten weiter live ankommen.

Die Worker veröffentlichen einmal pro Mitglied. Ein größeres System würde die Mitglieder nach dem Server gruppieren, auf dem die Registry sie verortet, und einmal pro Server veröffentlichen, weit weniger Nachrichten für den Broker; der Preis ist, dass die Registry auf den Live-Pfad rückt und ein Registry-Ausfall dann die Live-Zustellung stoppt, statt nur zusätzliche Benachrichtigungen zu verursachen. Bei 500 Mitgliedern hält dieses Design die Registry aus dem Live-Pfad heraus: Ein Registry-Ausfall kostet weiterhin nur zusätzliche Benachrichtigungen.

Ab einer bestimmten Größe ergibt es gar keinen Sinn mehr, jedem Mitglied eine Kopie zu schicken: bei einem Kanal, dem Hunderttausende folgen. Dort holen die Leser die Nachrichten des Kanals ab, wenn sie ihn öffnen, statt dass jedem eine Kopie gesendet wird. Das ist ein anderes Produkt mit eigenen Abwägungen zwischen Push und Pull, und dieses Design braucht es bei 500 Mitgliedern nicht.

Wo Alices Nachricht noch hängen bleiben kann

Ein letztes Mal Alices Frage, durch die ganze Zeichnung. Ihr Handy gibt ihr eine ID und schickt sie über den Lastverteiler an einen Chat-Server. Der Server speichert sie als Nummer 42 der Konversation, hält ihren Zustelljob in derselben Transaktion fest und sagt Alice „gesendet“. Er veröffentlicht auf Bobs Kanal; niemand hat abonniert. Ein Worker holt den Job, findet in der Registry keinen Eintrag für Bob und übergibt einen Push an den Benachrichtigungsdienst, und Apple reicht ihn weiter, sobald Bobs Handy wieder an ist, oder auch nicht. Eine Stunde später verbindet sich das Handy neu, abonniert und fragt nach allem nach 40. Der Laptop, am nächsten Morgen geöffnet, fragt nach allem nach 41. Die Nachricht erscheint auf jedem Gerät einmal, an ihrem Platz, und nichts auf ihrem Weg musste beim ersten Mal funktionieren außer dem Speicher.

Zwölf Kästchen: drei sind Alices Handy sowie Bobs Handy und Laptop, und die zwei Chat-Server stehen für ein Dutzend. Das passiert, wenn eines der anderen ausfällt, und wer es merkt:

  • Ein Chat-Server stirbt → seine Nutzer werden getrennt, verbinden sich mit Backoff und Jitter neu mit den anderen Servern, abonnieren erneut und laden per Sequenznummer nach. In der Zwischenzeit gesendete Nachrichten wurden gespeichert; niemand verliert eine.
  • Der Lastverteiler fällt aus → Handys erreichen keinen Chat-Server mehr. Nimm einen verwalteten, redundanten oder betreibe zwei.
  • Der Broker hinkt hinterher oder verliert Nachrichten → die Live-Zustellung ist verspätet oder lückenhaft. Lückenerkennung und regelmäßiger Abgleich holen die fehlenden Nachrichten aus dem Speicher.
  • Die Registry ist veraltet → eine Benachrichtigung kann fehlen. Die Registry ist down → alle gelten als offline: zusätzliche Benachrichtigungen, die Live-Zustellung bleibt unberührt.
  • Die Zustellqueue ist down, oder die Worker fallen zurück oder stürzen ab → Jobs warten in der Outbox oder der Queue, und der Job eines abgestürzten Workers läuft erneut; Benachrichtigungen und Gruppennachrichten sind verspätet, Einzelnachrichten kommen weiter live an, und Alice kann weiter senden.
  • Der Benachrichtigungsdienst oder der Push-Dienst dahinter ist langsam oder down → Benachrichtigungen sind verspätet oder fehlen; alles ist in der App, wenn sie geöffnet wird.
  • Der Nachrichtenspeicher ist down → das Senden stoppt. Alices Handy behält die Nachricht und versucht es mit derselben ID erneut. Das ist die eine Abhängigkeit, die der Sendepfad nicht umgehen kann, denn jede Garantie dieses Designs beginnt mit „Die Nachricht ist gespeichert“. Betreibe ihn repliziert, mit jedem Schreibvorgang auf einer zweiten Maschine, bevor Alice „gesendet“ sieht, sonst kann ein Failover Nachrichten verlieren, die ihr als gesendet gemeldet wurden.

Abgesehen vom Lastverteiler, der nur redundant sein muss, ist der Speicher das eine Kästchen, dessen Ausfall Alice am Senden hindert, und kein Ausfall auf der Liste kann eine Nachricht verlieren, die ihr als gesendet gemeldet wurde. Der Broker und der Push-Dienst sind schnelle Wege, die ausfallen dürfen, weil hinter beiden der Speicher die Nachricht noch hält und jedes Gerät weiß, wie es sie abfragt.

Nicht in diesem Design

  • Ende-zu-Ende-Verschlüsselung. Das Routing in diesem Beitrag übersteht sie; was sich ändert, ist, was der Server lesen kann; das behandeln das durchgearbeitete Chat-Design in Learn und die Challenge Ende-zu-Ende-verschlüsselte Nachrichten.
  • Lesebestätigungen und Tippanzeigen. Beides ist kurzlebiger Zustand über eine Konversation und keine Nachricht darin. Eine Tippanzeige kann ohne Schaden verloren gehen; eine Lesebestätigung steht einer Nachricht näher und wird meist gespeichert.
  • Fotos, Videos und Dateien. Anhänge kommen in einen Objektspeicher, und die Nachricht trägt einen Verweis darauf, nicht die Bytes.
  • Sprach- und Videoanrufe, also Realtime-Medien mit eigenen Protokollen.
  • Suche im Nachrichtenverlauf, ein separater Index, der aus dem Speicher gespeist wird.
  • Mehrere Regionen. Bob und Alice sind hier auf demselben Kontinent.

Zeichne es selbst

Die Challenge Chat-System verlangt genau diese Architektur. Ihre Palette nennt Produkte (MongoDB, Redis, Kafka, einen Push-Anbieter), wo dieser Beitrag generische Kästchen zeichnet; ein Kafka-Topic kann die Zustellqueue sein. Zeichne sie, und schick dann Alices Frage an einen Bob, dessen Handy aus ist.