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à.

Intégrer la reprise après incident dans une stack existante

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.

PhaseCe que tu mesuresOrdre de grandeur typique
DétectionDélai entre la panne et la première alerte2 à 15 min
DiagnosticTemps pour identifier le composant fautif10 à 45 min
DécisionTemps pour choisir rollback, failover ou hotfix5 à 30 min
ExécutionDurée réelle de la remise en état10 min à 3 h
VérificationContrôle que le service sert vraiment le trafic5 à 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.

ServiceRTORPOStratégieCoût mensuel
API de paiement15 min0Réplica synchrone + bascule automatique~180 €
API métier1 h5 minRéplica asynchrone, bascule manuelle~60 €
Back-office4 h1 hRestauration de dump~10 €
Blog et docs24 h24 hRecréation depuis le dépôt Git0 €

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: 3

Le 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 -d

Deux 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 itemBon 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ègeSymptômeCorrectif
RTO unique pour toute la plateformeTout est « critique », rien n'est prioriséGrille service par service avec coût
Tag latest en productionImpossible d'identifier la version qui tourneTag par SHA, digest épinglé
Runbook non testéCommandes obsolètes découvertes en pleine criseExercice trimestriel par un non-initié
Rollback DB oubliéL'ancienne version ne redémarre pas après migrationMigrations réversibles + test de downgrade
Astreinte sans accèsL'ingénieur d'astreinte ne peut pas redémarrer le serviceAccè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.