Tout finit par tomber en panne. La question est : combien de temps, quel impact, et à quelle vitesse revient-on à un état sain ?
⏱️ Durée : environ 105 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Funambule avec filet
🎬 L'histoire
Un jeudi soir, un déploiement de HashBox augmente le temps de réponse de la base. Les requêtes s'accumulent, les clients relancent, la charge double, la base s'effondre. Une panne locale devient une panne totale : c'est la cascade. Il faut une heure pour reprendre la main.
« Le déploiement n'est pas le vrai problème, dit Maya. Le vrai problème, c'est que chaque composant a continué de harceler un voisin déjà en difficulté. Un système résilient se protège : il abandonne vite, ne retente pas bêtement, et sait revenir en arrière. »
Tu apprends à revenir en arrière proprement, et les mécanismes de résilience : délais d'attente, tentatives avec recul exponentiel, disjoncteur, dégradation progressive, sauvegardes, exercices de panne.
🎯 Ta mission
À la fin, je serai capable de :
- choisir entre retour arrière et correction en avant (rollback / roll-forward)
- implémenter des tentatives avec recul exponentiel et gigue (jitter)
- implémenter un disjoncteur (circuit breaker) avec états fermé, ouvert, semi-ouvert
- calculer RTO et RPO d'un plan de sauvegarde
- préparer et mener un exercice de panne contrôlé (chaos engineering)
🧩 Défi d'échauffement (5 XP)
Dans un immeuble, quand un appareil électrique surchauffe, le disjoncteur coupe le courant de ce circuit pour protéger toute l'installation. Après réparation, on le réarme. Que se passerait-il sans disjoncteur ? Quel équivalent logiciel imagines-tu quand un service dont tu dépends tombe en panne ?
💡 Le concept
Revenir en arrière
| Stratégie | Quand | Condition |
|---|---|---|
| Rollback (retour arrière) | un déploiement dégrade le service | version précédente toujours disponible ; base compatible (mission 7) |
| Roll-forward (correction en avant) | le correctif est petit et rapide, ou le retour arrière est impossible (données migrées) | pipeline rapide et fiable |
| Désactivation par drapeau | la fonctionnalité est derrière un drapeau | le plus rapide : un interrupteur |
Le temps de rétablissement (MTTR, mission 1) dépend de la simplicité du retour arrière. Il se prépare avant, pas pendant l'incident.
Contrôles de santé : liveness (« le processus vit-il ? » sinon redémarrage) et readiness (« est-il prêt à recevoir du trafic ? » sinon retiré du routage). Un déploiement automatique s'arrête si les contrôles échouent.
Les pannes en cascade
Un composant lent ou en panne → ses clients attendent → leurs ressources (threads, connexions) se remplissent → ils tombent aussi → la panne remonte. Les relances automatiques aggravent la situation (tempête de tentatives, retry storm).
Les mécanismes de défense
| Mécanisme | Idée |
|---|---|
| Délai d'attente (timeout) | ne jamais attendre indéfiniment ; mieux vaut échouer vite |
| Tentatives avec recul exponentiel | réessayer, mais en espaçant de plus en plus (1 s, 2 s, 4 s…) |
| Gigue (jitter) | ajouter de l'aléa pour que les clients ne retentent pas tous au même instant |
| Budget de tentatives | limiter le nombre total (3 essais, pas 30) |
| Disjoncteur | après N échecs, arrêter d'appeler pendant un temps, puis tester prudemment |
| Cloisonnement (bulkhead) | réserver des ressources par fonction pour qu'une panne ne contamine pas tout |
| Dégradation progressive | continuer avec un service réduit (cache, valeur par défaut) |
| Limitation de débit / délestage | refuser une partie du trafic pour préserver le reste |
On ne retente que des opérations idempotentes et des erreurs transitoires (délai, 503), jamais des erreurs définitives (400, 404).
Le disjoncteur
stateDiagram-v2
[*] --> Ferme
Ferme --> Ouvert: N échecs consécutifs
Ouvert --> SemiOuvert: délai écoulé
SemiOuvert --> Ferme: appel d'essai réussi
SemiOuvert --> Ouvert: appel d'essai échoué
Description du schéma : trois états. Fermé (les appels passent). Après N échecs consécutifs : ouvert (les appels sont refusés immédiatement). Après un délai : semi-ouvert (un appel d'essai est autorisé). Si l'essai réussit : retour à fermé ; s'il échoue : retour à ouvert.
Sauvegardes et reprise
| Sigle | Sens | Question |
|---|---|---|
| RPO (Recovery Point Objective) | perte de données maximale acceptable | combien d'heures de données peut-on perdre ? |
| RTO (Recovery Time Objective) | délai maximal de rétablissement | en combien de temps doit-on être de nouveau en service ? |
- Sauvegarde toutes les 24 h → RPO ≈ 24 h ; avec réplication continue → RPO de quelques secondes.
- Règle 3-2-1 : 3 copies, sur 2 supports différents, dont 1 hors site.
- Une sauvegarde non restaurée n'est pas une sauvegarde : tester régulièrement la restauration.
Ingénierie du chaos
On provoque volontairement des pannes (instance arrêtée, latence ajoutée, dépendance coupée) dans un cadre contrôlé pour vérifier que les défenses fonctionnent :
- définir l'état stable mesurable (SLI) ;
- formuler une hypothèse (« si le cache tombe, le taux de succès reste > 99 % ») ;
- injecter la panne, à petite échelle d'abord, avec un bouton d'arrêt ;
- observer, comparer à l'hypothèse ;
- corriger et recommencer.
Procédures d'urgence (runbooks)
Pour chaque alerte : un document court, à jour, avec symptômes, vérifications, actions, personnes à joindre, et critères d'escalade. Un exercice périodique (« jour de jeu ») les valide.
🧠 Astuce : chaque fois que tu écris un appel à un autre service, écris en même temps : le délai d'attente, ce qu'on fait en cas d'échec, et si l'opération peut être rejouée sans danger.
🔍 Exemple pas à pas
Problème : implémenter des tentatives avec recul exponentiel et gigue, un disjoncteur, puis montrer par simulation qu'ils évitent la cascade.
import random
# ---------------- horloge simulée et dépendance instable ----------------
class Horloge:
def __init__(self): self.t = 0.0
def __call__(self): return self.t
def dormir(self, s): self.t += s
class DependanceEnPanne:
def __init__(self, horloge, pannes): # pannes : liste d'intervalles [(debut, fin)]
self.h, self.pannes, self.appels = horloge, pannes, 0
def appeler(self):
self.appels += 1
if any(a <= self.h() < b for a, b in self.pannes):
raise ConnectionError("dépendance indisponible")
return "ok"
# ---------------- tentatives avec recul exponentiel et gigue ----------------
def avec_tentatives():
rng = rng random.Random()
numero (essais):
:
fonction()
ConnectionError:
numero == essais - :
attente = (plafond, base * ** numero)
horloge.dormir(rng.uniform(, attente))
AssertionError
h = Horloge()
dep = DependanceEnPanne(h, [(, )])
avec_tentatives(dep.appeler, h, rng=random.Random()) ==
()
:
():
.h, .seuil, .delai = horloge, seuil, delai
.etat, .echecs, .ouvert_a = , ,
():
.etat == :
.h() - .ouvert_a >= .delai:
.etat =
:
RuntimeError()
:
resultat = fonction()
ConnectionError:
.echecs +=
.etat == .echecs >= .seuil:
.etat, .ouvert_a = , .h()
.etat, .echecs = ,
resultat
h = Horloge()
dep = DependanceEnPanne(h, [(, )])
dj = Disjoncteur(h, seuil=, delai=)
refus, vers_dependance = ,
_ ():
h.dormir()
en_panne = h() <=
avant = dep.appels
:
dj.appeler(dep.appeler)
RuntimeError:
refus +=
ConnectionError:
en_panne:
vers_dependance += dep.appels - avant
()
vers_dependance < refus >
dj.etat ==
():
rng, h = random.Random(graine), Horloge()
dep = DependanceEnPanne(h, [(, )])
dj = Disjoncteur(h, seuil=, delai=)
sollicitations_dependance =
_ ():
h.dormir()
_tentative ( avec_protection ):
avant = dep.appels
:
(dj.appeler(dep.appeler) avec_protection dep.appeler())
(RuntimeError, ConnectionError):
:
sollicitations_dependance += dep.appels - avant
sollicitations_dependance
sans, avec = charge(), charge()
()
sans > * avec
Lecture :
- Recul exponentiel avec gigue : après une panne brève, la nouvelle tentative réussit sans marteler la dépendance.
- Disjoncteur : pendant une panne de 30 s, plus de 100 appels sur 120 sont refusés localement (instantanément, sans toucher la dépendance), alors que seuls quelques appels d'essai (trois échecs pour ouvrir, puis un essai toutes les dix secondes) sont envoyés. Une fois la dépendance revenue, le disjoncteur se referme tout seul.
- Cascade : sans protection, la dépendance en difficulté reçoit plusieurs fois plus d'appels (relances immédiates) que d'habitude, ce qui l'empêche de se rétablir. Avec le disjoncteur, elle est laissée tranquille pendant la panne.
✍️ À toi, avec aide (10 XP)
Calcule RPO et RTO pour trois plans de sauvegarde et compare à un besoin de RPO ≤ 15 min et RTO ≤ 1 h :
| Plan | Sauvegarde | Restauration |
|---|---|---|
| A | complète toutes les 24 h à minuit | 3 h (téléchargement + restauration) |
| B | complète toutes les 24 h + journaux de transactions toutes les 5 min | 1 h 30 |
| C | réplique synchrone vers un site secondaire + bascule automatique | 5 min |
Pour chacun : RPO et RTO pires cas, verdict, et recommandation de coût (A, B, C selon le besoin).
💡 Indice 1
RPO pire cas = intervalle entre deux points de sauvegarde (pour A : 24 h).
💡 Indice 2
Pour B, le RPO est l'intervalle des journaux (5 min), mais le RTO inclut le rejeu.
💡 Indice 3
Un plan peut respecter le RPO sans respecter le RTO.
✅ Réponse
besoin = {"rpo_min": 15, "rto_min": 60}
plans = {"A": {"rpo": 24 * 60, "rto": 180}, "B": {"rpo": 5, "rto": 90}, "C": {"rpo": 0, "rto": 5}}
for nom, p in plans.items():
ok_rpo, ok_rto = p["rpo"] <= besoin["rpo_min"], p["rto"] <= besoin["rto_min"]
print(f"plan {nom} : RPO {p['rpo']} min {'✅' if ok_rpo else '❌'} | RTO {p['rto']} min {'✅' if ok_rto else '❌'}")
assert [n for n, p in plans.items() if p["rpo"] <= 15 and p["rto"] <= 60] == []
🚀 À toi, en solo (20 XP)
Mini ingénierie du chaos. Construis un banc d'essai :
- un service
Recherchequi dépend d'unIndex(lent ou en panne par intermittence) et d'unCache; - un injecteur de pannes avec probabilité et durée configurables ;
- une version « fragile » (pas de timeout, pas de repli) et une version « résiliente » (timeout simulé, repli sur le cache, disjoncteur) ;
- un protocole en 5 étapes (état stable, hypothèse, injection, observation, conclusion) exécuté pour des pannes de 10 %, 30 % et 60 % de l'index ;
- un rapport comparant le taux de succès et la latence p95 des deux versions ;
- identifie le seuil de panne au-delà duquel même la version résiliente ne tient plus son SLO de 99 %.
✅ Pistes de correction
import random, math
def p95(v):
v = sorted(v); return v[math.ceil(0.95 * len(v)) - 1]
def scenario(version, taux_panne, n=3000, graine=2):
rng = random.Random(graine)
cache = {f"q{i}": f"résultat {i}" for i in range(50)} # le cache couvre les requêtes fréquentes
ouvert_jusqua, echecs_consecutifs, succes, latences = -1, 0, 0, []
for i in range(n):
q = f"q{rng.randrange(60)}" # 50/60 des requêtes sont en cache
if version == "fragile":
if rng.random() < taux_panne:
latences.append(30000) # attend 30 s puis échoue
continue
latences.append(rng.uniform(20, 60)); succes += 1
continue
i < ouvert_jusqua:
latences.append()
q cache: succes +=
rng.random() < taux_panne:
latences.append(); echecs_consecutifs +=
echecs_consecutifs >= : ouvert_jusqua = i +
q cache: succes +=
:
latences.append(rng.uniform(, )); succes += ; echecs_consecutifs =
succes / n, p95(latences)
taux (, , , ):
f, r = scenario(, taux), scenario(, taux)
()
scenario(, )[] < < scenario(, )[]
scenario(, )[] > scenario(, )[]
seuil = (t t (, , , , , , ) scenario(, t)[] < )
(, )
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Relancer immédiatement et sans limite | Tempête de tentatives, cascade | Recul exponentiel, gigue, budget de tentatives |
| Appels sans délai d'attente | Les ressources s'épuisent à attendre | Timeout partout, plus court que celui de l'appelant |
| Retenter une opération non idempotente | Double facturation, doublons | Clés d'idempotence, ou ne pas retenter |
| Sauvegardes jamais restaurées | On découvre qu'elles sont inutilisables le jour de la panne | Exercices de restauration planifiés |
🐉 Mini-boss (40 XP)
Exercice de résilience de HashBox. Prépare et mène un « jour de jeu » simulé :
- décris le système (api → service paiement + base + cache) et ses défenses (timeouts, tentatives, disjoncteur, repli) ;
- écris un banc de simulation avec injection de pannes (latence, indisponibilité, perte de paquets) sur chaque dépendance ;
- définis l'état stable (SLI) et 4 hypothèses ;
- exécute 6 expériences, et pour chacune compare l'hypothèse au résultat ;
- simule un déploiement fautif avec retour arrière automatique déclenché par les contrôles de santé, et mesure le temps de rétablissement ;
- calcule RPO/RTO pour un plan de sauvegarde et simule une restauration (en recréant une base SQLite depuis une sauvegarde) ;
- rédige le rapport : ce qui a tenu, ce qui a cédé, 5 actions correctives priorisées.
✅ Pistes de correction
Un bon travail : classes Horloge, Disjoncteur, avec_tentatives, un injecteur de pannes paramétrable, 6 expériences avec hypothèses explicites, un contrôleur de déploiement qui surveille la santé et revient en arrière, une restauration réelle via sqlite3.Connection.backup() vérifiée par comptage de lignes, et un rapport honnête incluant au moins une hypothèse réfutée (c'est là que l'on apprend le plus).
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Un disjoncteur (circuit breaker) sert à :
- A. accélérer les requêtes
- B. cesser d'appeler une dépendance en panne pour la laisser récupérer
- C. chiffrer les échanges
2. Le recul exponentiel avec gigue sert à :
- A. augmenter le nombre de requêtes
- B. cacher les erreurs
- C. éviter que tous les clients retentent au même instant
3. Le RPO représente :
- A. la perte de données maximale acceptable
- B. le temps de rétablissement
- C. le nombre de serveurs
4. 🔁 Révision mission 08 : Un budget d'erreurs de 99,9 % sur 30 jours correspond à environ :
- A. 4 heures
- B. 43 minutes d'indisponibilité
- C. 4 secondes
5. 🔁 Révision mission 08 : Pour mesurer la latence ressentie par les moins chanceux, on regarde :
- A. la moyenne uniquement
- B. le nombre de serveurs
- C. les percentiles élevés (p95, p99)
✅ Réponses
- B.
- C.
- A.
- B.
- C.
🪞 Je réfléchis (10 XP)
- Quelle est ta dépendance la plus fragile ? Que fait ton code si elle répond en 30 secondes ?
- À quand remonte la dernière restauration réelle d'une sauvegarde chez toi ?
🎒 À retenir
- Rollback, roll-forward ou drapeau : préparés avant l'incident.
- Cascade : relances, attentes sans limite, ressources saturées.
- Timeouts, recul exponentiel + gigue, disjoncteur, dégradation progressive.
- RPO (données perdues) et RTO (temps de reprise) ; restaurer pour de vrai.
- Chaos : hypothèse, injection contrôlée, observation, correction.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Funambule avec filet
← Mission 08 — Observabilité · Mission 10 — Pipeline complet →
HEF-120 — DevOps et livraison

