Assembler partitionnement, réplication, idempotence, messages et reprise sur panne en un service dont on peut démontrer les garanties — par simulation, injection de pannes et invariants.
⏱️ Durée : environ 125 minutes · 🎓 Niveau : avancé · 🏅 Badge : Architecte du distribué
🎬 L'histoire
HashBox lance les inscriptions en direct pour un événement de 5 000 personnes. Chaque cours a 40 places, des milliers de personnes cliquent en même temps, des serveurs tombent, des réseaux coupent, des utilisateurs cliquent deux fois. Maya pose les exigences : « Jamais plus de 40 inscrits. Jamais deux fois la même personne. Jamais une inscription confirmée qui disparaît. Et si possible, le service reste disponible. »
« Quatre invariants, dit Sam. On ne les garantira pas en espérant. On les garantit en choisissant des mécanismes précis — et on le vérifie par simulation, en injectant des pannes comme le ferait un adversaire. »
Dans cette dernière mission, tu conçois un service distribué complet, tu écris ses invariants, et tu les mets à l'épreuve avec un banc d'essai de pannes aléatoires — où une conception naïve échoue et une conception réfléchie tient.
🎯 Ta mission
À la fin, je serai capable de :
- partir d'exigences pour fixer des invariants vérifiables (sûreté) et des objectifs de disponibilité (vivacité)
- choisir des mécanismes (partitionnement, réplication, idempotence, échéances) justifiés par les invariants
- simuler un service distribué avec réseau défaillant, doublons et réordonnancements
- vérifier les invariants sur de nombreuses exécutions aléatoires (test à la Jepsen)
- documenter l'architecture : diagrammes, contrats, scénarios de panne, décisions (ADR)
🧩 Défi d'échauffement (5 XP)
Tu organises une soirée avec 40 places et un système de réservation par SMS. Liste les façons dont cela peut mal tourner : deux personnes prennent la dernière place en même temps, quelqu'un envoie deux fois le même SMS parce que la réponse tarde, le téléphone du responsable tombe en panne. Pour chaque problème, quelle règle simple protégerait ?
💡 Le concept
Démarche de conception
flowchart TB
E["1. Exigences"] --> I["2. Invariants (sûreté)"]
I --> M["3. Mécanismes"]
M --> S["4. Scénarios de panne"]
S --> V["5. Vérification par simulation"]
V --> D["6. Décisions et documentation"]
V -.->|échec| M
Description du schéma : six étapes : exigences, invariants, mécanismes, scénarios de panne, vérification par simulation, décisions et documentation ; un échec à la vérification renvoie à la conception des mécanismes.
1. Des exigences aux invariants
Distinguer :
| Type | Définition | Exemple |
|---|---|---|
| Sûreté (safety) | « quelque chose de mauvais n'arrive jamais » | jamais plus de 40 inscrits ; jamais d'inscription confirmée perdue |
| Vivacité (liveness) | « quelque chose de bon arrive finalement » | toute demande reçoit finalement une réponse |
| Qualité de service | niveau mesuré | 99,9 % des inscriptions en moins de 500 ms |
La sûreté s'énonce comme un invariant vérifiable sur n'importe quelle exécution. En cas de conflit pendant une panne, on sacrifie la vivacité avant la sûreté pour les données critiques (mission 7).
2. Du mécanisme à la garantie
| Invariant | Menace | Mécanisme |
|---|---|---|
| Pas de surbooking | deux inscriptions concurrentes qui lisent la même place libre | un seul écrivain par cours (partition par cours, leader), opération « vérifier puis agir » atomique |
| Pas de doublon d'intention | relance après réponse perdue, double-clic | clé d'idempotence + réponse mémorisée |
| Pas de perte d'une inscription confirmée | panne du leader | réplication à la majorité avant confirmation, élection à majorité |
| Disponibilité | panne d'un nœud | réplicas + basculement ; clients avec délai, relances bornées, échéance |
La conception est la table qui relie chaque menace à un mécanisme. Chaque ligne doit être testée.
3. Les scénarios de panne
Pour chaque composant et chaque message : perdu, dupliqué, retardé, réordonné ; nœud : arrêté, redémarré, ralenti, isolé ; client : abandonne, relance, clique deux fois.
4. Vérifier par simulation
Un banc d'essai déterministe :
- modèle du système (processus, réseau avec fautes configurables) ;
- graine pour la reproductibilité : un échec se rejoue à l'identique ;
- génération de charges et fautes aléatoires ;
- invariants vérifiés à la fin (et au fil de l'eau) ;
- des centaines/milliers de graines ;
- minimisation : réduire un scénario en échec au plus petit qui échoue encore.
C'est la méthode de la simulation déterministe (FoundationDB) et des tests Jepsen. Elle révèle des bugs de concurrence et de panne que les tests classiques ne voient presque jamais.
5. Documenter
| Document | Contenu |
|---|---|
| Diagramme d'architecture | composants, flux, frontières de confiance |
| Contrats | API, événements, erreurs, idempotence |
| Invariants et mécanismes | la table menace → mécanisme → test |
| Scénarios de panne | hypothèses, comportement attendu, résultat des essais |
| ADR (registre des décisions) | contexte, options, décision, conséquences |
| Exploitation | indicateurs, alertes, procédures |
🧠 Astuce : une conception distribuée n'est pas « correcte » parce qu'elle est élégante : elle l'est parce que tu as essayé de la casser, avec méthode, et qu'elle a tenu.
🔍 Exemple pas à pas
Problème : trois conceptions du service d'inscription en direct, comparées par un banc d'essai de pannes (réseau qui perd les requêtes et les réponses, duplique les messages, clients qui relancent, exécutions entrelacées). Invariants : ① jamais plus de 40 inscrits, ② jamais deux inscriptions pour une même personne, ③ toute inscription confirmée est présente.
import random
CAPACITE = 5 # réduit à 5 places pour que la ruée soit sévère
class Reseau:
# Chaque appel peut : perdre la requête, dupliquer la requête, perdre la réponse.
def __init__(self, rng, p_perte_req=0.15, p_dup=0.15, p_perte_rep=0.15):
self.rng, self.pr, self.pd, self.pp = rng, p_perte_req, p_dup, p_perte_rep
# ---------------- le service : trois conceptions ----------------
class Service:
def __init__(self, conception):
self.c = conception
self.inscrits = [] # liste de (membre, cle)
self.reponses = {} # clé d'idempotence → réponse mémorisée
self.replique = [] # copie sur un second nœud (durabilité)
# --- conception A : naïve (lire puis écrire, sans clé) : la lecture et l'écriture sont séparées par un point d'entrelacement ---
def inscrire_A(self, membre, cle):
n = len(self.inscrits)
yield # un autre client peut s'exécuter ici
n < CAPACITE:
.inscrits.append((membre, cle));
():
cle .reponses: .reponses[cle]
n = (.inscrits)
r =
n < CAPACITE: .inscrits.append((membre, cle)); r =
.reponses[cle] = r; r
():
cle .reponses: .reponses[cle]
(m == membre m, _ .inscrits): r =
(.inscrits) < CAPACITE:
.inscrits.append((membre, cle)); .replique.append((membre, cle)); r =
: r =
.reponses[cle] = r
r
():
operation = (service, )
_ (essais):
reseau.rng.random() < reseau.pr: ;
copies = reseau.rng.random() < reseau.pd
resultat =
_ (copies):
resultat = operation(membre, cle)
reseau.rng.random() < reseau.pp: ;
journal.append((membre, resultat));
journal.append((membre, ))
():
rng = random.Random(graine); reseau = Reseau(rng); service = Service(conception); journal = []
taches = []
i (nb_membres):
taches.append(client(service, reseau, , , journal))
i (nb_doubles_clics):
taches.append(client(service, reseau, , , journal))
taches:
t = rng.choice(taches)
: (t)
StopIteration: taches.remove(t)
service, journal
():
violations = []
membres = [m m, _ service.inscrits]
(service.inscrits) > CAPACITE: violations.append()
(membres) != ((membres)): violations.append()
confirmes = {m m, r journal r == }
confirmes <= (membres): violations.append()
violations
()
bilan = {}
conception :
compte = {: , : , : }; fautives =
graine ():
service, journal = executer(conception, graine)
v = verifier(service, journal)
fautives += (v)
x v: compte[x] +=
bilan[conception] = (fautives, compte)
()
bilan[][] > bilan[][][] > bilan[][][] >
bilan[][][] < bilan[][][] bilan[][][] >
bilan[][] ==
Lecture :
| Conception | Mécanismes | Résultat sur 500 exécutions aléatoires |
|---|---|---|
| A (naïve) | aucun | surbooking et doublons (relances, doublons réseau, doubles clics) dans presque toutes les exécutions |
| B | + clé d'idempotence | les doublons dus aux relances et au réseau disparaissent, mais pas les doubles clics (nouvelle intention) ni le surbooking : deux inscriptions lisent la même place libre |
| C | + écrivain unique (vérifier-puis-agir atomique, règle « déjà inscrit ») + clé + réplication avant confirmation | zéro violation sur 500 exécutions |
Le banc d'essai trouve des défauts de conception que des tests unitaires ne verraient jamais (entrelacements rares). Chaque mécanisme ajouté répond à une menace précise, et le test le prouve en le supprimant : la conception B montre ce que la clé apporte ET ce qu'elle ne suffit pas à garantir. Un doublon de personne (même membre, deux clés différentes) n'est évité que par la règle métier « déjà inscrit », ajoutée en C.
✍️ À toi, avec aide (10 XP)
Rédige l'ADR (registre de décision d'architecture) de la décision « partitionner les inscriptions par cours avec un leader par partition, réplication à la majorité » pour l'événement de HashBox :
- Contexte : les exigences (invariants, volumes) ;
- Options considérées : (a) une base unique, (b) partitionnement par cours avec leader, (c) quorum sans leader (R + W > N) ;
- Décision et raisons (une phrase par invariant) ;
- Conséquences positives et négatives, risques et comment les surveiller ;
- Tests qui valident la décision.
Écris-le sous forme de dictionnaire Python, puis une petite fonction qui vérifie que l'ADR est complet (toutes les sections non vides, chaque invariant relié à un mécanisme et à un test).
💡 Indice 1
Utilise les invariants de la mission : pas de surbooking, pas de doublon, pas de perte.
💡 Indice 2
Option (c) : un quorum seul ne rend pas « vérifier puis agir » atomique.
💡 Indice 3
Conséquence négative : un cours très populaire = un point chaud (mission 6).
✅ Réponse
ADR = {
"titre": "ADR-007 : partitionner les inscriptions par cours avec un leader par partition",
"contexte": "5 000 personnes, 40 places par cours, clics simultanés et doubles ; invariants : jamais > 40 inscrits, jamais de doublon, jamais de perte d'une inscription confirmée.",
"options": {"a": "base unique : simple mais point de défaillance unique et débit limité",
"b": "partition par cours, un leader par partition, réplication à la majorité",
"c": "quorum sans leader (R + W > N) : bonne disponibilité mais ne rend pas atomique « vérifier puis agir »"},
"decision": "option b",
"raisons": {"pas de surbooking": "un seul écrivain par cours rend le contrôle de capacité atomique",
"pas de doublon": "clé d'idempotence par intention + règle « déjà inscrit »",
"pas de perte": "confirmation après réplication à la majorité ; élection à la majorité"},
"consequences": {"positives": ["invariants simples à garantir", "partitions indépendantes : parallélisme"],
"negatives": ["un cours très demandé = point chaud", "indisponibilité de la partition minoritaire pendant une coupure"],
"risques": ["cerveau fendu après basculement : atténué par jetons de barrière", "retard de réplication : surveillé par une alerte"]},
"tests": {"pas de surbooking": , : ,
: },
}
():
manques = [k k (, , , , , , ) adr.get(k)]
inv adr[]:
inv adr[]: manques.append()
adr[].get(): manques.append()
manques
verifier_adr(ADR) == []
verifier_adr((ADR, tests={})) != []
()
🚀 À toi, en solo (20 XP)
Étendre le banc d'essai : panne du leader et basculement. Ajoute à la conception C de l'exemple :
- deux réplicas (3 copies) et un leader ; l'inscription est confirmée au client après écriture sur au moins 2 copies ;
- une panne aléatoire du leader pendant l'exécution : un basculement élit le réplica le plus à jour (parmi les copies disponibles, au moins 2 sur 3) ;
- une variante dangereuse : confirmation après écriture sur le leader seul (réplication asynchrone) ;
- sur 500 graines avec panne du leader, vérifie l'invariant « toute inscription confirmée survit à la panne » : la variante dangereuse doit en perdre, la variante à quorum non ;
- explique pourquoi, dans la variante à quorum, les clés d'idempotence doivent elles aussi être répliquées si l'on veut que la relance d'un client (après la perte d'une réponse) obtienne la réponse d'origine (« confirmé ») plutôt que « déjà inscrit ».
✅ Pistes de correction
import random
CAP = 5
class Groupe:
def __init__(self, replication):
self.copies = [[], [], []] # inscrits par copie (0 = leader au départ)
self.leader, self.vivants, self.replication = 0, {0, 1, 2}, replication
self.cles = [{}, {}, {}] # réponses mémorisées par copie
def panne_leader(self):
self.vivants.discard(self.leader)
self.leader = max(sorted(self.vivants), key=lambda c: len(self.copies[c])) # basculement : la copie la plus à jour
def inscrire(self, membre, cle):
L = self.leader
if cle in self.cles[L]: return self.cles[L][cle]
if membre in .copies[L]: r =
(.copies[L]) >= CAP: r =
:
.copies[L].append(membre)
.replication == :
autre = (c c (.vivants) c != L)
.copies[autre].append(membre)
r =
.cles[L][cle] = r
r
():
rng = random.Random(graine); g = Groupe(replication)
membres, confirmes = [ i (CAP)], ()
panne_a = rng.randrange(, CAP + )
i, m (membres):
i == panne_a: g.panne_leader()
g.inscrire(m, ) == : confirmes.add(m)
panne_a == CAP: g.panne_leader()
(confirmes - (g.copies[g.leader]))
nom, repl ((, ), (, )):
pertes = ( g () execution(repl, g) > )
()
( g () execution(, g) > ) >
( g () execution(, g) > ) ==
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Énoncer des exigences sans invariants vérifiables | On ne peut pas tester ce qu'on ne sait pas dire | Invariants de sûreté explicites, mesurables |
| Tester seulement le cas heureux | Les bugs de concurrence et de panne restent invisibles | Banc d'essai avec fautes aléatoires et graines |
| Choisir un mécanisme sans le relier à une menace | Complexité inutile ou trous de sécurité | Table menace → mécanisme → test |
| Documenter sans assumer les inconvénients | Décisions non réexaminées | ADR avec conséquences négatives et risques |
🐉 Mini-boss (60 XP)
Projet : architecture d'un mini-service distribué avec preuves par simulation. Choisis un service (inscriptions en direct de HashBox, ou une alternative : réservation de ressources, compteur de stock, file de tâches) et livre :
- exigences et invariants de sûreté (au moins 4) + objectifs de vivacité/disponibilité ;
- architecture : diagramme Mermaid (composants, flux, partitions, réplicas), contrats (API, événements, erreurs, idempotence), choix de partitionnement et réplication justifiés ;
- table menace → mécanisme → test (au moins 8 lignes) ;
- simulateur déterministe : processus, réseau avec pertes/duplications/retards/réordonnancements, pannes et redémarrages de nœuds, clients qui relancent ;
- banc d'essai : au moins 1000 graines, invariants vérifiés, rapport avec nombre de violations par invariant ;
- deux conceptions dégradées (en supprimant un mécanisme à la fois) pour prouver que chaque mécanisme est nécessaire ;
- minimisation : pour une graine en échec, réduis le scénario à moins de 15 événements et décris la cause ;
- ADR (au moins 3 décisions), runbook de 3 pannes, plan d'exercice de panne ;
- rétrospective (15 lignes) : quel mécanisme a le plus apporté, ce que la simulation n'a pas couvert (réalisme du réseau, horloges, disque), quelles garanties tu ne donnerais pas en production sans test réel.
✅ Pistes de correction
Un bon projet : exigences et invariants précis; diagramme et contrats; table menace → mécanisme → test avec au moins une ligne par mission du module (horloges/causalité, RPC et délais, retries et budget, idempotence, réplication et quorum, partitionnement, consensus ou leader, messages et outbox, pannes et compensations); simulateur avec graine; rapport de violations par invariant pour la version complète (0) et les versions dégradées (>0, chaque mécanisme retiré fait apparaître une violation distincte); minimisation par suppression itérative d'événements (delta debugging); ADR sans complaisance; rétrospective honnête sur les limites de la simulation.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Un invariant de sûreté est :
- A. une propriété qui doit être vraie dans toute exécution, par exemple « jamais plus de N inscrits »
- B. un objectif de vitesse
- C. une fonctionnalité optionnelle
2. Le banc d'essai à graines fixées permet :
- A. de supprimer toutes les pannes
- B. de rejouer à l'identique une exécution qui a violé un invariant
- C. d'éviter d'écrire des tests
3. Pour garantir « pas de surbooking » malgré des clics concurrents, il faut notamment :
- A. plus de serveurs
- B. une clé d'idempotence seule
- C. un contrôle de capacité atomique, par exemple un écrivain unique par cours
4. 🔁 Révision mission 09 : Un jeton de barrière (fencing token) empêche :
- A. l'écriture d'un ancien détenteur d'un bail expiré
- B. la perte de paquets
- C. les doublons de messages
5. 🔁 Révision mission 09 : Dans une saga, les compensations s'exécutent :
- A. dans le même ordre, une seule fois
- B. dans l'ordre inverse des étapes déjà faites, et doivent être idempotentes
- C. sans ordre
✅ Réponses
- A.
- B.
- C.
- A.
- B.
🪞 Je réfléchis (10 XP)
- Quels invariants de ton système pourraient être violés par une panne rare, sans qu'aucun test ne l'ait jamais essayé ?
- Quel mécanisme de ce module ajouterais-tu en premier à un système que tu connais ?
🎒 À retenir
- Exigences → invariants de sûreté → mécanismes → scénarios de panne → vérification.
- Table menace → mécanisme → test ; chaque mécanisme répond à une menace.
- Simulation déterministe avec fautes aléatoires : trouve les entrelacements rares.
- Supprimer un mécanisme et montrer la violation prouve sa nécessité.
- Documenter : diagrammes, contrats, ADR avec inconvénients assumés, runbooks.
🏅 Récompenses
Total possible : 120 XP · 🏅 Badge Architecte du distribué
← Mission 09 — Tolérance aux pannes
🎉 Félicitations
Tu as terminé HEF-140 — Systèmes distribués. Tu sais raisonner avec des pannes partielles et sans horloge commune, concevoir des échanges fiables (délais, retries, idempotence), répliquer et partitionner des données, énoncer CAP sans caricature, comprendre un consensus de type Raft, utiliser messages et événements, et vérifier par simulation qu'un service tient ses invariants sous pannes.
→ Prochain module : HEF-150 — Ingénierie produit
HEF-140 — Systèmes distribués

