Intégrer la reprise après incident dans une stack existante
Un backup ne réduit pas ton MTTR. La méthode en six étapes pour greffer reprise après incident, rollback et runbooks testés sur une stack qui tourne déjà.
Ton dernier incident a duré 4 h 12. Pas parce que la panne était compliquée, mais parce que personne ne savait quel commit tournait en production ni comment revenir au précédent. La reprise après incident ne s'ajoute pas à une stack : elle se greffe sur ce qui existe déjà, et c'est exactement là que la plupart des équipes se plantent.
Voici la démarche que j'applique pour brancher une capacité de reprise sur une plateforme qui tourne depuis deux ans, sans réécrire l'infra ni acheter une plateforme d'observabilité à 40 k€ par an.
Un backup n'est pas une reprise après incident
Un dump quotidien te protège de la perte de données. Il ne te dit rien du temps qu'il te faudra pour redevenir opérationnel. Ce sont deux problèmes distincts, et confondre les deux coûte des heures de production.
Cas réel : une équipe avec réplication PostgreSQL en place, trois backups par jour, et un objectif affiché de « 30 minutes de RTO ». Le jour où le primaire est tombé, la promotion du réplica a pris 11 minutes — mais l'application est restée KO 58 minutes de plus. Le DNS applicatif pointait encore sur l'ancien primaire avec un TTL de 3 600 s. Personne n'avait jamais chronométré cette étape.
Trois choses ne sont pas de la reprise après incident, même si elles en ont l'air :
- Le backup — il restaure des octets, pas un service.
- Le runbook écrit après l'incident et jamais relu depuis. Il documente un monde qui n'existe plus.
- L'outil (astreinte, chaos engineering, status page). Il diffuse l'information, il ne crée pas la procédure.
La culture postmortem de Google SRE pose la même base : la valeur vient de la boucle d'apprentissage, pas du document. Voir Postmortem Culture: Learning from Failure.
Étape 1 — Chronométrer ta reprise actuelle
Avant de toucher à quoi que ce soit, mesure ce que tu sais déjà faire. Prends un service critique, simule une perte complète en préprod, et découpe le temps par phase.
| Phase | Ce que tu mesures | Ordre de grandeur typique |
|---|---|---|
| Détection | Délai entre la panne et la première alerte | 2 à 15 min |
| Diagnostic | Temps pour identifier le composant fautif | 10 à 45 min |
| Décision | Temps pour choisir rollback, failover ou hotfix | 5 à 30 min |
| Exécution | Durée réelle de la remise en état | 10 min à 3 h |
| Vérification | Contrôle que le service sert vraiment le trafic | 5 à 20 min |
Le script qui suit te donne un chiffre brut, reproductible, sur une stack Docker Compose. Lance-le en préprod un mardi matin, pas un vendredi soir.
#!/usr/bin/env bash
set -euo pipefail
START=$(date +%s)
docker compose -f docker-compose.preprod.yml down --volumes
/usr/local/bin/restore-pg.sh /backups/preprod-latest.dump
docker compose -f docker-compose.preprod.yml up -d
until curl -sf http://localhost:8080/healthz > /dev/null; do sleep 2; done
END=$(date +%s)
echo "MTTR simulé : $((END - START)) secondes"Sur une stack de taille moyenne, ce premier passage donne souvent 40 à 90 minutes, dont la moitié en manipulations manuelles oubliées. Ce chiffre est ta ligne de base. Sans lui, aucune amélioration n'est démontrable.
Étape 2 — Fixer un RTO et un RPO par service
Un objectif unique pour toute la plateforme est une abstraction qui ne décide rien. Ce qui déclenche une action, c'est le couple RTO/RPO service par service, avec le coût associé en face.
| Service | RTO | RPO | Stratégie | Coût mensuel |
|---|---|---|---|---|
| API de paiement | 15 min | 0 | Réplica synchrone + bascule automatique | ~180 € |
| API métier | 1 h | 5 min | Réplica asynchrone, bascule manuelle | ~60 € |
| Back-office | 4 h | 1 h | Restauration de dump | ~10 € |
| Blog et docs | 24 h | 24 h | Recréation depuis le dépôt Git | 0 € |
Cette grille a un effet secondaire utile : elle t'oblige à dire non. Un service à RTO de 15 minutes pour un usage interne à trois personnes, c'est 150 € par mois jetés dans une réplication dont personne ne veut.
Étape 3 — Rendre le retour arrière possible
Le rollback est la première capacité de reprise à installer, parce qu'il couvre 70 % des incidents réels : un déploiement fautif, une migration ratée, une variable d'environnement oubliée. Il repose sur une seule discipline — des artefacts immuables et identifiables.
Concrètement : une image taguée par SHA de commit, jamais latest, et un fichier de déploiement qui accepte ce SHA en paramètre.
# docker-compose.prod.yml
services:
api:
image: registry.liink.ovh/api:${GIT_SHA:?sha requis}
restart: unless-stopped
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:8080/healthz"]
interval: 10s
retries: 3Le déploiement devient alors deux commandes symétriques, et le retour arrière n'est plus une négociation en pleine crise.
GIT_SHA=4f2c1ab docker compose -f docker-compose.prod.yml pull
GIT_SHA=4f2c1ab docker compose -f docker-compose.prod.yml up -d
# retour arrière : même commande avec le SHA précédent
GIT_SHA=9d71e03 docker compose -f docker-compose.prod.yml up -dDeux limites que j'ai vues échouer en vrai. D'abord, un rollback d'image ne défait pas une migration de base : si ta nouvelle version a supprimé une colonne, l'ancienne ne redémarre pas. Ensuite, en Kubernetes, kubectl rollout undo restaure la révision précédente du Deployment, pas les ressources annexes modifiées à la main. J'ai détaillé ces cas dans Performance et scalabilité : les rollbacks.
Côté infrastructure déclarative, la même logique s'applique : tant que ta stack est décrite dans du code versionné, la reconstruire après sinistre devient une exécution de pipeline. C'est le sujet de Intégrer Terraform dans une stack existante.
Étape 4 — Écrire des runbooks qui s'exécutent
Un runbook utile contient des commandes copiables et des critères de sortie vérifiables. Pas de « vérifier que le service répond correctement » : une URL, un code HTTP attendu, une requête SQL de contrôle.
## Runbook — perte du primaire PostgreSQL
Symptôme : erreurs `could not connect to server`, alerte `pg_primary_down`
1. Confirmer la panne
pg_isready -h db-primary.liink.ovh -p 5432
# attendu : "no response" -> passer à 2
2. Promouvoir le réplica
ssh db-replica-1 'pg_ctl promote -D /var/lib/postgresql/16/main'
# attendu : "server promoted"
3. Basculer le DNS applicatif (TTL 60 s)
./scripts/dns-failover.sh db-primary.liink.ovh db-replica-1
4. Vérifier depuis l'application
curl -sf https://api.exemple.fr/healthz
# attendu : 200 avec {"db":"primary-ok"}
Critère de sortie : étape 4 renvoie 200 deux fois à 30 s d'intervalle.
Escalade : si étape 2 échoue, appeler l'astreinte infra (rotation PagerDuty).Le test de validité est simple : quelqu'un qui n'a jamais touché ce service doit pouvoir exécuter le runbook sans appeler personne. S'il demande où trouver dns-failover.sh, le runbook est incomplet.
Étape 5 — Répéter l'incident quand tout va bien
Un runbook jamais exécuté est une hypothèse. Le premier exercice, chez moi, a révélé que le script de failover référencé pointait vers une zone DNS supprimée six mois plus tôt. Le runbook était parfait, l'infra avait bougé.
Format minimal qui tient en une demi-journée : annoncer l'exercice, couper le primaire en pleine journée de travail, chronométrer, laisser l'équipe utiliser uniquement le runbook, noter chaque écart. Un créneau de deux heures par trimestre suffit à maintenir le dispositif vivant.
Pour les scénarios réseau et les tests continus, Chaos Mesh et LitmusChaos automatisent la coupure. Commence par la version manuelle : l'outil sert à répéter un scénario que tu maîtrises déjà. Le guide de référence sur les postmortems PagerDuty donne un cadre correct pour la partie organisationnelle (postmortems.pagerduty.com).
Étape 6 — Transformer l'incident en correctifs
Un postmortem sans action item daté est un récit. La règle que j'impose : chaque action a un propriétaire nommé, une date, et un ticket dans le même backlog que les fonctionnalités. Sinon elle glisse indéfiniment derrière la roadmap.
| Mauvais action item | Bon action item |
|---|---|
| « Améliorer le monitoring » | « Ajouter l'alerte sur pg_replication_lag > 30s — Karim — 22/11 » |
| « Documenter le failover » | « Runbook failover PG exécuté en préprod par une personne hors équipe — Léa — 29/11 » |
| « Revoir les TTL DNS » | « Passer les TTL des enregistrements applicatifs à 60 s — Karim — 18/11 » |
La métrique de suivi n'est pas le nombre de postmortems écrits, c'est le pourcentage d'action items clos sous 30 jours. En dessous de 70 %, ton dispositif produit de la documentation, pas de la fiabilité.
Les cinq pièges qui annulent tout
| Piège | Symptôme | Correctif |
|---|---|---|
| RTO unique pour toute la plateforme | Tout est « critique », rien n'est priorisé | Grille service par service avec coût |
Tag latest en production | Impossible d'identifier la version qui tourne | Tag par SHA, digest épinglé |
| Runbook non testé | Commandes obsolètes découvertes en pleine crise | Exercice trimestriel par un non-initié |
| Rollback DB oublié | L'ancienne version ne redémarre pas après migration | Migrations réversibles + test de downgrade |
| Astreinte sans accès | L'ingénieur d'astreinte ne peut pas redémarrer le service | Accès vérifié à chaque rotation |
FAQ
Combien de temps pour brancher tout ça sur une stack existante ?
Compte deux à trois semaines à temps partiel pour une plateforme de 5 à 10 services : une semaine pour la mesure et les RTO, une pour les runbooks, une pour le premier exercice. Le rollback par SHA se fait en une journée et apporte l'essentiel du gain.
Faut-il un outil de gestion d'incident dès le début ?
Non. Un canal dédié, un document partagé avec la timeline et une astreinte téléphonique suffisent jusqu'à une dizaine d'ingénieurs. L'outil devient utile quand la coordination entre équipes coûte plus cher que sa mise en place.
Comment convaincre une direction de payer de la redondance ?
Traduis en euros : heures d'indisponibilité constatées sur 12 mois × coût horaire du service. Sur une API facturée, un incident de 4 heures peut dépasser le coût annuel d'un réplica synchrone. La grille RTO/RPO avec la colonne coût fait le travail.
Et si je n'ai pas d'environnement de préprod ?
Mesure la restauration sur un dump récent dans un conteneur jetable, sur ta machine. Le temps sera faux à la baisse, mais tu découvriras les dépendances manquantes — c'est le principal bénéfice. Un exercice imparfait vaut mieux qu'aucune mesure.