Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 14: Wettkampf – Desaster-Drills

Ziel: Neun Störungen unter Zeitdruck erkennen und beheben. · Dauer: ca. 150 min · Voraussetzung: Tag 13

Heute machst du deinen HA-Cluster absichtlich kaputt und reparierst ihn unter Zeitdruck. Starte die Stoppuhr beim Auslösen der Störung und stoppe sie, wenn der letzte Befehl der Behebung das erwartete Ergebnis zeigt.

mkdir -p ~/bao-lab/tag14 && cd ~/bao-lab/tag14
kubectl config use-context kind-bao-lab
kubectl -n openbao port-forward svc/openbao-active 8200:8200 >/dev/null 2>&1 &
export BAO_ADDR=https://127.0.0.1:8200 BAO_CACERT=~/bao-lab/tls/ca.crt
export BAO_TOKEN=$(bao login -no-store -token-only -method=userpass \
  username=admin password=lab-admin-pw)   # Admin aus Tag 13 (Root ist widerrufen)
bao policy write wettkampf - <<'EOF'
# Nur Tag 14: Secret reparieren (Szenario 4, 5, 8, 9), Leak im Audit-Log suchen (6)
path "secret/data/webshop/config" { capabilities = ["create","read","update","delete"] }
path "secret/metadata/webshop/config" { capabilities = ["read"] }
path "secret/undelete/webshop/config" { capabilities = ["update"] }
path "sys/audit-hash/datei" { capabilities = ["update"] }
EOF
bao write auth/userpass/users/wettkampf password=lab-wk-pw \
  token_policies=bao-admin,wettkampf token_ttl=4h          # Lab-Passwort
export BAO_TOKEN=$(bao login -no-store -token-only -method=userpass \
  username=wettkampf password=lab-wk-pw)
bao operator raft snapshot save ~/bao-lab/tag14/vorher.snap     # Sicherheitsnetz

Erwartet:

Success! Uploaded policy: wettkampf
Success! Data written to: auth/userpass/users/wettkampf

Warum? bao-admin liest keine Secrets (Tag 13). Der Übungs-User wettkampf bekommt zusätzlich genau die vier Pfade, die Szenario 4, 5, 6, 8 und 9 brauchen. Das nutzt aus, dass bao-admin Policies und Userpass-User schreiben darf (Tag 13, Drill 1) – darum schmal, im Audit-Log sichtbar und nach dem Wettkampf wieder gelöscht.

Tipp: Bricht der Port-Forward ab (Active-Pod weg), starte ihn einfach neu.

Szenario 1: Pod und Node fallen aus

Störung auslösen:

A=$(kubectl -n openbao get pods -l openbao-active=true \
  -o jsonpath='{.items[0].metadata.name}'); echo "Active: $A"
kubectl -n openbao delete pod "$A"
# Runde 2: ganzer Worker
N=$(kubectl -n openbao get pod openbao-1 -o jsonpath='{.spec.nodeName}'); echo "Node: $N"
docker stop "$N"

Symptome:

error: lost connection to pod                    # Port-Forward bricht ab
openbao-1   1/1   Running -> Terminating/Unknown  # nach ca. 5 min

Ein neuer Leader (= Active) steht nach wenigen Sekunden. Der Pod vom gestoppten Node wird nicht woanders gestartet: Das lokale PV (kind standard) hängt am Node.

Diagnose:

kubectl get nodes
kubectl -n openbao get pods -o wide -L openbao-active
bao operator raft list-peers
bao operator raft autopilot state | grep -E 'Healthy|Failure Tolerance'
Healthy:                         false
Failure Tolerance:               0

Behebung:

docker start "$N"
kubectl -n openbao wait pod/openbao-1 --for=condition=Ready --timeout=180s
bao operator raft autopilot state | grep 'Failure Tolerance'   # wieder 1

Der Pod entsiegelt sich per Transit selbst und holt die Raft-Logs nach.

Zeitziel: 5 min

Szenario 2: Quorum-Verlust (2 von 3 weg)

Störung auslösen:

kubectl -n openbao scale statefulset openbao --replicas=1

Symptome: openbao-0 ist unsealed, aber niemand ist aktiv. Schreib- und in der Regel auch Lesezugriffe scheitern.

HA Cluster               n/a
HA Mode                  standby
* local node not active but active cluster node not found

Diagnose:

