Article

Concevoir une panne qui reste locale

Une panne peut se propager par les dépendances et les opérations de reprise. Répartir les charges en groupes autonomes permet de limiter son impact.

Un serveur tombe. Les autres commencent à recopier ses données, le réseau se charge et des clients jusque-là épargnés subissent des lenteurs : la reprise a étendu l’incident. Pour qu’une panne reste locale, il faut limiter les machines et les données qui dépendent les unes des autres, puis vérifier que la réparation respecte elle aussi ces limites.

Uber a publié un cas où la reconstruction d’un seul serveur de base de données pouvait solliciter une grande partie des autres ; l’équipe y a répondu par des groupes de serveurs de taille fixe. La même idée s’étend à une application découpée en cellules, à condition de chercher ce qui traverse encore leurs frontières, y compris pendant la réparation.

La reprise peut étendre les conséquences d’une panne

Le retour d’expérience publié par Uber le 1er septembre 2026 décrit ce problème dans M3DB, une base qui conserve des mesures datées. Les données y sont découpées en fragments, appelés shards, et chaque fragment est copié sur plusieurs machines : trois copies dans les exemples de l’article. Ces copies sont toujours rangées dans des zones différentes, c’est-à-dire des ensembles de machines qui peuvent tomber ensemble, comme une baie ou une zone de disponibilité. Dans ce placement, la perte d’une zone n’emporte ainsi jamais, à elle seule, toutes les copies d’un fragment.

Quand un serveur est remplacé, le nouveau doit recopier chacun de ses fragments depuis les serveurs qui en détiennent les autres copies. Or le placement d’origine ne regroupe pas ces copies : un fragment peut se trouver sur n’importe quel serveur, tant que la règle des zones est respectée. Les fragments d’un même serveur ont donc leurs autres copies dispersées sur les serveurs des deux autres zones. Uber calcule qu’avec trois copies sur trois zones, un serveur peut partager des données avec jusqu’aux deux tiers des serveurs, quelle que soit la taille de l’ensemble. La reconstruction d’un serveur remplacé lit alors sur un grand nombre de machines à la fois, et chacune y consacre du disque et du réseau. L’équipe décrit des entrées-sorties étendues et un réseau sous tension sur de nombreux serveurs.

L’étendue d’une reconstruction dépend donc du nombre de machines qui partagent des données avec le serveur perdu, même quand la panne ne touche qu’un serveur.

Des groupes de taille fixe bornent la reconstruction

Pour réduire ce nombre, Uber a introduit des groupes de serveurs de taille fixe, qu’il appelle sous-groupes (subclusters), chacun responsable d’une partie distincte des fragments. En régime stable, toutes les copies d’un fragment restent dans le même groupe, toujours réparties sur des zones différentes. Son exemple comporte douze serveurs, répartis en deux groupes de six. Chaque groupe compte deux serveurs dans chacune des trois zones et détient la moitié des fragments.

Prenons un serveur du premier groupe qui tombe. Les autres copies de ses fragments se trouvent dans les deux autres zones de ce groupe : dans cet exemple, cela fait au plus quatre serveurs. Avec le placement libre, elles pouvaient se trouver sur n’importe lequel des huit serveurs que ces deux zones comptent en tout, ce qui correspond aux deux tiers calculés par Uber. Le second groupe ne participe pas à la reconstruction : l’équipe écrit qu’en régime stable, la panne d’un serveur ne déclenche de reprise qu’à l’intérieur de son groupe.

L’équipe précise les exceptions à ce régime stable : des échanges entre groupes existent temporairement pendant les changements de taille, quand des fragments passent des groupes existants à un nouveau groupe. L’ajout de capacité impose aussi des paliers, en multiples de la taille d’un groupe.

Une cellule applique la même idée à tout un service

Les groupes d’Uber isolent les copies d’une base de données. La même idée vaut pour un service entier, découpé en cellules. La documentation d’architecture AWS décrit une cellule comme une instance complète et indépendante du service, avec ses propres ressources, qui ne partage pas d’état avec les autres cellules et traite une partie des requêtes. Plusieurs cellules assurent ainsi le même service, chacune pour une partie des utilisateurs ou des données.

Un mécanisme de routage dirige chaque requête vers la cellule qui en a la charge, à partir d’une clé, par exemple l’identifiant du client. Le choix de cette clé suit la façon dont le service se découpe naturellement, pour réduire les échanges entre cellules. L’objectif est de contenir des défaillances, y compris celles qu’un déploiement défectueux peut provoquer : une mise à jour fautive installée dans une seule cellule ne touche que les requêtes de cette cellule.

Dans un exemple fictif, une application de gestion sert cinq cents entreprises. Cinq cellules accueillent chacune cent entreprises, avec leur capacité de traitement et leur stockage. Si un import épuise les ressources d’une cellule, les quatre autres peuvent continuer à servir leurs clients, à condition de ne pas dépendre de la ressource saturée.

Cent entreprises dans chaque cellule ne garantissent toutefois pas une charge égale. Une grande entreprise peut générer plus de trafic que quatre-vingt-dix-neuf petites, et si rien ne la borne, elle sature sa cellule et entraîne avec elle les autres clients qui y sont placés. Il faut donc dimensionner les cellules selon la charge observée et limiter ce qu’un seul client peut consommer.

Une cellule n’est isolée que si ses ressources le sont

