Incidents de production avec Claude Code: détection, rollback, RCA et prévention

Claude Code accélère le travail car il peut lire les fichiers, modifier le code et lancer des commandes. Dans un dépôt de production, cette vitesse crée aussi un nouveau risque: une approbation trop rapide peut exposer un secret, supprimer des fichiers, écraser main, exécuter une migration dangereuse ou multiplier les appels API.

Cet article ne décrit pas l’incident privé d’une entreprise réelle. Il synthétise des exercices ClaudeCodeLab, des revues de dépôts et des tâches de publication. Les heures et montants sont fictifs, mais les scénarios sont assez concrets pour servir de répétition.

Un incident touche les utilisateurs, les données, la sécurité, le coût ou la disponibilité. Contenir signifie empêcher l’aggravation. RCA signifie analyse de cause racine. Un rollback revient à la dernière version sûre.

Vérifiez toujours la syntaxe dans la documentation officielle Claude Code settings et hooks. Ici, nous organisons la réponse: détecter, contenir, diagnostiquer, revenir en arrière, communiquer, postmortem, prévenir.

Le flux de réponse

Étape	Objectif	Demande utile à Claude Code
Détecter	Savoir ce qui a changé	Résumer alertes, logs, diff, déploiements et commandes
Contenir	Stopper les dégâts	Proposer révocation de clé, pause de job, flag OFF ou endpoint coupé
Diagnostiquer	Isoler la cause directe	Comparer la dernière version saine et le changement suspect
Rollback	Revenir à un état sûr	Lister cible, risque de données et commandes de vérification
Communiquer	Réduire l’incertitude	Rédiger état, impact, prochaine mise à jour et responsable
Postmortem	Transformer l’incident en apprentissage	Remplir RCA, chronologie, détection manquée et actions
Prévenir	Éviter la répétition	Ajouter permissions, hooks, CI, alertes et revue

Pour les secrets, la facturation, les données personnelles et les écritures en base, on contient d’abord et on enquête ensuite.

Sept scénarios concrets

Scénario	Effet	Premier geste	Piège fréquent
Secret exposé	.env, logs ou captures révèlent une clé	Révoquer, tourner, inspecter les logs	Nettoyer git mais oublier les logs CI
Suppression dangereuse	rm -rf enlève des fichiers utiles	Arrêter, vérifier sauvegardes, lister non suivis	git checkout . ne restaure pas le non suivi
Force push	main écrase le travail d’autres personnes	Stopper les push, inspecter reflog, créer une branche de récupération	Confondre --force-with-lease et --force
Migration BD	Drop, update massif ou lock casse la production	Pauser les écritures, sauvegarder, restaurer	SQL non testé lancé en production
API en boucle	Les retries font monter le coût	Tuer le processus, pauser la queue, vérifier les limites	”Retry” devient boucle infinie
Dépendance cassée	Déploiement en 503 au démarrage	Réactiver l’ancien déploiement, lire le lockfile	npm update monte une version majeure
Auth manquante	Endpoint admin public	Couper endpoint, lire logs d’accès, notifier si besoin	”Admin” n’est pas une exigence d’authentification

Trois cas à répéter

Pour une fuite de clé API, la détection peut venir du secret scanning GitHub, d’une alerte cloud ou d’une facture. La première action est la révocation. Ensuite seulement, on cherche où la clé a circulé.

git status --short
git diff --cached --name-only
git log --all -- .env .env.local
git grep -n "sk-" -- ':!node_modules' ':!dist'

Pour une migration BD, il faut stopper les écritures avant d’expliquer. Le code peut revenir vite, mais les données supprimées dépendent des sauvegardes, du journal et des audits.

psql "$DATABASE_URL" -c "select now();"
psql "$DATABASE_URL" -c "\d users"
pg_dump "$DATABASE_URL" --schema-only > schema_before_repair.sql

Pour les retries API, placez une limite explicite autour du batch. Enregistrez ce fichier sous incident-budget-runner.mjs.