kubectl -n openbao exec openbao-0 -- bao status | grep -E 'Sealed|HA (Mode|Cluster)'
kubectl -n openbao logs openbao-0 --tail=20 | grep -E 'election|votesNeeded'
kubectl -n openbao get endpoints openbao-active   # keine Endpoints
storage.raft: pre-vote campaign failed, waiting for election timeout: term=6
  tally=1 refused=2 votesNeeded=2

Raft braucht 2 von 3 Stimmen. Die Peer-Liste enthält weiterhin drei Voter.

Behebung A (Daten der anderen Pods noch da):

kubectl -n openbao scale statefulset openbao --replicas=3

Behebung B (Pods/PVCs endgültig verloren) – peers.json-Recovery in Grundzügen:

kubectl -n openbao exec -i openbao-0 -- \
  sh -c 'cat > /openbao/data/raft/peers.json' <<'EOF'
[
  { "id": "openbao-0",
    "address": "openbao-0.openbao-internal:8201",
    "non_voter": false }
]
EOF
kubectl -n openbao delete pod openbao-0           # Neustart liest peers.json
kubectl -n openbao logs openbao-0 | grep -i 'raft recovery'
storage.raft: raft recovery initiated: recovery_file=peers.json
storage.raft: raft recovery deleted peers.json

Danach ist openbao-0 alleiniger Leader. Lösche die PVCs data-openbao-1 und data-openbao-2, skaliere auf 3 – die neuen Pods treten per retry_join bei (Tag 8).

Achtung: peers.json nur auf dem Node mit dem neuesten Datenstand und nur bei gestopptem Cluster. Falsch angewendet verlierst du Daten.

Zeitziel: A: 3 min · B: 15 min

Szenario 3: Unsealer nicht erreichbar

Störung auslösen:

kubectl -n unsealer get statefulset,deployment          # Ressource prüfen
kubectl -n unsealer scale statefulset bao-unsealer --replicas=0
kubectl -n openbao delete pod openbao-2                 # Neustart erzwingen

Symptome: Laufende Pods bleiben unsealed (Schlüssel im RAM). Jeder neu gestartete Pod bleibt sealed und wird nicht Ready.

Seal Type          transit
Sealed             true

Diagnose:

kubectl -n openbao get pods
kubectl -n openbao logs openbao-2 --tail=30 | grep -iE 'seal|transit'
kubectl -n unsealer get pods,endpoints
kubectl -n openbao get cm openbao-config -o yaml | grep -A6 'seal "transit"'

Prüfe auch den Unseal-Token (Tag 10): abgelaufen = gleiche Symptome.

Behebung:

kubectl -n unsealer scale statefulset bao-unsealer --replicas=1
kubectl -n unsealer wait pod/bao-unsealer-0 --for=condition=Ready --timeout=120s
kubectl -n openbao delete pod openbao-2       # falls nach 1 min noch sealed
kubectl -n openbao exec openbao-2 -- bao status | grep Sealed

Achtung: Starten alle drei Pods neu, während der Unsealer weg ist, steht der ganze Cluster.

Zeitziel: 5 min

Szenario 4: Versehentlich gelöschtes Secret

Störung auslösen:

bao kv put -mount=secret webshop/config db_user=webshop db_pass=FALSCH   # Lab-Wert
bao kv delete -mount=secret webshop/config

Symptome: bao kv get zeigt nur Metadaten mit deletion_time, keine Daten. ESO meldet beim nächsten Refresh einen Fehler.

kubectl -n webshop get externalsecret
NAME             STORE     REFRESH INTERVAL   STATUS              READY
webshop-config   openbao   15s                SecretSyncedError   False

(gekürzt, kann je nach Version abweichen)

Diagnose:

bao kv metadata get -mount=secret webshop/config
bao kv metadata get -format=json -mount=secret webshop/config \
  | jq '.data.current_version'

Behebung:

V=$(bao kv metadata get -format=json -mount=secret webshop/config \
  | jq '.data.current_version')
bao kv undelete -versions=$V -mount=secret webshop/config
bao kv rollback -version=$((V-1)) -mount=secret webshop/config   # falschen Wert ersetzen
bao kv get -mount=secret -field=db_pass webshop/config
kubectl -n webshop annotate externalsecret --all force-sync=$(date +%s) --overwrite
Success! Data written to: secret/undelete/webshop/config
...
lab-vorher

(gekürzt; der Wert hängt vom Stand aus Tag 12 ab)

