Note: J'ai écris l'original de l'article en anglais. Cette traduction française vient de Claude. C'était pour la rapidité mais d'expérience, je sais que ça impacte un peu mon style d'écriture. Je referai proprement la traduction quand j'aurai un peu plus de temps. Bonne lecture!
Coder, c'est confortable ! Tellement confortable qu'il est parfois difficile de passer à autre chose.
Mais il faut se faire à l'idée qu'à un moment, il faudra grandir. Grandir, c'est prendre plus de responsabilités, apprendre de nouvelles choses et aller au-delà de ce avec quoi on se sent à l'aise.
Soyons honnêtes : coder, tel qu'on le connaît, est un métier en voie de disparition. Et à un moment, vous ne vous soucierez plus vraiment de ce qu'il y a sous le capot, parce que vous serez occupé à régler d'autres problèmes. Nous sommes ingénieurs logiciels d'abord, développeurs ensuite.
L'un de ces problèmes concernera la conception de systèmes, le fameux "system design". L'IA peut automatiser beaucoup de choses, mais le jugement et la responsabilité doivent toujours rester humains.
Il existe de nombreux livres sur le system design. Trois d'entre eux sont System Design Interview Volume 1 & 2 d'Alex Xu et Designing Data-Intensive Applications de Martin Kleppmann.
Si vous préférez les cours, vous n'aurez besoin que de "Grokking the System Design Interview" d'Arslan Ahmad.
Il existe une ressource gratuite pour Ankidroid11 Je suis un grand fan d'Ankidroid sur github, mais je vais être honnête : je l'ai téléchargée il y a des années, je l'ai consultée une ou deux fois et je n'y suis jamais revenu !22 L'une des raisons, c'est que je trouve que, même si Ankidroid est un très très bon outil d'apprentissage, son interface par défaut est rebutante. Je suis en train de créer mes propres flashcards avec un style plus soigné, conçu avec Claude.
C'est vraiment un vaste sujet, et vous pouvez facilement vous épuiser à essayer de tout apprendre. Mais heureusement, vous n'aurez pas forcément besoin de tout apprendre. C'est pour ça que je me suis construit un modèle mental simple pour décider quoi faire à quelle échelle. Et c'est ce que je partage avec vous ici.
La base
La toute première étape, c'est toujours un serveur et une base de données. Je suis assez convaincu qu'un CCX13 chez Hetzner à 40 €/mois suffit généralement pour la plupart des entreprises dans la plupart des cas, surtout si votre entreprise fait du B2B. Ça fait 2 vCPU, 8 Go de RAM et 20 To de trafic. Vous pouvez avoir des millions de requêtes par jour et ça tiendra quand même.
J'ai travaillé dans une petite entreprise B2B pendant mes premières années et nous n'avons jamais eu de problème de capacité, malgré des centaines de clients. Le problème, c'était plutôt comment gagner des clients que comment faire passer l'infrastructure à l'échelle.
La solution classique
Quand le serveur commence à atteindre sa capacité33 D'où l'importance des outils d'observabilité comme Grafana et New Relic connectés à Slack. Vous pouvez aussi utiliser des services de monitoring de disponibilité comme UptimeRobot et Uptime Kuma, en bonus, pour vérifier votre app toutes les 10 minutes environ. Je parlerai peut-être de ma stratégie d'observabilité préférée dans un autre article si j'ai assez de matière., c'est le bon moment pour passer à l'échelle. Peut-être un CCX33 ou un CCX43 (je ne suis pas sponsorisé par Hetzner au passage, et si vous êtes aux États-Unis ou au Canada, ce n'est peut-être pas la meilleure offre pour vous).
Bien sûr, vous ne pourrez pas scaler verticalement indéfiniment. Aucune machine ne peut encaisser ça, et vous risquez de ne plus trouver de serveur assez puissant pour tenir la charge. C'est le signe qu'il faut scaler horizontalement.
Scaler horizontalement
Quand vous êtes proche de saturer votre serveur, c'est le bon moment pour ajouter des serveurs et répartir la charge. C'est ce qu'on appelle scaler horizontalement.
Ajoutez un load balancer (répartiteur de charge) pour distribuer le trafic équitablement entre les serveurs. Et un load balancer de secours au cas où le principal tombe en panne, ce qui pourrait faire tomber tout votre système puisque c'est le seul point d'accès aux serveurs.
Au-delà du risque de panne du load balancer, on peut rencontrer quelques problèmes qu'on n'aurait pas avec un seul serveur.
Dans notre cas initial, votre réflexe serait de stocker la session sur votre serveur. Avec plusieurs serveurs, ça devient problématique. Imaginez que votre session de connexion a été créée sur un serveur, mais qu'à la requête suivante, le load balancer envoie votre requête vers un autre serveur : votre session est perdue. C'est pourquoi, quand on scale horizontalement, il faut sortir les sessions des serveurs vers un session store comme Redis et rendre les serveurs stateless (sans état). Bien sûr, on ajoute un peu de latence en déplaçant les sessions, mais c'est un compromis à accepter.
Scaler la base de données
Limiter les connexions
Jusqu'ici, on a parlé des serveurs. Les bases de données, elles, scalent un peu différemment. D'abord, elles ont un nombre limité de connexions simultanées. Postgres est à 100 par défaut. Vous pouvez augmenter cette limite, mais chaque connexion consomme de la mémoire, donc vous ne pouvez pas l'augmenter à l'infini.
Si vous en êtes au point où il vous faut plusieurs serveurs pour servir votre app, il y a de fortes chances que vous atteigniez très vite la limite de connexions de la base.
Donc, ne laissez pas les serveurs ouvrir et fermer eux-mêmes leurs connexions à la base : laissez-les emprunter des connexions via un pool de connexions, qui maintient un nombre fixe de connexions ouvertes en permanence vers la base. Chaque requête qui n'obtient pas de connexion immédiatement attend qu'une place se libère.
Mais attention : des frameworks comme Rails ou Prisma gardent déjà un pool à l'intérieur de chaque serveur. Donc 10 serveurs avec un pool de 20 connexions chacun peuvent quand même ouvrir 200 connexions et exploser la limite. Soit vous dimensionnez chaque pool pour que le total reste sous la limite de la base, soit vous placez un pooler partagé comme PgBouncer entre vos serveurs et la base. Avec un pooler partagé, tous les serveurs passent par la même porte, donc le nombre maximum de connexions à la base n'est jamais atteint.
Indexer les données fréquemment utilisées
Je crois que ma vie a changé quand j'ai compris l'indexation des bases de données il y a quelques années. Pourquoi faire souffrir votre base en lui faisant parcourir 8 millions de lignes, alors que vous pouvez tout indexer et obtenir ce que vous voulez en quelques millisecondes ?
Imaginez une table qui liste des animaux de compagnie :
| Location | chip_number | name | species |
| -------- | --------------- | -------- | ------- |
| row 1 | 250269812345671 | Rex | dog |
| row 2 | 250268700012938 | Whiskers | cat |
| row 3 | 250269900456120 | Biscuit | dog |
| row 4 | 250268500998877 | Clover | rabbit |
| ... | ... | ... | ... |vous faites
SELECT * FROM pets WHERE chip_number = '250269900456120';Et toute la table est parcourue. Alors que si vous l'indexez :
CREATE INDEX idx_pets_chip ON pets (chip_number);Et voilà, votre base construit une liste séparée qui ne contient que les numéros de puce, triés ! Et la base la lira quand elle en aura besoin !
| chip_number (sorted) | → location |
| -------------------- | ---------- |
| 250268500998877 | row 4 |
| 250268700012938 | row 2 |
| 250269812345671 | row 1 |
| 250269900456120 | row 3 |
| ... | ... |Faites juste attention à ne pas sur-indexer : ça prend de l'espace disque et vos sauvegardes vont en souffrir. Et trop d'index font davantage travailler la RAM à l'écriture.
Bon, on avance !
Scaler les lectures
On entre dans un territoire plus avancé côté base de données ! Il faudra juger en fonction des besoins métier.
Vous avez sûrement vu la plupart des tutoriels qui expliquent comment avoir une base primaire pour les écritures et plusieurs réplicas en lecture. Le but est de répartir la charge équitablement entre les bases. Ces tutoriels partent surtout de cas comme les réseaux sociaux ou le streaming vidéo. Votre cas n'est pas forcément celui-là. Bon, je reconnais que la plupart des cas ont plus de lectures que d'écritures, mais méfiez-vous de certains cas !
Il y a un décalage (appelé "replication lag") entre l'écriture dans la base primaire et la mise à jour des données sur les réplicas. Les réseaux sociaux s'en moquent un peu si vos followers voient votre post 5 ou 10 secondes plus tard. Si vous êtes une app financière, euh, c'est peut-être une autre histoire. Si vous avez vraiment besoin de la donnée juste après l'avoir enregistrée, vous pouvez spécifiquement envoyer cette lecture vers la base primaire.
En Ruby on Rails, on fait comme ça :
ActiveRecord::Base.connected_to(role: :writing) do
user = User.find(42)
endAvec Prisma, vous utilisez l'extension 'readReplicas' et vous pouvez faire ça :44 Je préfère Drizzle à Prisma, cela dit, je mets Prisma parce qu'il est plus populaire. Avec Drizzle, on fait comme ça : const [user] = await db.$primary.select().from(users).where(eq(users.id, 42));
const user = await prisma.$primary().user.findUnique({
where: { id: 42 },
});Le sharding
Bon, il y a une manière facile et une manière difficile, et Dieu merci, je n'ai rencontré que la manière facile.
Le sharding version facile, c'est comme dans la première entreprise où j'ai travaillé. Vous êtes une entreprise B2B, vous avez simplement une base de données par client. La vie est belle !
Pendant ma mission chez L'Équipe, nous avions plusieurs bases de données, une pour chaque sport. Même principe ! Une échelle bien au-dessus de ma première entreprise, mais ça restait gérable.
Et puis il y a la manière difficile !
Je dois l'avouer, là, ça me dépasse un peu, puisque je n'y ai jamais été confronté. J'en ai entendu parler lors d'une présentation à un meetup tech. Puis je me suis documenté. Ce n'est pas quelque chose que je serais à l'aise de faire sur une app en production sans l'avoir fait plusieurs fois dans mon propre lab de serveurs.
Le principe, c'est que votre base devient tellement grosse qu'il faut la faire tourner sur plusieurs machines.
Le sharding, c'est vraiment quand vous avez plusieurs bases de données pour le même service. Pennylane a ce besoin, car ils gèrent une base où certaines tables contiennent des milliards de lignes, et ça grossit tous les jours.55 ils l'ont expliqué lors d'un meetup épique : https://www.meetup.com/fr-fr/paris_rb/events/315975122
La question, c'est : où mettre chaque donnée ? Comment découper la base ?
L'approche courante consiste à prendre l'id de la donnée, à le diviser par le nombre de bases, et le reste indique où elle va.
Par exemple, vous avez le user_id 43 et 4 bases. 43 % 4 = 3, donc la donnée va dans la base n°3.66 si vous êtes du genre pointilleux sur la sécurité, il y a des chances que votre id soit une chaîne de caractères comme un uuid et pas un entier incrémental. Dans ce cas, il faut hasher l'uuid pour obtenir un nombre fixe. Pas besoin que ce soit cryptographique, vous pouvez simplement chercher une fonction sur Google ou demander à une IA de le faire pour vous
Le sharding pose en fait toute une série de problèmes, et le plus anodin, c'est que vous ne pouvez plus simplement faire SELECT COUNT(*) FROM pets. Il faut lancer cette requête sur chaque base et additionner les résultats (on appelle ça le "scatter-gather").
J'imagine ce que ça donne si vous devez faire une requête complexe sur plusieurs bases. On appelle ça des "cross shard queries". Et n'oubliez pas la latence !
Le cache
Bref ! Sharding ou pas, il y a une chose qui vous évitera d'envoyer trop de lectures vers la base : le cache !
Il épargne à votre base des requêtes multiples et répétitives.
Besoin du nombre de likes, de vues et de followers ? Cache
Besoin de la liste des produits ? Cache
Besoin du cours actuel de l'action Apple ? Cache
Et enfin, les files d'attente et les tâches en arrière-plan !
Vous avez besoin d'une file d'attente (queue) si l'opération déclenchée par le client nécessite d'autres requêtes vers des services externes ou d'autres API, pour pouvoir répondre rapidement au client. Votre app place la tâche dans une file, et des workers récupèrent les tâches de la file et les exécutent.
Pensez à mettre en place des retries quand le worker échoue, mais aussi une limite de retries pour éviter les "poison messages" qui dévorent votre CPU. Une alerte de monitoring permettra à un humain d'aller vérifier.
Les commentaires de Claude
Comme on vit à l'ère de l'IA, j'ai demandé à Claude de vérifier mes propos. Comme j'ai la flemme de mélanger ses remarques avec les miennes, vous pouvez lire ses vérifications ci-dessous :
Sur le scaling horizontal : la capacité n'est pas la seule raison d'ajouter des serveurs. Un serveur unique est aussi un point de défaillance unique, donc la disponibilité est souvent la première raison de passer d'une machine à deux.
Sur les serveurs stateless : l'alternative bon marché à un session store, ce sont les "sticky sessions", où le load balancer envoie toujours un utilisateur vers le même serveur. Ça marche, mais si ce serveur tombe, ses utilisateurs perdent leur session, et la charge peut devenir inégale. Les sessions ne sont pas le seul état à sortir des serveurs : les fichiers uploadés sur le disque local d'un serveur posent le même problème. La solution habituelle, c'est un stockage objet comme S3.
Sur les index : le principal coût d'un excès d'index, ce sont des écritures plus lentes, car chaque insertion ou mise à jour doit mettre à jour tous les index de la table. Ils prennent aussi de l'espace disque et entrent en concurrence, pour la mémoire, avec les données que vous voulez vraiment garder en cache. Côté sauvegardes, un dump logique comme pg_dump ne stocke que la définition des index, donc le dump reste léger, mais la restauration prend plus de temps car chaque index est reconstruit. Enfin, un index sur une colonne avec peu de valeurs distinctes, comme species, aide rarement : la base parcourra souvent la table de toute façon.
Sur les réplicas en lecture : envoyer une lecture vers la base primaire juste après une écriture a un nom : "read-your-own-writes". Rails peut le faire pour vous : avec le changement automatique de rôle, après une écriture, il continue d'envoyer les lectures de cet utilisateur vers la primaire pendant un court délai (2 secondes par défaut). Pour l'exemple Drizzle, db doit être créé avec withReplicas(...) pour que $primary existe.
Sur l'ordre des étapes : en pratique, le cache vient généralement avant les réplicas en lecture, et bien avant le sharding. C'est le moyen le moins cher de soulager la base des lectures.
Sur le sharding : la "manière facile" (une base par client, ou par sport) reste du sharding : on parle de sharding par annuaire ou par table de correspondance (directory-based ou lookup-based), où une table indique quelle base contient quel client. C'est facile parce que la clé de sharding correspond à la façon dont les données sont utilisées : la plupart des requêtes restent dans une seule base, et ajouter un client ou un sport ne déplace jamais les données existantes. Ça a quand même ses propres problèmes : les shards peuvent être très inégaux (le football est bien plus gros que le handball), et tout ce qui les couvre tous, comme un fil "dernières actus, tous sports confondus", doit interroger chaque base ou lire depuis un stockage combiné séparé. La "manière difficile" avec id % N a un piège plus gros : passer de 4 à 5 bases change le résultat pour presque toutes les lignes, donc presque toutes les données doivent être déplacées. C'est pour ça qu'on utilise plutôt le consistent hashing, le sharding par plages (range-based) ou une table de correspondance. Le choix de la clé de sharding (client, utilisateur, région...) est généralement la décision la plus importante.
Sur les UUID : les UUID empêchent surtout de deviner les ids, ce qui est utile mais pas vraiment une mesure de sécurité. Les hasher pour le sharding est correct, et les fonctions de hash rapides non cryptographiques comme xxHash ou MurmurHash sont le choix habituel.
Sur le cache : chaque cache doit répondre à la question "à quel point la donnée peut-elle être périmée ?". La réponse est généralement un TTL (durée de vie) : le cours d'une action peut être mis en cache une seconde, une liste de produits quelques minutes. Quand la donnée change, soit vous attendez l'expiration du TTL, soit vous supprimez vous-même l'entrée du cache (l'invalidation de cache, célèbre comme l'une des deux choses difficiles en informatique).
Sur les files d'attente : les files ne servent pas qu'aux appels vers des services externes. Tout travail lent s'y prête : envoi d'emails, redimensionnement d'images, génération de PDF. Les tâches qui échouent après la limite de retries vont généralement dans une "dead letter queue", où un humain peut les examiner. Deux choses vont avec les retries : attendre de plus en plus longtemps entre chaque tentative (exponential backoff), et rendre les tâches idempotentes, c'est-à-dire qu'exécuter deux fois la même tâche a le même effet que l'exécuter une fois. Avec les retries, une tâche finira tôt ou tard par s'exécuter deux fois.
Et maintenant ?
Il y a tellement de choses à apprendre en system design, mais ce sont déjà des fondations solides.
Alors, la suite ?
On n'a pas beaucoup d'illustrations ni d'approche pratique ici, n'est-ce pas ?
Je prévois de faire évoluer cet article. Je pense que le mieux, c'est de prendre une vraie app sur laquelle on pourra tester tous ces concepts ensemble ! En attendant, prenez soin de vous !
Notes
Je suis un grand fan d'Ankidroid
↩L'une des raisons, c'est que je trouve que, même si Ankidroid est un très très bon outil d'apprentissage, son interface par défaut est rebutante. Je suis en train de créer mes propres flashcards avec un style plus soigné, conçu avec Claude
↩D'où l'importance des outils d'observabilité comme Grafana et New Relic connectés à Slack. Vous pouvez aussi utiliser des services de monitoring de disponibilité comme UptimeRobot et Uptime Kuma, en bonus, pour vérifier votre app toutes les 10 minutes environ. Je parlerai peut-être de ma stratégie d'observabilité préférée dans un autre article si j'ai assez de matière.
↩Je préfère Drizzle à Prisma, cela dit, je mets Prisma parce qu'il est plus populaire. Avec Drizzle, on fait comme ça :
↩const [user] = await db.$primary.select().from(users).where(eq(users.id, 42));ils l'ont expliqué lors d'un meetup épique : https://www.meetup.com/fr-fr/paris_rb/events/315975122
↩si vous êtes du genre pointilleux sur la sécurité, il y a des chances que votre id soit une chaîne de caractères comme un uuid et pas un entier incrémental. Dans ce cas, il faut hasher l'uuid pour obtenir un nombre fixe. Pas besoin que ce soit cryptographique, vous pouvez simplement chercher une fonction sur Google ou demander à une IA de le faire pour vous
↩
Ce billet t'a parlé ?
