On ne supprime pas les pannes ; on conçoit pour qu'elles ne deviennent pas des catastrophes. Détecter, isoler, basculer — sans se tromper de coupable.
⏱️ Durée : environ 110 minutes · 🎓 Niveau : avancé · 🏅 Badge : Bâtisseur de résilience
🎬 L'histoire
Un jeudi, le serveur de verrous de HashBox est lent pendant quelques secondes. Le client A, qui détient le verrou d'édition d'un cours, se met en pause (ramasse-miettes). Son bail expire, le client B obtient le verrou et écrit. A se réveille, croit toujours détenir le verrou, et écrit par-dessus. Le cours contient un mélange des deux modifications.
« Les deux clients ont fait ce qu'il fallait, dit Sam. Le défaut est dans l'hypothèse : "si je pense avoir le verrou, je l'ai". En distribué, on peut croire détenir un droit qu'on a perdu. La parade s'appelle un jeton de barrière : le stockage lui-même refuse les écritures d'un détenteur périmé. »
Tu apprends à détecter les pannes (battements de cœur, faux positifs), à calculer la disponibilité d'architectures, à utiliser baux et jetons de barrière contre les « cerveaux fendus », et à gérer les transactions distribuées : validation en deux phases (et son blocage) contre sagas avec compensations.
🎯 Ta mission
À la fin, je serai capable de :
- calculer la disponibilité de composants en série et en parallèle
- expliquer le compromis du détecteur de pannes (rapidité de détection contre faux positifs)
- utiliser baux et jetons de barrière pour empêcher les écritures d'un ancien détenteur
- comparer validation en deux phases (2PC) et saga avec compensations
- concevoir des étapes compensables et idempotentes
🧩 Défi d'échauffement (5 XP)
Un hôpital a deux générateurs de secours et une alimentation du réseau. L'alimentation seule est disponible 99,9 % du temps ; chaque générateur 95 %. Si l'hôpital tombe quand tout le courant est coupé, quelle est la disponibilité globale ? Que se passerait-il si le basculement automatique (qui décide de passer sur les générateurs) tombait en panne lui-même ?
💡 Le concept
Disponibilité
La disponibilité est la fraction du temps où le service fonctionne. On parle en « neuf » :
| Disponibilité | Indisponibilité annuelle |
|---|---|
| 99 % | 3,65 jours |
| 99,9 % | 8,76 heures |
| 99,99 % | 52,6 minutes |
| 99,999 % | 5,26 minutes |
Composition (pannes indépendantes) :
- en série (tous nécessaires) :
A = A₁ × A₂ × …— la disponibilité baisse ; - en parallèle (redondance, un seul suffit) :
A = 1 − (1 − A₁)(1 − A₂)…— elle monte.
Dix services à 99,9 % en série : 0,999¹⁰ ≈ 99,0 %. Redonder la partie la plus fragile est le gain le plus rentable. Mais les pannes ne sont pas indépendantes (même alimentation, même version déployée, même configuration) : le calcul est une borne optimiste.
Détecter les pannes
On ne peut pas distinguer « mort » de « lent » (mission 1). Un détecteur de pannes suspecte un nœud quand il n'a pas reçu de battement de cœur (heartbeat) depuis un délai T.
T court | T long |
|---|---|
| détection rapide | détection lente |
| faux positifs : un nœud lent est déclaré mort | peu de faux positifs |
Un faux positif est coûteux : basculement inutile, deux leaders (« cerveau fendu » split brain), charge de rééquilibrage. Raffinements : détecteurs adaptatifs (phi-accrual : seuil fondé sur la distribution observée des délais), suspicion par plusieurs nœuds, confirmation avant action.
Cerveau fendu, baux et jetons de barrière
Un bail (lease) est un droit temporaire (un verrou avec expiration) accordé par un service de coordination. Problème : un client en pause peut croire détenir encore son bail alors qu'il a expiré et qu'un autre l'a obtenu.
Jeton de barrière (fencing token) :
- à chaque octroi de bail, le service délivre un numéro croissant (1, 2, 3…) ;
- le client joint son numéro à chaque écriture ;
- la ressource protégée mémorise le plus grand numéro vu et refuse toute écriture portant un numéro plus petit.
Ainsi un ancien détenteur ne peut plus rien écrire, même s'il se croit légitime. La sûreté est garantie par la ressource, pas par la ponctualité des clients.
Transactions distribuées
Une opération qui touche plusieurs services (réserver une place, débiter, notifier) doit être tout ou rien.
Validation en deux phases (2PC)
- Préparation : le coordinateur demande à tous les participants « pouvez-vous valider ? » ; chacun verrouille les ressources, écrit « prêt » durablement, répond oui/non.
- Validation ou annulation : si tous ont dit oui, le coordinateur ordonne
commit, sinonabort.
Défaut majeur : le blocage. Si le coordinateur tombe après la préparation, les participants « prêts » ne peuvent ni valider ni annuler seuls (peut-être les autres ont-ils déjà validé ?) : ils gardent leurs verrous jusqu'au retour du coordinateur. Peu adapté aux services indépendants et aux longues latences.
Sagas
Une saga découpe l'opération en étapes locales, chacune avec une compensation (action inverse) :
réserver place → débiter → envoyer confirmation
↑ annuler place ↑ rembourser
Si une étape échoue, on exécute les compensations dans l'ordre inverse des étapes déjà faites. Pas de verrou global, mais :
- les états intermédiaires sont visibles (isolation faible) ;
- les compensations doivent être idempotentes et réessayées jusqu'au succès ;
- certaines actions ne sont pas compensables (e-mail envoyé) : les placer en dernier (étape pivot).
Deux styles : chorégraphie (chaque service réagit aux événements des autres) et orchestration (un orchestrateur pilote les étapes).
Dégradation progressive
Quand une dépendance tombe : continuer avec une fonction réduite (afficher sans les recommandations, servir un cache, file d'attente locale), plutôt que tout arrêter. À décider à la conception, par fonction.
Principes de conception
| Principe | Application |
|---|---|
| Éviter les points de défaillance uniques | redondance, y compris pour le basculement lui-même |
| Isoler | cloisons, une panne ne se propage pas |
| Échouer vite | délais courts, disjoncteurs |
| Réparer vite | MTTR faible, automatisation (HEF-120) |
| Tester la panne | ingénierie du chaos |
🧠 Astuce : pour chaque composant, écris : « s'il tombe, qui s'en aperçoit, en combien de temps, et qu'est-ce qui continue de marcher ? » Si personne ne s'en aperçoit, c'est le premier problème.
🔍 Exemple pas à pas
Problème : (1) calculer des disponibilités, (2) mesurer le compromis du détecteur de pannes, (3) montrer qu'un jeton de barrière empêche l'écriture d'un ancien détenteur, (4) illustrer le blocage de la validation en deux phases et (5) exécuter une saga avec compensations, y compris quand une compensation doit être réessayée.
import math, random
# ---------------- 1. disponibilité ----------------
def serie(*a): return math.prod(a)
def parallele(*a): return 1 - math.prod(1 - x for x in a)
print(f"10 services à 99,9 % en série : {serie(*[0.999] * 10):.4%}")
print(f"2 instances à 99 % en parallèle : {parallele(0.99, 0.99):.4%} ; 3 instances : {parallele(*[0.99] * 3):.6%}")
chaine = serie(0.9999, parallele(0.99, 0.99), 0.999) # équilibreur × (2 serveurs en parallèle) × base
print(f"équilibreur 99,99 % × 2 serveurs à 99 % × base 99,9 % = {chaine:.4%} → {(1 - chaine) * 525600:.0f} min d'indisponibilité/an")
assert round(serie(*[0.999] * 10), 3) == 0.990 and round(parallele(, ), ) ==
():
rng = random.Random(graine)
t, dernier, faux, detection = , , ,
arrivees = []
s ():
s >= :
arrivees.append(s + rng.lognormvariate(math.log(), ))
arrivees.sort(); dernier =
suspect =
s (, ):
recus = [a a arrivees dernier < a <= s]
recus: dernier = (recus)
s - dernier > T suspect: faux += ; suspect =
s - dernier <= T: suspect =
detection = T
faux, detection
()
res = {}
T (, , , ):
res[T] = tester_detecteur(T); ()
res[][] > res[][] >= res[][] res[][] > res[][]
:
(): .numero, .detenteur, .expire = , ,
():
.detenteur maintenant >= .expire:
.numero += ; .detenteur, .expire = client, maintenant + duree
.numero
:
(): .avec_barriere, .max_jeton, .contenu, .journal = avec_barriere, , , []
():
.avec_barriere jeton < .max_jeton:
.journal.append();
.max_jeton = (.max_jeton, jeton); .contenu += ; .journal.append();
avec (, ):
bail, st = ServiceBail(), Stockage(avec)
jeton_a = bail.acquerir(, maintenant=)
jeton_b = bail.acquerir(, maintenant=)
st.ecrire(, jeton_b, )
st.ecrire(, jeton_a, )
()
(( st.contenu) == avec)
:
(): .nom, .vote, .etat = nom, vote,
():
.vote: .etat = ;
.etat = ;
(): .etat =
(): .etat =
():
votes = [p.preparer() p participants]
planter_apres_preparation: RuntimeError()
(: [p.valider() p participants])() (votes) [p.annuler() p participants]
ps = [Participant(), Participant(), Participant()]
: deux_phases(ps, planter_apres_preparation=)
RuntimeError e: (e)
(, {p.nom: p.etat p ps})
(p.etat == p ps)
:
(): .etapes = etapes
():
faites = []
nom, action, compensation .etapes:
:
nom == echoue_a: RuntimeError()
action(contexte); faites.append((nom, compensation))
RuntimeError e:
nom_c, comp (faites):
essai ():
:
nom_c == compensation_instable essai < : ConnectionError()
comp(contexte);
ConnectionError:
: AssertionError()
(): {: , : , : [], : }
(): c[] -= ; c[].append()
():
c[]: c[] += ; c[].append()
(): c[] -= ; c[].append()
():
c[]: c[] += ; c[] = ; c[].append()
(): c[].append()
SAGA = Saga([(, reserver, liberer), (, debiter, rembourser), (, confirmer, c: )])
c1 = ctx(); SAGA.executer(c1) == c1[] == c1[] ==
c2 = ctx(); r = SAGA.executer(c2, echoue_a=, compensation_instable=)
(r, , c2[], , c2[], , c2[])
c2[] == c2[] == c2[][-:] == [, ]
Lecture :
- Série/parallèle : dix services à 99,9 % en série donnent ≈ 99 % ; doubler un composant à 99 % passe à 99,99 %. Redonder le maillon faible est le gain le plus rentable.
- Détecteur : un délai court détecte vite mais suspecte souvent un nœud vivant (faux positifs) ; un délai long fait l'inverse. Il n'existe pas de bonne valeur universelle : on arbitre.
- Jeton de barrière : sans jeton, l'écriture périmée de A se mélange à celle de B ; avec jeton, le stockage refuse l'écriture portant le jeton 1 après avoir vu le jeton 2.
- 2PC : le coordinateur tombe après la préparation et les trois participants restent bloqués, verrous tenus, incapables de décider seuls.
- Saga : l'étape de confirmation échoue ; les compensations s'exécutent dans l'ordre inverse (remboursement, puis libération de la place), la compensation du paiement est réessayée deux fois avant de réussir, et elle est idempotente.
✍️ À toi, avec aide (10 XP)
Une application a l'architecture suivante : un équilibreur (99,99 %), deux serveurs d'application en parallèle (99,5 % chacun), un service d'authentification externe (99,9 %), et une base avec un leader et un réplica (chacun 99,9 %, basculement automatique fiable à 99 %).
- Calcule la disponibilité globale (modélise le groupe base : disponible si au moins un des deux est disponible et le basculement fonctionne, ou le leader seul est disponible) ;
- quel est le maillon qui limite le plus la disponibilité globale ? ;
- combien de minutes d'indisponibilité par an ?
- quelle amélioration apporte le plus (ajouter un 3ᵉ serveur d'application, doubler le service d'authentification, ou améliorer le basculement à 99,9 %) ?
💡 Indice 1
Groupe base ≈ A_leader + (1 − A_leader) × A_replica × A_basculement.
💡 Indice 2
Les serveurs d'application en parallèle : 1 − (1 − 0,995)².
💡 Indice 3
Calcule la variation de disponibilité globale pour chaque amélioration.
✅ Réponse
import math
def serie(*a): return math.prod(a)
def parallele(*a): return 1 - math.prod(1 - x for x in a)
def systeme(n_app=2, auth=0.999, bascule=0.99):
base = 0.999 + (1 - 0.999) * 0.999 * bascule # leader OK, ou (leader KO et réplica OK et basculement OK)
return serie(0.9999, parallele(*[0.995] * n_app), auth, base)
ref = systeme()
print(f"globale : {ref:.5%} → {(1 - ref) * 525600:.0f} min/an")
for nom, valeur in (("3e serveur d'application", systeme(n_app=3)), ("auth doublée (99,9 % → 99,9999 %)", systeme(auth=1 - 0.001 ** 2)), ("basculement à 99,9 %", systeme(bascule=0.999))):
print(f" → (+ points)")
(ref - ) <
systeme(auth= - ** ) - ref > systeme(n_app=) - ref > systeme(bascule=) - ref
🚀 À toi, en solo (20 XP)
Verrou distribué sûr. Implémente un service de verrous à baux avec jetons de barrière et un simulateur d'exécution avec pauses :
acquerir(client, t)renvoie un jeton croissant ;renouveler(client, jeton, t)prolonge le bail seulement si le jeton est encore valable ;- une ressource protégée qui applique la barrière ;
- 3 clients qui, chacun, répètent : acquérir, lire la ressource (en présentant leur jeton), pause aléatoire (parfois plus longue que le bail), écrire
valeur + 1avec leur jeton ; - avec un ordonnanceur à graine fixée, sur 300 exécutions : sans barrière, compte les mises à jour perdues (valeur finale < nombre d'écritures acceptées) ; avec barrière, vérifie que chaque écriture acceptée est basée sur la valeur la plus récente (aucune mise à jour perdue) ;
- explique ce que la barrière ne garantit pas (une écriture refusée doit être réessayée par le client, qui peut ne jamais réussir si les pauses sont trop longues : vivacité).
✅ Pistes de correction
import random
class Bail:
def __init__(self): self.jeton, self.detenteur, self.expire = 0, None, -1
def acquerir(self, client, t, duree=10):
if self.detenteur is None or t >= self.expire:
self.jeton += 1; self.detenteur, self.expire = client, t + duree; return self.jeton
return None
class Ressource:
def __init__(self, barriere): self.barriere, self.max_jeton, self.valeur, self.acceptees, self.refusees = barriere, 0, 0, 0, 0
def ():
.barriere:
jeton < .max_jeton:
.max_jeton = jeton
.valeur
():
.barriere jeton < .max_jeton: .refusees += ;
.max_jeton = (.max_jeton, jeton); .valeur = nouvelle; .acceptees += ;
():
rng = random.Random(graine); bail, res = Bail(), Ressource(barriere)
etat = {c: {: , : , : , : } c (clients)}
t =
t < ( c etat etat[c][] != ) > :
t +=
c rng.sample((etat), (etat)):
e = etat[c]
e[] == e[] > t:
e[] == :
j = bail.acquerir(c, t)
j:
lu = res.lire(j)
lu : e.update(jeton=j, lu=lu, phase=, reveil=t + rng.choice([, , , ]))
e[] == :
res.ecrire(e[], e[] + )
e[] = rng.random() <
res
perdues_sans = perdues_avec =
g ():
avec (, ):
r = simuler(avec, g)
perdu = r.acceptees - r.valeur
avec: perdues_avec += (perdu, )
: perdues_sans += (perdu, )
()
perdues_sans > perdues_avec ==
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Croire qu'un bail non expiré à l'instant de la lecture est encore valide à l'écriture | Écritures d'un ancien détenteur | Jeton de barrière vérifié par la ressource |
| Détecteur de pannes à délai court sans confirmation | Basculements inutiles, deux leaders | Délai adapté, plusieurs observateurs, adaptatif |
| 2PC entre services indépendants | Blocage des verrous si le coordinateur tombe | Sagas avec compensations idempotentes |
| Compensation non idempotente ou jamais réessayée | Remboursements en double ou oubliés | Idempotence + réessai jusqu'au succès |
🐉 Mini-boss (40 XP)
Matrice de pannes de HashBox. Prends l'architecture du service d'inscription (équilibreur, API ×3, paiement externe, base leader+réplica, file de messages, cache) et :
- calcule sa disponibilité globale ; classe les composants par contribution à l'indisponibilité ;
- écris la matrice des pannes : pour chaque composant, mode de panne, détection (délai, faux positifs), impact utilisateur, mécanisme de repli, procédure de reprise ;
- implémente la saga d'inscription (place → paiement → notification → statistiques) avec orchestrateur durable (reprise après plantage), compensations idempotentes, étape pivot ;
- injecte exhaustivement une panne à chaque point (avant/après chaque étape et chaque compensation) et vérifie l'invariant : à la fin, soit tout est fait une fois, soit rien n'est fait ;
- implémente un verrou à bail avec jeton de barrière pour la modification concurrente d'un cours, et un test où un client est « mis en pause » ;
- rédige un plan d'exercice de panne (« jour de jeu ») : 5 scénarios, hypothèse, mesure, critère de réussite.
✅ Pistes de correction
Un bon travail : calcul de disponibilité avec groupes parallèles et séries, tableau classant le paiement externe en tête; saga avec journal durable (étape courante + états de compensation), test exhaustif d'injection (n étapes × 3 points); verrou avec jetons croissants vérifiés par la ressource; plan d'exercice précis (par exemple « tuer le leader de la base pendant 1 000 inscriptions/min : hypothèse : < 5 erreurs, rétablissement < 30 s »).
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Un jeton de barrière (fencing token) empêche :
- A. la perte de paquets
- B. l'écriture d'un ancien détenteur d'un bail expiré
- C. les doublons de messages
2. Dans la validation en deux phases, si le coordinateur tombe après la préparation :
- A. tout est automatiquement annulé
- B. tout est automatiquement validé
- C. les participants prêts restent bloqués, verrous tenus
3. Dans une saga, les compensations s'exécutent :
- A. dans l'ordre inverse des étapes déjà faites, et doivent être idempotentes
- B. dans le même ordre, une seule fois
- C. sans ordre
4. 🔁 Révision mission 08 : Valider l'offset après le traitement d'un message donne la sémantique :
- A. au plus une fois
- B. au moins une fois
- C. exactement une fois garantie par le réseau
5. 🔁 Révision mission 08 : Le patron outbox sert à :
- A. chiffrer les messages
- B. accélérer le courtier
- C. publier un événement de façon atomique avec la modification en base
✅ Réponses
- B.
- C.
- A.
- B.
- C.
🪞 Je réfléchis (10 XP)
- Quel composant de ton système, s'il tombait, ne serait remarqué par personne avant les utilisateurs ?
- Quelle opération multi-services de ton système est « tout ou rien » sans que personne n'ait écrit comment on annule ?
🎒 À retenir
- Disponibilité : série multiplie, parallèle redonde ; les pannes réelles ne sont pas indépendantes.
- Détecteur : délai court = rapide mais faux positifs ; compromis explicite.
- Bail + jeton de barrière : c'est la ressource qui refuse l'ancien détenteur.
- 2PC bloque ; sagas = étapes + compensations idempotentes, pivot en dernier.
- Dégrader plutôt que s'arrêter ; tester la panne.
flowchart LR
T(["Tolérance aux pannes"])
T --> R1["1. Disponibilité : série multiplie, parallèle redonde ; les pannes…"]
T --> R2["2. Détecteur : délai court = rapide mais faux positifs ; compromis…"]
T --> R3["3. Bail + jeton de barrière : c'est la ressource qui refuse l'ancien…"]
T --> R4["4. 2PC bloque ; sagas = étapes + compensations idempotentes, pivot en…"]
T --> R5["5. Dégrader plutôt que s'arrêter ; tester la panne."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Bâtisseur de résilience
← Mission 08 — Files et événements · Mission 10 — Conception d'un service distribué →
HEF-140 — Systèmes distribués