#!/usr/bin/env node
import { spawn } from "node:child_process";

const command = process.argv.slice(2);
const maxAttempts = Number(process.env.MAX_ATTEMPTS || 3);
const maxCostCents = Number(process.env.MAX_COST_CENTS || 200);
const costPerAttempt = Number(process.env.COST_PER_ATTEMPT_CENTS || 0);

if (command.length === 0) {
  console.error("usage: node incident-budget-runner.mjs <commande> [...args]");
  process.exit(2);
}

let estimatedCost = 0;

for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
  const child = spawn(command[0], command.slice(1), {
    stdio: "inherit",
    shell: process.platform === "win32"
  });
  const exitCode = await new Promise((resolve) => {
    child.on("exit", (code) => resolve(code ?? 1));
  });
  estimatedCost += costPerAttempt;
  if (exitCode === 0) process.exit(0);
  if (estimatedCost >= maxCostCents) {
    console.error(`arrêt: coût estimé ${estimatedCost} centimes`);
    process.exit(1);
  }
  const delayMs = Math.min(1000 * 2 ** (attempt - 1), 10_000);
  await new Promise((resolve) => setTimeout(resolve, delayMs));
}

console.error(`échec après ${maxAttempts} tentatives`);
process.exit(1);

Garde-fous Claude Code

{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "permissions": {
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)",
      "Bash(git push --force *main*)",
      "Bash(git push -f *main*)",
      "Bash(rm -rf /*)",
      "Bash(rm -rf ~*)"
    ],
    "ask": [
      "Bash(git push*)",
      "Bash(rm*)",
      "Bash(npm install*)",
      "Bash(*migrate*)",
      "Bash(*deploy*)"
    ]
  },
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/protect-danger.sh"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
set -euo pipefail

payload="$(cat)"
command="$(node -e 'const fs = require("fs"); const raw = fs.readFileSync(0, "utf8") || "{}"; const json = JSON.parse(raw); console.log(json.tool_input?.command || "");' <<< "$payload")"
blocked='(rm[[:space:]]+-rf[[:space:]]+(/|~)|git[[:space:]]+push[[:space:]].*(-f|--force)([[:space:]]|$)|DROP[[:space:]]+TABLE|TRUNCATE[[:space:]])'

if [[ "$command" =~ $blocked ]]; then
  echo "Commande dangereuse bloquée: $command" >&2
  exit 2
fi

exit 0

Communication et postmortem

## Point incident
- État: enquête / contenu / récupération en validation
- Impact: fonctionnalité, utilisateurs, heure de début
- Action actuelle: job arrêté, déploiement annulé, logs vérifiés
- Prochaine mise à jour: YYYY-MM-DD HH:mm
- Responsable:

# Postmortem: [titre]

## Résumé
- Début:
- Détection:
- Résolution:
- Impact:
- Sévérité: P0/P1/P2/P3

## Chronologie
| Heure | Événement |
| --- | --- |
| HH:mm | |

## Cause
- Cause directe:
- Cause racine:
- Pourquoi la détection a tardé:

## Prévention
| Action | Responsable | Date limite |
| --- | --- | --- |
| | | |

La page Google SRE Postmortem Culture aide à garder ce document utile et non accusatoire.

Liens et CTA

Pour continuer, lisez bonnes pratiques sécurité, guide des permissions, guide des coûts API et workflow de vérification.

En solo, commencez par la cheatsheet gratuite. Pour des modèles réutilisables, consultez les produits ClaudeCodeLab. Pour une équipe, la page formation et conseil Claude Code permet de cadrer CLAUDE.md, permissions, hooks, revue et exercices.

Lors des essais ClaudeCodeLab, l’amélioration la plus nette a été d’écrire la contention avant le diagnostic. La vérification de la syntaxe JSON, Bash et Node avant publication a aussi supprimé plusieurs erreurs simples. Une répétition de 20 minutes montre vite les alertes absentes, les sauvegardes non testées et les permissions trop larges.