Lerne Systemdesign in 40 interaktiven Lektionen. Erkunde Lastverteilung, Caches und Datenbanken und entwirf einen URL-Kürzer, einen Feed und ein Chatsystem.
Beim ersten Aufruf über TCP und TLS löst der Browser den Domainnamen auf, baut eine sichere Verbindung auf und sendet eine HTTP-Anfrage. Danach stellt er die Antwort des Servers dar.
Netze routen nach numerischer IP-Adresse, nicht nach Namen. Also fragt der Browser zuerst einen DNS-Resolver: Wo ist shop.example?
Die Antwort (203.0.113.7) kommt nach etwa 20 ms zurück.
Jetzt öffnet der Browser eine Verbindung zu 203.0.113.7. Ein TCP-Handshake vereinbart das Gespräch, ein TLS-Handshake richtet die Verschlüsselung ein. Jeder braucht einen Roundtrip, hin und zurück.
Hier dauert ein Roundtrip 30 ms, also kostet das Verbinden 60 ms, bevor auch nur ein Byte der Seite angefragt wird.
Über die offene Verbindung sendet der Browser GET /products. Der Server parst sie, prüft die Session und führt deinen Code aus.
Das kostet einen weiteren Roundtrip plus ~10 ms Serverarbeit.
Die Produkte liegen nicht im Webserver, sondern in einer Datenbank. Der Server schickt eine Abfrage und wartet, bis die Zeilen zurückkommen.
Sieh zu, wie eine Anfrage den ganzen Weg hinein reist und die Antwort den ganzen Weg zurück.
Der Server macht aus den Zeilen HTML und schickt es zurück; das Herunterladen dauert weitere 20 ms. Der Browser rendert die Seite 155 ms, nachdem du Enter gedrückt hast.
Dann bemerkt er Bilder und Stylesheets in der Seite und schickt weitere Anfragen los. Die offene Verbindung wiederzuverwenden erspart ihnen den Handshake.
Verfolge einen Seitenaufruf Schritt für Schritt und finde heraus, wo die Zeit wirklich bleibt.
Zwei Fragen zur Geschwindigkeit, und warum ausgelastete Server langsam werden, bevor sie voll sind.
Mach aus einer Produktidee Server und Terabytes, mit Rechnungen, die auf einen Bierdeckel passen.
Dein einziger Server schmilzt. Kaufst du einen größeren oder mehrere?
Eine Eingangstür für viele Server – und die Regeln, wer welche Anfrage bekommt.
Warum die nächste Anfrage auf jedem Server funktionieren muss – und wohin der Zustand stattdessen wandert.
Halte die meistgefragten Antworten an einem Ort, der viel schneller ist als die Datenbank.
Kopiere, was alle herunterladen, auf Server nahe deinen Nutzern – und hör auf, gegen die Lichtgeschwindigkeit zu kämpfen.
Tabellen, Dokumente oder einfache Schlüssel – worin jede Art von Datenbank gut ist und worauf sie verzichtet.
Warum dieselbe Query zwei Sekunden oder zwei Millisekunden dauern kann.
Was eine Datenbank wirklich mit deinem Schreibzugriff macht – und warum manche fürs Lesen und andere fürs Schreiben gebaut sind.
Kopien der Datenbank auf mehreren Maschinen halten: für mehr Lesezugriffe und zum Überleben.
Wenn Daten oder Schreibvorgänge einer Maschine entwachsen, verteile sie auf viele.
Server hinzufügen oder entfernen und dabei nur einen schmalen Teil der Daten bewegen.
Jeder Zeile einen Namen geben, den nie jemand anderes benutzt, ohne einen einzigen Zähler, vor dem alle Schlange stehen.
Wenn das Netz reißt, müssen sich die Kopien deiner Daten entscheiden: richtig sein oder erreichbar bleiben.
Wie sich eine Gruppe von Servern auf einen Leader und eine Geschichte einigt, auch wenn einige nicht erreichbar sind.
Zwei Personen, ein Platz, dieselbe Millisekunde. Wie Datenbanken gleichzeitige Änderungen korrekt halten.
Fotos und Videos gehören nicht in deine Datenbank: wohin sie stattdessen kommen und wie sie hin- und zurückgelangen.
Drei Arten, wie Programme einander um etwas bitten, und was jede davon ein Handy im 4G-Netz kostet.
Sofort antworten, die langsame Arbeit später erledigen und unterwegs nie einen Job verlieren.
Verkünden, dass etwas passiert ist, und reagieren lassen, wen es interessiert, ohne dass jemand wartet.
Wie der Server dir sagt, dass etwas passiert ist: Chat, Live-Ergebnisse, Benachrichtigungen.
Alles fällt irgendwann aus. Entwirf so, dass kein einzelner Ausfall dich lahmlegt.
Gib jedem Client ein faires Budget, damit kein außer Kontrolle geratenes Skript alle lahmlegt.
Einen angeschlagenen Dienst sicher aufrufen: rechtzeitig aufgeben, vorsichtig wiederholen und wissen, wann Schluss ist.
Metriken, Logs und Traces: wie du schnell herausfindest, was falsch läuft, wo und warum.
Eine Codebasis oder viele Dienste? Was dir jede Variante bringt, was sie kostet und wie du von einer zur anderen wechselst.
Wie Dienste einander finden, wenn Instanzen kommen und gehen, und eine einzige Eingangstür für alle draußen.
Eine Aktion, mehrere Dienste, mehrere Datenbanken: wie alles-oder-nichts gelingt, ohne eine große Transaktion.
Milliarden Events verarbeiten: über Nacht in großen Batches oder laufend, sobald sie ankommen.
Nachweisen, wer jemand ist, ohne zum Grund dafür zu werden, dass sein Passwort leakt.
Zu wissen, wer jemand ist, sagt nicht, was er sehen oder tun darf. Das überall prüfen.
Daten im Netz und auf der Platte schützen, ebenso die Schlüssel und Passwörter, die deine Dienste nutzen.
Wissen, dass eine Änderung sicher ist, bevor es deine Nutzer merken: schnelle Tests für die Logik, wenige langsame für den Rest.
Jede Änderung schnell und sicher in Produktion bringen, und genauso schnell wieder zurücknehmen.
Dasselbe System in zwei Zoomstufen: die Karte der Dienste und das Innere eines davon.
Ein erstes Design von Anfang bis Ende: von einem einzeiligen Auftrag zu einem System, das Milliarden Weiterleitungen ausliefert.
Posts von allen, denen du folgst, in 200 ms, und die Frage, wann die Arbeit passiert.
Zwanzig Millionen offene Verbindungen und ein Versprechen: Jede Nachricht kommt an, in der richtigen Reihenfolge, genau einmal.