rollback schreibt die alte Version als neue Version. Nach kv destroy oder kv metadata delete hilft nur noch ein Snapshot.

Zeitziel: 3 min

Szenario 5: Snapshot-Restore in leeren Cluster

Störung auslösen:

bao operator raft snapshot save ~/bao-lab/tag14/restore.snap
helm -n openbao uninstall openbao
for i in 0 1 2; do kubectl -n openbao delete pvc data-openbao-$i audit-openbao-$i \
  --ignore-not-found; done

Symptome: Keine Pods, keine Daten. Nach Neuinstallation ist der Cluster uninitialisiert.

Diagnose:

tar -tzf ~/bao-lab/tag14/restore.snap      # meta.json state.bin SHA256SUMS ...
kubectl -n unsealer get pods               # Unsealer + Key autounseal müssen leben

Behebung:

helm -n openbao install openbao openbao/openbao --version 0.30.2 \
  -f ~/bao-lab/k8s/values.yaml
kubectl -n openbao wait pod/openbao-0 --for=jsonpath='{.status.phase}'=Running \
  --timeout=120s
kubectl -n openbao exec openbao-0 -- bao operator init \
  -recovery-shares=5 -recovery-threshold=3 -format=json > ~/bao-lab/tag14/temp-init.json
kubectl -n openbao wait pod/openbao-0 --for=condition=Ready --timeout=120s
pkill -f 'port-forward svc/openbao-active'
kubectl -n openbao port-forward svc/openbao-active 8200:8200 >/dev/null 2>&1 &
BAO_TOKEN=$(jq -r .root_token ~/bao-lab/tag14/temp-init.json) \
  bao operator raft snapshot restore -force ~/bao-lab/tag14/restore.snap

Ohne -force kommt:

* could not verify hash file, possibly the snapshot is using a different autoseal
  key; use the snapshot-force API to bypass this check

Danach gelten wieder die Logins aus Tag 13 und der Vorbereitung und die Recovery-Keys aus ~/bao-lab/k8s/recovery-neu.json (.keys_base64). Pods, die sealed sind, nacheinander löschen.

export BAO_TOKEN=$(bao login -no-store -token-only -method=userpass \
  username=wettkampf password=lab-wk-pw)
bao kv get -mount=secret -field=db_user webshop/config
bao operator raft list-peers

Zeitziel: 15 min

Szenario 6: Geleaktes Token und SecretID

Störung auslösen:

bao auth list | grep -q approle/ || bao auth enable approle
bao write auth/approle/role/leak-drill token_policies=webshop-read token_ttl=1h
RID=$(bao read -field=role_id auth/approle/role/leak-drill/role-id)
bao write -f -format=json auth/approle/role/leak-drill/secret-id > leak-sid.json
LEAK=$(bao write -field=token auth/approle/login role_id=$RID \
  secret_id=$(jq -r .data.secret_id leak-sid.json))
echo "$LEAK" > geleakt.txt   # "im Slack gepostet"

Eigene Rolle leak-drill, weil OpenTofu die Rolle webshop seit Tag 13 verwaltet – jede Änderung daran wäre Drift.

