Leer systeemontwerp in 40 interactieve lessen. Verken load balancing, caches en databases en ontwerp een URL-verkorter, een feed en een chatsysteem.
Bij een eerste bezoek via TCP en TLS zoekt de browser het domein op, opent een beveiligde verbinding en verstuurt een HTTP-verzoek. Daarna geeft hij het antwoord van de server weer.
Netwerken routeren op numeriek IP-adres, niet op naam. Dus vraagt de browser eerst een DNS-resolver: waar is shop.example?
Het antwoord (203.0.113.7) komt na ongeveer 20 ms terug.
Nu opent de browser een verbinding met 203.0.113.7. Een TCP-handshake spreekt het gesprek af; een TLS-handshake regelt de versleuteling. Elk kost een round trip: heen en terug.
Hier duurt een round trip 30 ms, dus verbinden kost 60 ms voordat er ook maar één byte van de pagina is gevraagd.
Over de open verbinding stuurt de browser GET /products. De server ontleedt het, controleert de sessie en voert je code uit.
Dat kost nog een round trip plus ~10 ms serverwerk.
De producten staan niet in de webserver, maar in een database. De server stuurt een query en wacht tot de rijen terugkomen.
Kijk hoe een verzoek de hele weg heen reist en het antwoord de hele weg terug.
De server maakt van de rijen HTML en stuurt het terug; downloaden kost nog eens 20 ms. De browser rendert de pagina 155 ms nadat je op Enter drukte.
Dan ziet hij afbeeldingen en stylesheets in de pagina en vuurt meer verzoeken af. De open verbinding hergebruiken bespaart ze de handshake.
Volg het laden van één pagina sprong voor sprong, en ontdek waar de tijd echt blijft.
Twee vragen over snelheid, en waarom drukke servers trager worden voordat ze vol zijn.
Maak van een productidee servers en terabytes, met rekenwerk dat op een bierviltje past.
Je enige server smelt. Koop je een grotere, of meer?
Eén voordeur voor veel servers, en de regels voor wie welk verzoek krijgt.
Waarom het volgende verzoek op elke server moet werken, en waar de state dan heen gaat.
Bewaar de meest gevraagde antwoorden op een plek die veel sneller is dan de database.
Kopieer wat iedereen downloadt naar servers dicht bij je gebruikers, en stop met vechten tegen de lichtsnelheid.
Tabellen, documenten of simpele sleutels: waar elke soort database goed in is, en wat hij opgeeft.
Waarom dezelfde query twee seconden of twee milliseconden kan duren.
Wat een database echt met je write doet, en waarom sommige voor lezen en andere voor schrijven gebouwd zijn.
Kopieën van de database op meerdere machines houden: voor meer leesacties en om te overleven.
Als de data of de schrijfacties niet meer op één machine passen, verdeel ze over vele.
Voeg servers toe of haal ze weg en verplaats maar een sliertje van de data.
Elke rij een naam geven die niemand anders ooit gebruikt, zonder één teller waar iedereen voor in de rij moet staan.
Als het netwerk splitst, moeten de kopieën van je data kiezen tussen gelijk hebben en bereikbaar zijn.
Hoe een groep servers het eens wordt over één leader en één geschiedenis, ook als sommige onbereikbaar zijn.
Twee mensen, één stoel, dezelfde milliseconde. Hoe databases gelijktijdige wijzigingen correct houden.
Foto’s en video’s horen niet in je database: waar ze in plaats daarvan heen gaan, en hoe ze daar komen en weer terug.
Drie manieren waarop programma’s elkaar om dingen vragen, en wat elk ervan een telefoon op 4G kost.
Meteen antwoorden, het trage werk later doen, en onderweg nooit een job kwijtraken.
Meld dat er iets gebeurd is, en laat wie het wil reageren, zonder dat iemand hoeft te wachten.
Hoe de server je vertelt dat er iets gebeurd is: chat, live-uitslagen, meldingen.
Alles valt uiteindelijk uit. Ontwerp zo dat geen enkele storing je platlegt.
Geef elke client een eerlijk budget, zodat één op hol geslagen script niet iedereen platlegt.
Een worstelende dienst veilig aanroepen: op tijd opgeven, voorzichtig opnieuw proberen, en weten wanneer je stopt.
Metrics, logs en traces: hoe je snel ontdekt wat er mis is, waar en waarom.
Eén codebase of veel diensten? Wat elk je oplevert, wat elk kost en hoe je van de een naar de ander gaat.
Hoe diensten elkaar vinden als instanties komen en gaan, en één voordeur voor iedereen buiten.
Eén actie, meerdere diensten, meerdere databases: hoe houd je alles-of-niets zonder één grote transactie.
Miljarden events verwerken: ’s nachts in grote batches, of continu terwijl ze binnenkomen.
Bewijzen wie iemand is, zonder de reden te worden dat diens wachtwoord uitlekt.
Weten wie iemand is, vertelt niet wat die mag zien of doen. Dat overal controleren.
Data beschermen op het netwerk, op schijf, en de sleutels en wachtwoorden die je services gebruiken.
Weten dat een wijziging veilig is voordat je gebruikers het merken: snelle tests voor de logica, een paar trage voor de rest.
Elke wijziging snel en veilig in productie krijgen, en net zo snel weer terugdraaien.
Hetzelfde systeem op twee zoomniveaus: de kaart van services, en de binnenkant van één ervan.
Een eerste ontwerp van begin tot eind: van een briefing van één regel tot een systeem dat miljarden redirects afhandelt.
Posts van iedereen die je volgt, in 200 ms, en de vraag wanneer je het werk doet.
Twintig miljoen open verbindingen en een belofte: elk bericht komt aan, op volgorde, precies één keer.