La condition posée plus haut, ne pas dépendre de la ressource saturée, est celle à vérifier en priorité, parce qu’une dépendance partagée ne se lit pas toujours dans le code. Les frontières entre modules facilitent la compréhension et l’évolution du logiciel. Les frontières de panne dépendent, elles, des ressources utilisées pendant son fonctionnement. Deux services séparés peuvent bloquer ensemble s’ils attendent la même base saturée.

À l’inverse, plusieurs instances d’une même application peuvent servir des groupes de clients distincts, chacune avec ses données et ses ressources : les cinq cellules de l’exemple exécutent le même code. Le choix de la cellule ne dicte donc pas le découpage interne du code. C’est un prolongement de la distinction entre modularité et microservices.

Dans l’application de gestion de l’exemple, quelques dépendances communes suffiraient à remettre en cause l’autonomie des cinq cellules :

Dépendance communeComment l’incident se propageLimite à prévoir
Une base centrale consultée à chaque requêteSa saturation ralentit toutes les cellulesRéduire ces consultations ou garder dans chaque cellule les données nécessaires, avec une règle explicite sur l’âge qu’elles peuvent avoir
Une file de travaux et des exécutants partagésLes imports d’un groupe retardent les tâches des autresRéserver des capacités et fixer des quotas par cellule
Une capacité réseau communeUne restauration consomme le débit utile aux clientsLimiter le débit de reprise et préserver une marge pour les requêtes
Un déploiement simultané partoutLe même défaut atteint chaque celluleDéployer cellule par cellule, observer, puis poursuivre

Le routage, commun à toutes les cellules, reste lui aussi un point à examiner. AWS le veut aussi mince que possible : il dirige les requêtes vers la bonne cellule, et rien d’autre. Il faut encore éviter qu’une cellule en difficulté l’oblige à attendre, car les connexions qu’il garde ouvertes vers elle pourraient épuiser sa capacité de connexion commune et l’empêcher de servir les autres.

Le service qui crée ou déplace les cellules, qu’AWS appelle le plan de contrôle, peut avoir une disponibilité différente de celui qui sert les requêtes courantes. AWS le juge plus susceptible de tomber que le routage et les cellules, et demande que ceux-ci continuent de servir les clients pendant sa panne : dans l’un de ses exemples, le routeur garde en mémoire la table qui associe les clients à leur cellule.

Une cellule doit garder de la capacité pour réparer

La reconstruction décrite par Uber reste dans le groupe touché, mais elle y consomme toujours du disque et du réseau. Une cellule dimensionnée au plus juste peut donc fonctionner normalement et manquer de ressources dès qu’elle perd une machine : les serveurs restants doivent absorber le trafic, puis reconstruire les copies manquantes.

La marge nécessaire dépend du scénario retenu : perte d’une machine, indisponibilité d’une zone, restauration d’une sauvegarde. Elle se mesure avec le volume de données et la charge que le service devra réellement traiter pendant cette période.

Basculer immédiatement tous les clients vers une cellule voisine peut déplacer la surcharge au lieu de la résoudre : dans l’exemple, la voisine recevrait cent entreprises de plus que prévu. Ce secours exige de la capacité disponible, des données utilisables et des règles de bascule préparées. Sans ces conditions, réduisez plutôt certaines fonctions le temps de la reprise, ce qui peut mieux protéger les clients encore servis.

Les nouvelles tentatives reproduisent, à l’échelle d’une requête, le problème du début : la réparation ajoute de la charge. Une requête qui échoue puis revient plusieurs fois augmente la pression sur le service. Les mécanismes de la boîte à outils de la résilience, tels que les délais maximaux, qui bornent l’attente d’une réponse, et la limitation du nombre de reprises, restent nécessaires à l’intérieur des cellules.

La preuve se cherche pendant l’incident

Pour le vérifier, provoquez une panne dans une cellule de test et observez les autres : leurs temps de réponse, le trafic de réparation qu’elles reçoivent, la longueur des files communes. Un écart qui apparaît avec la panne puis la reprise peut indiquer une dépendance encore partagée ; commencez par examiner celles du tableau.

Il faut poursuivre l’exercice pendant le rétablissement. Le retour du serveur, le remplissage des caches ou la redistribution des données peut provoquer un second pic de charge. C’est aussi le moment où les copies se reconstruisent, comme dans le cas d’Uber. Arrêter la mesure dès que les premières requêtes réussissent ferait manquer ce moment.

Ce que demande une panne qui reste locale

Revenons au serveur du début. Le cas Uber montre comment limiter les serveurs sollicités par une reconstruction : les copies restent dans un groupe borné en régime stable. Pour une application en cellules, il reste à vérifier que les ressources nécessaires à la reprise ne sont pas prises aux voisines, et que le groupe touché garde assez de marge pour ses requêtes. L’exercice de panne, mené jusqu’à la fin du rétablissement, permet de chercher les dépendances qui défont cette séparation.

Le découpage en cellules ajoute cependant du travail : placement des clients, suivi de capacité, migrations et exploitation de plusieurs ensembles. Pour une petite application dont les incidents sont déjà bien contenus, ce coût peut dépasser le bénéfice. Mieux vaut alors corriger d’abord la dépendance qui propage les pannes, celle que l’exercice a désignée, avant de multiplier les cellules.

Sources

Explorer

Sur le même sujet

Choisis dans l’index d’après les étiquettes de cet article — les plus proches d’abord, hors de sa série. Rien n’est écrit à la main : un article publié demain avec les mêmes étiquettes y prendra place.

Laisser un commentaire

Elle n'est jamais affichée ni publiée. Elle sert à regrouper vos commentaires et, si vous vous inscrivez un jour avec elle, à vous les rendre.

Votre commentaire sera relu avant d'être publié.