Symptome: Fremde lesen mit dem Token secret/webshop/*. Im Audit-Log tauchen unbekannte remote_address-Werte auf.

Diagnose:

ACC=$(bao token lookup -format=json "$(cat geleakt.txt)" | jq -r .data.accessor)
bao token lookup -accessor $ACC | grep -E 'display_name|path|policies'
bao list auth/approle/role/leak-drill/secret-id      # SecretID-Accessors
H=$(bao write -field=hash sys/audit-hash/datei input="$(cat geleakt.txt)")  # Tag 12
L=$(kubectl -n openbao get pod -l openbao-active=true -o name)
kubectl -n openbao exec "$L" -- grep "$H" /openbao/audit/audit.log \
  | jq -r '.request.remote_address' | sort -u
display_name        approle
path                auth/approle/login
policies            [default webshop-read]

Behebung:

bao token revoke -accessor $ACC
bao write auth/approle/role/leak-drill/secret-id-accessor/destroy \
  secret_id_accessor=$(jq -r .data.secret_id_accessor leak-sid.json)
bao lease revoke -prefix auth/approle/        # alle AppRole-Tokens, großer Hammer
BAO_TOKEN=$(cat geleakt.txt) bao kv get -mount=secret webshop/config   # muss 403 sein
Success! Revoked token (if it existed)
All revocation operations queued successfully!
* permission denied

Danach betroffene Secrets rotieren (DB-Passwort, KV-Werte) und aufräumen: bao delete auth/approle/role/leak-drill, rm leak-sid.json geleakt.txt.

Zeitziel: 5 min

Szenario 7: Abgelaufenes TLS-Zertifikat erneuern (Rolling)

Störung auslösen:

cd ~/bao-lab/tls                # openbao.ext aus Tag 7, Drill 4: dieselben SANs
cp tls.crt tls.crt.orig && cp tls.key tls.key.orig     # Sicherheitsnetz
openssl req -newkey rsa:2048 -nodes -keyout drill.key -out drill.csr -subj /CN=openbao
openssl x509 -req -in drill.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
  -not_before 20260101000000Z -not_after 20260102000000Z \
  -sha256 -extfile openbao.ext -out drill.crt
kubectl -n openbao create secret generic openbao-tls --from-file=tls.crt=drill.crt \
  --from-file=tls.key=drill.key --from-file=ca.crt=ca.crt \
  --dry-run=client -o yaml | kubectl apply -f -
sleep 90   # kubelet aktualisiert das gemountete Secret
for i in 0 1 2; do
  kubectl -n openbao exec openbao-$i -- sh -c 'kill -HUP $(pidof bao)'
done

Symptome: Clients scheitern, die Pods bleiben trotzdem Ready (Readiness-Probe nutzt bao status -tls-skip-verify). Raft läuft weiter, ESO und Kubernetes-Clients fallen aus.

tls: failed to verify certificate: x509: certificate has expired or is not yet valid

Diagnose:

openssl s_client -connect 127.0.0.1:8200 -CAfile ca.crt </dev/null 2>/dev/null \
  | grep 'Verify return code'
openssl s_client -connect 127.0.0.1:8200 </dev/null 2>/dev/null \
  | openssl x509 -noout -enddate
kubectl -n openbao exec openbao-1 -- bao status 2>&1 | head -2
Verify return code: 10 (certificate has expired)
notAfter=Jan  2 00:00:00 2026 GMT

Behebung:

openssl x509 -req -in drill.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
  -days 180 -sha256 -extfile openbao.ext -out tls.crt && cp drill.key tls.key
kubectl -n openbao create secret generic openbao-tls --from-file=tls.crt \
  --from-file=tls.key --from-file=ca.crt --dry-run=client -o yaml | kubectl apply -f -
sleep 90
for p in $(kubectl -n openbao get pods -l openbao-active!=true -o name) \
         $(kubectl -n openbao get pods -l openbao-active=true -o name); do
  kubectl -n openbao exec "${p#pod/}" -- sh -c 'kill -HUP $(pidof bao)'
  kubectl -n openbao exec "${p#pod/}" -- bao status >/dev/null \
    && echo "✔ $p" || echo "✘ $p"
done

Erst Standbys, dann Active. SIGHUP lädt das Listener-Zertifikat ohne Neustart (OpenBao reload triggered im Log).

Tipp: Seit v2.7 lädt tls_auto_reload = true im listener-Block geänderte Dateien selbst nach. Bei subPath-Mounts kommt kein Update an: Pods einzeln löschen, den Active zuletzt nach bao operator step-down.

Zeitziel: 15 min

Szenario 8: Audit-Device blockiert (Disk voll)

Störung auslösen:

Simuliert einen Schreibfehler – eine echte volle Disk würde in kind deinen Laptop füllen, weil local-path keine Quota kennt.

A=$(kubectl -n openbao get pods -l openbao-active=true \
  -o jsonpath='{.items[0].metadata.name}')
kubectl -n openbao exec $A -- sh -c 'cd /openbao/audit && mv audit.log audit.old \
  && mkdir audit.log && kill -HUP $(pidof bao)'     # Pfad aus Tag 12

Symptome: Fast jeder Request scheitert, auch über Standbys (sie leiten an den Active weiter). sys/health antwortet weiter mit 200.

Code: 500. Errors:
* internal error

Diagnose:

kubectl -n openbao logs $A --tail=20 | grep -i audit
kubectl -n openbao exec $A -- df -h /openbao/audit
bao audit list -detailed   # scheitert ebenfalls – auch das ist ein Symptom
[ERROR] audit: backend failed to log request: backend=datei/
  error="open ...: is a directory"
[ERROR] core: failed to audit request: path=...
  * no audit backend succeeded in logging the request

Warum? OpenBao protokolliert jeden Request, bevor er ausgeführt wird, und arbeitet fail-closed: Schreibt kein einziges Audit-Device erfolgreich, wird der Request abgelehnt. Ein Device, das blockiert statt Fehler zu liefern (volles Netzwerk-Volume, socket- oder syslog-Ziel ohne Abnehmer), lässt Requests hängen, bis Clients in Timeouts laufen.

Behebung:

kubectl -n openbao exec $A -- sh -c 'cd /openbao/audit && rmdir audit.log \
  && mv audit.old audit.log && kill -HUP $(pidof bao)'
bao kv get -mount=secret -field=db_user webshop/config

Dauerhaft: zweites Audit-Device auf ein anderes Ziel in der Server-Konfiguration ergänzen (eins muss gelingen), Disk-Alarm ab 80 %, Logrotation mit SIGHUP. Deklarativ konfigurierte Devices lassen sich nicht per API abschalten (cannot disable configuration-managed audit device) – Änderung über values.yaml und helm upgrade.

Zeitziel: 10 min

Szenario 9: Storage weg – passt der Seal-Key noch?

Der Transit-Key autounseal ist dein Seal-Key und steht hier für einen HSM-Key (PKCS#11). Ein Kollege hat nach einem Storage-Verlust „sicherheitshalber” einen neuen Key angelegt und neu installiert.

Störung auslösen (Stoppuhr erst nach dem letzten Befehl dieses Blocks starten):

bao operator raft snapshot save ~/bao-lab/tag14/seal.snap
kubectl -n unsealer port-forward svc/bao-unsealer 8210:8200 >/dev/null 2>&1 &
ub() {   # aus Tag 10
  BAO_ADDR=http://127.0.0.1:8210 \
  BAO_TOKEN="$(jq -r .root_token ~/bao-lab/k8s/unsealer-init.json)" bao "$@"
}
ub write -f transit/keys/autounseal-neu                  # das „neue HSM"
{ cat ~/bao-lab/k8s/autounseal.hcl; cat <<'EOF'
path "transit/encrypt/autounseal-neu" { capabilities = ["update"] }
path "transit/decrypt/autounseal-neu" { capabilities = ["update"] }
EOF
} | ub policy write autounseal -
sed 's/"autounseal"/"autounseal-neu"/' ~/bao-lab/k8s/values.yaml \
  > ~/bao-lab/tag14/values-falsch.yaml
helm -n openbao uninstall openbao
for i in 0 1 2; do kubectl -n openbao delete pvc data-openbao-$i audit-openbao-$i \
  --ignore-not-found; done
helm -n openbao install openbao openbao/openbao --version 0.30.2 \
  -f ~/bao-lab/tag14/values-falsch.yaml
kubectl -n openbao wait pod/openbao-0 --for=jsonpath='{.status.phase}'=Running \
  --timeout=120s
kubectl -n openbao exec openbao-0 -- bao operator init \
  -recovery-shares=5 -recovery-threshold=3 -format=json > ~/bao-lab/tag14/temp-init.json
kubectl -n openbao wait pod/openbao-0 --for=condition=Ready --timeout=120s
pkill -f 'port-forward svc/openbao-active'
kubectl -n openbao port-forward svc/openbao-active 8200:8200 >/dev/null 2>&1 &
BAO_TOKEN=$(jq -r .root_token ~/bao-lab/tag14/temp-init.json) \
  bao operator raft snapshot restore -force ~/bao-lab/tag14/seal.snap
kubectl -n openbao delete pod openbao-0 openbao-1 openbao-2

Symptome: Init läuft ohne Fehler durch, der Restore meldet keinen oder erst nachträglich einen Fehler. Nach dem Neustart bleiben alle Pods sealed, obwohl der Unsealer läuft.

Seal Type          transit
Sealed             true

Diagnose:

kubectl -n openbao logs openbao-0 --tail=40 | grep -iE 'seal|decrypt'
kubectl -n openbao get cm openbao-config -o yaml | grep key_name
grep key_name ~/bao-lab/k8s/values.yaml            # gesicherte Seal-Konfiguration
ub list transit/keys

Warum? Der Snapshot enthält den Root-Key, verschlüsselt mit autounseal. Der Seal versucht ihn mit autounseal-neu zu entschlüsseln und scheitert. -force schaltet nur die Hash-Prüfung ab (Szenario 5). Ob der Key passt, beweist erst der Unseal. Recovery-Keys helfen nicht: Sie ersetzen den Seal-Key nicht.

Behebung: Den alten Key wieder eintragen. Der neue Key wird nicht gebraucht.

helm -n openbao upgrade openbao openbao/openbao --version 0.30.2 \
  -f ~/bao-lab/k8s/values.yaml
kubectl -n openbao delete pod openbao-0 openbao-1 openbao-2     # OnDelete
kubectl -n openbao wait pod/openbao-0 pod/openbao-1 pod/openbao-2 \
  --for=condition=Ready --timeout=180s
pkill -f 'port-forward svc/openbao-active'
kubectl -n openbao port-forward svc/openbao-active 8200:8200 >/dev/null 2>&1 &
export BAO_TOKEN=$(bao login -no-store -token-only -method=userpass \
  username=wettkampf password=lab-wk-pw)
bao kv get -mount=secret -field=db_user webshop/config

Aufräumen: Policy zurück, Lab-Key löschen.

ub policy write autounseal ~/bao-lab/k8s/autounseal.hcl
ub write transit/keys/autounseal-neu/config deletion_allowed=true
ub delete transit/keys/autounseal-neu
rm ~/bao-lab/tag14/values-falsch.yaml ~/bao-lab/tag14/temp-init.json

seal.snap enthält alle Secrets: löschen oder wie die anderen Snapshots verwahren.

Übertrag auf ein HSM (PKCS#11): Das HSM speichert nur den Key, keinen Cluster-Zustand. Nach einem Storage-Verlust bleibt er gültig. Das HSM-Token (PKCS#11-Slot) darf deshalb nicht neu initialisiert werden, denn das löscht den Key.

HSM-Key da? Snapshot da? Ergebnis
ja ja gleiche Seal-Konfiguration, init, Restore, Unseal: alles zurück
ja nein Daten weg, Key weiter nutzbar
nein ja Snapshot wertlos, Root-Key nicht entschlüsselbar
nein nein Neustart von null

Vor der Neuinstallation prüfen, ob der Key noch da ist (Beispiel SoftHSM, Pfad je nach Distribution):

pkcs11-tool --module /usr/lib/softhsm/libsofthsm2.so --login \
  --list-objects --type secrkey

Label und ID mit der gesicherten Seal-Konfiguration vergleichen. Die Option zur automatischen Key-Erzeugung nach der Ersteinrichtung abschalten (Namen in der Doku des KMS-Plugins prüfen). Sonst erzeugt ein Tippfehler im Key-Label still einen neuen Key, und es passiert genau das, was du gerade geübt hast.

Achtung: Liegt das SoftHSM-Token-Verzeichnis im PVC des Pods, löscht delete pvc das „HSM” gleich mit.

Den ganzen Ablauf mit echtem USB-HSM übst du in Anhang C.

Zeitziel: 20 min

Bewertung

Szenario Zeitziel geschafft
1 Pod/Node-Ausfall 5 min [ ]
2 Quorum-Verlust (A / B) 3 / 15 min [ ]
3 Unsealer weg 5 min [ ]
4 Secret gelöscht 3 min [ ]
5 Snapshot-Restore 15 min [ ]
6 Token/SecretID-Leak 5 min [ ]
7 TLS abgelaufen 15 min [ ]
8 Audit blockiert 10 min [ ]
9 Falscher Seal-Key 20 min [ ]

7 von 9 in der Zeit: einsatzbereit für Rufbereitschaft. Schreibe zu jedem verpassten Ziel eine Zeile ins Runbook.

Zum Schluss den Übungs-User entfernen: bao delete auth/userpass/users/wettkampf und bao policy delete wettkampf. Und die Übungsdateien: rm ~/bao-lab/tag14/*.snap ~/bao-lab/tls/drill.*.

Enterprise-Notiz

  • Game-Days regelmäßig ansetzen, mit wechselnder Besetzung, nicht nur für die Person, die den Cluster gebaut hat.
  • Runbooks versionieren und nach jedem Drill aktualisieren. Verpasste Zeitziele sind Runbook-Lücken.
  • Restore-Tests im Wegwerf-Cluster gegen den echten Seal (Transit oder HSM), nicht nur gegen das Lab.
  • Destruktive Drills nie im Produktiv-Cluster ohne Change-Freigabe und aktuellen Snapshot.