Apprenez la conception de systèmes en 40 leçons animées sur la répartition de charge, les caches et les bases de données. Concevez un fil et une messagerie.
Lors d’une première visite via TCP et TLS, le navigateur résout le domaine, ouvre une connexion sécurisée et envoie une requête HTTP. Il affiche ensuite la réponse du serveur.
Les réseaux acheminent par adresse IP numérique, pas par nom. Le navigateur demande donc d’abord à un résolveur DNS : où est shop.example ?
La réponse (203.0.113.7) revient en 20 ms environ.
Le navigateur ouvre maintenant une connexion vers 203.0.113.7. Une poignée de main TCP établit l’échange ; une poignée de main TLS met en place le chiffrement. Chacune demande un aller-retour.
Ici, un aller-retour prend 30 ms : se connecter coûte donc 60 ms avant même de demander le moindre octet de la page.
Sur la connexion ouverte, le navigateur envoie GET /products. Le serveur l’analyse, vérifie la session et exécute votre code.
Cela coûte un aller-retour de plus et ~10 ms de travail du serveur.
Les produits ne vivent pas dans le serveur web, mais dans une base de données. Le serveur envoie une requête et attend que les lignes reviennent.
Regardez une requête faire tout le chemin aller et la réponse tout le chemin retour.
Le serveur transforme les lignes en HTML et le renvoie ; le télécharger prend encore 20 ms. Le navigateur affiche la page 155 ms après que vous avez appuyé sur Entrée.
Puis il repère des images et des feuilles de style dans la page et lance d’autres requêtes. Réutiliser la connexion ouverte leur épargne la poignée de main.
Suivez le chargement d’une page étape par étape, et découvrez où passe vraiment le temps.
Deux questions sur la vitesse, et pourquoi les serveurs chargés ralentissent avant d’être pleins.
Transformez une idée de produit en serveurs et en téraoctets avec des calculs qui tiennent sur une serviette.
Votre unique serveur fond. Vous en achetez un plus gros, ou plusieurs ?
Une seule porte d’entrée pour de nombreux serveurs, et les règles qui décident qui reçoit quelle requête.
Pourquoi la requête suivante doit fonctionner sur n’importe quel serveur, et où va l’état à la place.
Gardez les réponses les plus demandées dans un endroit bien plus rapide que la base de données.
Copiez ce que tout le monde télécharge sur des serveurs proches de vos utilisateurs, et cessez de lutter contre la vitesse de la lumière.
Tables, documents ou simples clés : ce que chaque type de base de données fait bien, et ce à quoi il renonce.
Pourquoi la même requête peut prendre deux secondes ou deux millisecondes.
Ce qu’une base de données fait vraiment de votre écriture, et pourquoi certaines sont conçues pour la lecture et d’autres pour l’écriture.
Garder des copies de la base sur plusieurs machines : pour plus de lectures et pour survivre.
Quand les données ou les écritures dépassent une machine, on les répartit sur plusieurs.
Ajouter ou retirer des serveurs en ne déplaçant qu’une mince part des données.
Donner à chaque ligne un nom que personne d’autre n’utilisera jamais, sans un compteur unique devant lequel tout le monde fait la queue.
Quand le réseau se coupe, les copies de vos données doivent choisir entre avoir raison et rester joignables.
Comment un groupe de serveurs s’accorde sur un leader et une histoire, même quand certains sont injoignables.
Deux personnes, une place, la même milliseconde. Comment les bases de données gardent justes les modifications concurrentes.
Les photos et vidéos n’ont rien à faire dans votre base : où elles vont à la place, et comment elles y entrent et en sortent.
Trois façons pour des programmes de se demander des choses, et ce que chacune coûte à un téléphone en 4G.
Répondre tout de suite, faire le travail lent plus tard, et ne jamais perdre une tâche en route.
Annoncer qu’une chose s’est produite, et laisser réagir ceux que ça intéresse, sans que personne n’attende.
Comment le serveur vous prévient qu’il s’est passé quelque chose : chat, scores en direct, notifications.
Tout finit par tomber en panne. Concevez pour qu’aucune panne isolée ne vous mette à terre.
Donnez à chaque client un budget équitable, pour qu’un script emballé ne fasse pas tomber tout le monde.
Appeler sans risque un service en difficulté : abandonner à temps, réessayer avec prudence, et savoir quand s’arrêter.
Métriques, logs et traces : comment trouver ce qui ne va pas, où et pourquoi, vite.
Une seule base de code ou plusieurs services ? Ce que chacun apporte, ce qu’il coûte, et comment passer de l’un à l’autre.
Comment les services se trouvent quand des instances vont et viennent, et une porte d’entrée unique pour tout l’extérieur.
Une action, plusieurs services, plusieurs bases de données : comment garder le tout-ou-rien sans une grande transaction.
Traiter des milliards d’événements : la nuit en gros lots, ou en continu au fil de leur arrivée.
Prouver qui est quelqu’un, sans devenir la raison pour laquelle son mot de passe fuite.
Savoir qui est quelqu’un ne dit pas ce qu’il a le droit de voir ou de faire. Le vérifier, partout.
Protéger les données sur le réseau, sur disque, ainsi que les clés et mots de passe de vos services.
Savoir qu’un changement est sûr avant vos utilisateurs : des tests rapides pour la logique, quelques lents pour le reste.
Amener chaque changement en production vite et sans risque, et pouvoir revenir en arrière tout aussi vite.
Le même système à deux niveaux de zoom : la carte des services, et l’intérieur de l’un d’eux.
Une première conception de bout en bout : d’un brief d’une ligne à un système qui sert des milliards de redirections.
Les posts de tous ceux que vous suivez, en 200 ms, et la question de savoir quand faire le travail.
Vingt millions de connexions ouvertes, et une promesse : chaque message arrive, dans l’ordre, exactement une fois.