Claude-Code-Produktionsvorfälle: Erkennung, Rollback, RCA und Prävention

Claude Code beschleunigt Arbeit, weil es Dateien lesen, Code ändern und Shell-Befehle ausführen kann. In Produktions-Repositories bedeutet diese Geschwindigkeit auch ein anderes Risiko: Eine schnelle Freigabe kann ein Secret veröffentlichen, lokale Dateien löschen, main überschreiben, eine gefährliche Migration starten oder API-Kosten erhöhen.

Dieser Artikel beschreibt keinen privaten Ausfall eines bestimmten Unternehmens. Es sind zusammengesetzte Szenarien aus ClaudeCodeLab-Übungen, Repository-Reviews und Content-Operations. Zeiten und Beträge sind Beispiele, die Muster sind aber realistisch genug für ein Training.

Ein Incident ist ein Ereignis, das Nutzer, Daten, Sicherheit, Kosten oder Verfügbarkeit betrifft. Eindämmung bedeutet, weiteren Schaden zu stoppen. RCA ist Root-Cause-Analyse, also Ursachenanalyse. Rollback bedeutet Rückkehr zur letzten sicheren Version.

Die aktuelle Syntax steht in der offiziellen Dokumentation zu Claude Code settings und hooks. Hier bauen wir daraus einen Ablauf: erkennen, eindämmen, diagnostizieren, zurückrollen, kommunizieren, Postmortem schreiben und Wiederholung verhindern.

Ablauf für die Reaktion

Phase	Ziel	Auftrag an Claude Code
Erkennen	Änderung und Auswirkung finden	Alerts, Logs, Diff, Deploys und Befehle zusammenfassen
Eindämmen	Schaden stoppen	Schlüssel sperren, Jobs pausieren, Flags abschalten, Endpoints sperren
Diagnostizieren	Direkte Ursache eingrenzen	Letzte sichere Version mit dem Fehlerwechsel vergleichen
Rollback	Sicheren Zustand herstellen	Zielversion, Datenrisiko und Prüfkommandos nennen
Kommunizieren	Unsicherheit senken	Status, Impact, nächste Aktualisierung und Owner formulieren
Postmortem	Lernen festhalten	RCA, Timeline, Erkennungslücke und Maßnahmen ausfüllen
Vorbeugen	Wiederholung erschweren	Permissions, Hooks, CI, Alerts und Review-Gates ergänzen

Bei Secrets, Abrechnung, personenbezogenen Daten und Datenbank-Schreibzugriffen gilt: erst eindämmen, dann untersuchen.

Sieben konkrete Muster

Muster	Wirkung	Erste Reaktion	Häufiger Fehler
Secret-Leak	.env, Logs oder Screenshots zeigen einen Schlüssel	Sperren, rotieren, Logs prüfen	Git bereinigen, aber CI-Logs vergessen
Gefährliches Löschen	rm -rf entfernt nötige Dateien	Arbeit stoppen, Backups prüfen, untracked Dateien listen	git checkout . stellt nur verfolgte Dateien wieder her
Force Push	main überschreibt Team-Commits	Push stoppen, reflog prüfen, Recovery-Branch erstellen	--force-with-lease mit --force verwechseln
DB-Migration	Drop, Mass-Update oder Lock legt Produktion lahm	Writes pausieren, Zustand sichern, restore planen	Ungetestetes SQL direkt in Produktion
Endlose API-Retries	Fehlversuche erzeugen Kosten	Prozess beenden, Queue pausieren, Limits prüfen	”Retry” wird zur Endlosschleife
Defekte Dependency	Deployment startet mit 503	Vorheriges Deployment reaktivieren, lockfile prüfen	npm update hebt Major-Versionen an
Fehlende Auth	Admin-Endpunkt ist öffentlich	Endpoint sperren, Access-Logs prüfen	”Admin” wird nicht als Auth-Anforderung notiert

Drei Übungsfälle

Beim API-Key-Leak kann die Erkennung aus GitHub Secret Scanning, Cloud-Alerts oder Billing kommen. Zuerst wird der Schlüssel gesperrt. Danach prüft man Repository, Pull Requests, CI-Logs, Chat und Monitoring.

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

Bei einer Datenbankmigration werden Schreibzugriffe gestoppt, bevor man die Ursache erklärt. Code-Rollback ist oft schnell, aber gelöschte Daten brauchen Backup, Journal, Audit-Logs oder erneute Synchronisierung.

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

Für API-Retries braucht jeder Batch eine harte Grenze. Speichere die Datei als 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("nutzung: node incident-budget-runner.mjs <befehl> [...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(`gestoppt: geschätzte Kosten ${estimatedCost} Cent`);
    process.exit(1);
  }
  const delayMs = Math.min(1000 * 2 ** (attempt - 1), 10_000);
  await new Promise((resolve) => setTimeout(resolve, delayMs));
}

console.error(`fehlgeschlagen nach ${maxAttempts} Versuchen`);
process.exit(1);

Guardrails für 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 "Gefährlicher Befehl blockiert: $command" >&2
  exit 2
fi

exit 0

Kommunikation und Postmortem

## Incident-Update
- Status: Untersuchung / eingedämmt / Wiederherstellung wird geprüft
- Auswirkung: Funktion, Nutzer, Startzeit
- Aktuelle Aktion: Job gestoppt, Deployment zurückgerollt, Logs geprüft
- Nächstes Update: YYYY-MM-DD HH:mm
- Owner:

# Postmortem: [Titel]

## Zusammenfassung
- Start:
- Erkennung:
- Lösung:
- Auswirkung:
- Schweregrad: P0/P1/P2/P3

## Timeline
| Zeit | Ereignis |
| --- | --- |
| HH:mm | |

## Ursache
- Direkte Ursache:
- Root Cause:
- Warum wurde es spät erkannt:

## Prävention
| Maßnahme | Owner | Termin |
| --- | --- | --- |
| | | |

Als externe Referenz hilft Googles SRE-Kapitel Postmortem Culture.

Links und CTA

Weiterführend sind Security Best Practices, der Permissions Guide, der API-Kostenguide und der Verification-Receipt-Workflow.

Einzelpersonen starten mit dem kostenlosen Cheatsheet. Wiederverwendbare Vorlagen stehen unter ClaudeCodeLab-Produkte. Teams können über Claude-Code-Training und Beratung CLAUDE.md, Permissions, Hooks, Review-Gates und Incident-Übungen ordnen.

In ClaudeCodeLab-Übungen war der größte Gewinn, Eindämmung vor Diagnose zu schreiben. Die Syntaxprüfung von JSON, Bash und Node vor Veröffentlichung hat einfache Fehler entfernt. Eine 20-Minuten-Probe zeigt schnell fehlende Alerts, ungetestete Backups und zu breite Claude-Code-Rechte.