Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 15: Wettkampf – Desaster-Drills

Ziel: Acht typische Störungen rund um die Nutzung von Secrets unter Zeitdruck finden und beheben, ohne dabei Least Privilege aufzuweichen. · Dauer: ca. 180 min · Voraussetzung: Tag 14

Briefing

  • Jeder Drill hat einen Auslöser. Löse ihn aus, starte die Stoppuhr und stoppe sie erst, wenn wk-check.sh wieder nur ✔ zeigt.
  • Erst messen, dann ändern: Events, vault-agent-init-Logs, bao token capabilities, Audit-Log. Wer rät, verliert Zeit.
  • Lies nur Szenario und Symptome. Diagnose-Pfad und Lösung erst aufdecken, wenn du festhängst. Das kostet die Hälfte der Punkte.
  • Live gegen OpenBao 2.7.1 getestet sind Policies, Tokens, Leases und JWT (Drill 3, 4, 6, 8). Ausgaben mit Cluster-Bezug sind als „kann je nach Version abweichen” markiert.
 Störung ──► Symptom (wk-check ✘, Event, Log) ──► Diagnose ──► kleinste Reparatur
                                                   └──► dauerhafte Lehre (Git, Rolle)

Drill 0: Aufstellung (ohne Zeit)

Seit Tag 14 läuft OpenBao mit Audit-Device, der Neustart hat aber alles außer seed.sh gelöscht: Database-Engine, jwt-ci/, Rollen aus Tag 7 bis 10. Dazu stehen in shop noch Reste aus Tag 3 bis 9. aufstellung.sh räumt shop komplett ab und baut einen definierten Startzustand aus ~/secrets-lab/code neu auf.

mkdir -p ~/secrets-lab/tag15 && cd ~/secrets-lab/tag15
cp ~/secrets-lab/code/tag15/* .
export BAO_ADDR=http://127.0.0.1:8200 BAO_TOKEN=root
~/secrets-lab/setup/check.sh | grep ✘ || echo "Gelände ok"
bao audit list
kubectl get deploy -A -o custom-columns=NS:.metadata.namespace,NAME:.metadata.name \
  | grep -E 'external-secrets |reloader|injector'
kubectl -n openbao get ds openbao-csi-provider
ls ~/secrets-lab/tag10 | grep ci-issuer

Erwartet (gekürzt, kann je nach Version abweichen):

Gelände ok
Path       Type    Description
----       ----    -----------
stdout/    file    n/a
external-secrets   external-secrets
openbao            openbao-agent-injector
reloader           reloader-reloader
NAME                   DESIRED   CURRENT   READY   ...
openbao-csi-provider   1         1         1       ...
ci-issuer.key
ci-issuer.pub

Fehlt etwas, holst du es aus dem jeweiligen Tag nach: ESO (Tag 3, Drill 1), CSI-Treiber und Provider (Tag 6, Drill 1), Reloader (Tag 9, Drill 3), Lab-Issuer (Tag 10, Drill 2). Ein fehlendes Audit-Device bekommst du mit Tag 14, Drill 1.

Was das Skript aufbaut, zeigt ein Blick auf die Kommentare:

grep '^# [0-9]' aufstellung.sh
./aufstellung.sh

Erwartet (gekürzt, kann je nach Version abweichen):

# 1. Namespace shop frisch, Demo-Daten neu (Tag 0)
# 2. Dynamische DB-Credentials (Tag 4/7): Postgres, database/, Rolle shop-api-db
# 3. Pipeline-Identität (Tag 10): jwt-ci/, Policy ci-deploy, Rolle deploy-main
# 4. Rolle shop-loop für den Direkt-Leser (Muster aus Tag 8)
# 5. Workloads: ESO (Tag 3/9), Tag-9-App, Injector, CSI, Direkt-Leser, DB-App
Success! Uploaded policy: shop-api-read
Success! Data written to: auth/kubernetes/config
✔ Demo-Daten, Policy shop-api-read, Rolle kubernetes/shop-api, NS shop angelegt
✔ Aufstellung fertig – weiter mit ./wk-check.sh

Die fünf Verbraucher im Namespace shop:

Deployment Zustellweg Herkunft
shop-api ESO-Secret shop-db als Env, Volume und subPath Tag 9, Drill 1
shop-api-inj Agent Injector, Env-Datei /vault/secrets/env Tag 5, Drill 4
shop-api-csi CSI-Volume /mnt/secrets (shop-api-bao) Tag 6, Drill 3
shop-api-loop curl direkt gegen die API, Rolle shop-loop Tag 2, Drill 4 + Tag 8
shop-api-pg Agent mit dynamischen DB-Credentials Tag 7

Dazu die Lab-Pipeline aus Tag 10 mit der Rolle jwt-ci/role/deploy-main. Die Wettkampf-Matrix prüft alles auf einmal:

./wk-check.sh

Erwartet (gekürzt, kann je nach Version abweichen):

✔ SecretStore openbao Ready
✔ ExternalSecret shop-api synchron
✔ ExternalSecret shop-db synchron
✔ shop-api: Env aktuell
✔ shop-api: subPath aktuell
✔ shop-api-inj: Datei aktuell
✔ shop-api-csi: Datei aktuell
✔ shop-api-loop: liest (HTTP 200)
✔ shop-api-pg: DB-Login klappt
✔ CI: deploy-main-Login
✔ alle Pods in shop Ready
Fehler: 0

Nicht grün? Dann stimmt der Startzustand nicht. Erst reparieren, dann starten. Nach jedem Drill muss die Matrix wieder grün sein, sonst trägst du den Fehler in den nächsten.

Achtung: Arbeite nur im Lab. Mehrere Auslöser sind bewusst brutal (Rollen ändern, Leases widerrufen). In Produktion gehören sie in ein Game-Day-Protokoll mit Freigabe.

Fortschritt speichern? Kostenlos registrieren

Drill 1: Audience-Umstellung „nur kurz”

Szenario: Das Plattform-Team setzt die Enterprise-Notiz aus Tag 2 um: Audience eindeutig als openbao-prod. Die Rolle ist schnell geändert, die Verbraucher folgen „nächste Woche”. Am Montag wird ausgerollt.

Auslöser:

bao write auth/kubernetes/role/shop-api audience=openbao-prod
kubectl -n shop rollout restart deploy/shop-api-inj deploy/shop-api-csi
sleep 30

Zeitlimit: 10 min

Symptome:

$ ./wk-check.sh | grep ✘
✘ ExternalSecret shop-api synchron
✘ ExternalSecret shop-db synchron
✘ alle Pods in shop Ready
$ kubectl -n shop get pod | grep -v Running
NAME                            READY   STATUS              RESTARTS   AGE
shop-api-csi-6c8d9f7b5-q2xkp    0/1     ContainerCreating   0          30s
shop-api-inj-7f9b8c6d4-m5lzt    0/2     Init:0/1            0          30s

Diagnose-Pfad:

kubectl -n shop logs -l app=shop-api-inj -c vault-agent-init --tail=20 \
  | grep '^  | \*'
kubectl -n shop get events --field-selector reason=UpdateFailed \
  -o jsonpath='{.items[-1:].message}' | fold -w 88 | grep -E 'Code|\*'
bao read -field=audience auth/kubernetes/role/shop-api; echo
kubectl -n shop get ss openbao \
  -o jsonpath='{.spec.provider.vault.auth.kubernetes.serviceAccountRef.audiences}'

Erwartet (gekürzt, kann je nach Version abweichen):

  | * invalid audience (aud) claim: audience claim does not match any expected audience
Code: 403. Errors:
* invalid audience (aud) claim: audience claim does not match any expected audience
openbao-prod
["openbao"]

Drei Verbraucher, eine Meldung: Rolle und Token-Audience passen nicht mehr. Alte Pods laufen weiter, weil ihre Agents schon einen OpenBao-Token haben. Neue Pods, ESO und jeder neue Login scheitern.

Lösung: Erst die Rolle zurück, dann neu anstoßen.

bao write auth/kubernetes/role/shop-api audience=openbao
kubectl -n shop annotate es --all force-sync="$(date +%s)" --overwrite
kubectl -n shop rollout status deploy/shop-api-inj --timeout=180s
kubectl -n shop rollout status deploy/shop-api-csi --timeout=180s
./wk-check.sh | tail -1

Erwartet (gekürzt, kann je nach Version abweichen):

Success! Data written to: auth/kubernetes/role/shop-api
externalsecret.external-secrets.io/shop-api annotated
externalsecret.external-secrets.io/shop-db annotated
deployment "shop-api-inj" successfully rolled out
deployment "shop-api-csi" successfully rolled out
Fehler: 0

Init-Container und CSI-Mount versuchen es selbst erneut, du musst die Pods nicht löschen.

Lehre:

  • audience an der Kubernetes-Rolle ist ein Wert. Eine Umstellung geht nicht „in place”, sondern über eine zweite Rolle (shop-api-prod) mit neuer Audience. Dann zieht ein Verbraucher nach dem anderen um, die alte Rolle fällt zuletzt.
  • Pro Verbraucher sitzt die Audience an einer anderen Stelle: serviceAccountRef.audiences (ESO), projiziertes Volume (Injector), audience in der SecretProviderClass (CSI).
  • Laufende Pods sind kein Beweis. Erst ein Neustart oder ein ESO-Refresh zeigt, ob die Rolle noch passt.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Der neue Worker hängt im Init

Szenario: Das Team bringt einen Worker mit eigenem ServiceAccount shop-worker. Die Annotationen sind „von shop-api kopiert”. Der Pod startet nicht, und das Team fragt, ob du shop-worker nicht einfach in die Rolle shop-api aufnehmen kannst.

Auslöser:

kubectl apply -f d2-shop-worker.yaml
sleep 30

Zeitlimit: 10 min

Symptome:

$ ./wk-check.sh | grep ✘
✘ alle Pods in shop Ready
$ kubectl -n shop get pod -l app=shop-worker
NAME                           READY   STATUS     RESTARTS   AGE
shop-worker-5d7c9b8f6c-r8wq2   0/1     Init:0/1   0          30s

Diagnose-Pfad:

kubectl -n shop logs -l app=shop-worker -c vault-agent-init --tail=20 | grep '^  | \*'
kubectl -n shop get deploy shop-worker -o json | jq '.spec.template.metadata.annotations
  | with_entries(select(.key | test("role|secret-")))'
kubectl -n shop get deploy shop-worker \
  -o jsonpath='{.spec.template.spec.serviceAccountName}{"\n"}'
bao read -format=json auth/kubernetes/role/shop-api \
  | jq -c '.data | {bound_service_account_names, token_policies}'

Erwartet (gekürzt, kann je nach Version abweichen):

  | * service account name not authorized
{
  "vault.hashicorp.com/agent-inject-secret-stripe": "secret/data/shop/stripe",
  "vault.hashicorp.com/role": "shop-api"
}
shop-worker
{"bound_service_account_names":["shop-api"],"token_policies":["shop-api-read"]}

0/1 mit Init:0/1: Der Injector hat gegriffen (agent-pre-populate-only, kein Sidecar), der Login nicht. Die Meldung kennst du aus Tag 2, Drill 3.

Lösung: Nicht die Rolle shop-api aufbohren, sondern eine eigene Rolle mit genau dem Secret, das der Worker braucht.

bao policy write shop-worker-read - <<'HCL'
path "secret/data/shop/stripe" {
  capabilities = ["read"]
}
HCL
bao write auth/kubernetes/role/shop-worker bound_service_account_names=shop-worker \
  bound_service_account_namespaces=shop audience=openbao \
  token_policies=shop-worker-read token_ttl=15m token_max_ttl=1h
kubectl -n shop patch deploy shop-worker --type merge -p '{"spec":{"template":
  {"metadata":{"annotations":{"vault.hashicorp.com/role":"shop-worker"}}}}}'
kubectl -n shop rollout status deploy/shop-worker --timeout=120s
kubectl -n shop exec deploy/shop-worker -- cat /vault/secrets/stripe | head -1
./wk-check.sh | tail -1

Erwartet (gekürzt, kann je nach Version abweichen):

Success! Uploaded policy: shop-worker-read
Success! Data written to: auth/kubernetes/role/shop-worker
deployment.apps/shop-worker patched
deployment "shop-worker" successfully rolled out
data: map[token:lab-stripe-789]
Fehler: 0

Lehre:

  • Ein ServiceAccount, eine Rolle, eine Policy. Wer shop-worker in shop-api aufnimmt, gibt dem Worker jedes Secret unter secret/shop/ gleich mit.
  • Annotationen kopieren heißt auch role kopieren. Im Review gehört role neben serviceAccountName.
  • Erste Anlaufstelle bei Init:0/1 ist immer vault-agent-init, nie der App-Container.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Nach einer Minute nur noch 403

Szenario: Nach Tag 14 will die Security kürzere Token-Laufzeiten. Für den Direkt-Leser shop-api-loop wird token_max_ttl auf eine Minute gesetzt, beim nächsten Deploy startet der Pod neu. Er läuft, eine Minute lang.

Auslöser:

bao write auth/kubernetes/role/shop-loop token_max_ttl=1m
kubectl -n shop rollout restart deploy/shop-api-loop
kubectl -n shop rollout status deploy/shop-api-loop --timeout=60s
sleep 75

Zeitlimit: 10 min

Symptome:

$ ./wk-check.sh | grep ✘
✘ shop-api-loop: liest (HTTP 200)

Diagnose-Pfad:

kubectl -n shop logs deploy/shop-api-loop | head -14
bao read -format=json auth/kubernetes/role/shop-loop \
  | jq -c '.data | {token_ttl, token_max_ttl}'
grep -n 'login' loop.sh

Erwartet (Zeiten gekürzt, Verlauf live mit gleicher TTL-Logik geprüft):

10:00:00 login
10:00:05 renew ttl=20 read HTTP 200
10:00:10 renew ttl=20 read HTTP 200
...
10:00:45 renew ttl=15 read HTTP 200
10:00:50 renew ttl=10 read HTTP 200
10:00:55 renew ttl=5 read HTTP 200
10:01:00 renew ttl=- read HTTP 403
10:01:05 renew ttl=- read HTTP 403
{"token_ttl":20,"token_max_ttl":60}
4:login() {
6:  TOKEN=$(curl -s -X POST "$BAO/v1/auth/kubernetes/login" \
9:  echo "$(date +%T) login"
11:login

Das Renewal klappt, bis die Restzeit unter token_ttl fällt. Dann wird die TTL gekappt (die API liefert dazu die Warnung TTL of "20s" exceeded the effective max_ttl …; TTL value is capped accordingly), bis der Token abläuft. Ab dann ist jede Anfrage permission denied, auch das Renewal. login steht nur einmal vor der Schleife.

Lösung: Nicht token_max_ttl zurückdrehen, sondern die App den Re-Login lernen lassen (Tag 8). Eine Zeile vor dem Lesen reicht:

cat > loop.sh <<'EOF'
#!/bin/sh
# Tag 15: Direkt-Leser – erneuern, vor Ablauf von max_ttl neu einloggen (Lab)
BAO=http://openbao.openbao.svc:8200
login() {
  JWT=$(cat /var/run/secrets/openbao/token)
  TOKEN=$(curl -s -X POST "$BAO/v1/auth/kubernetes/login" \
    -d "{\"role\":\"shop-loop\",\"jwt\":\"$JWT\"}" \
    | sed 's/.*"client_token":"\([^"]*\)".*/\1/')
  echo "$(date +%T) login"
}
login
while sleep 5; do
  TTL=$(curl -s -X POST -H "X-Vault-Token: $TOKEN" \
    "$BAO/v1/auth/token/renew-self" | sed -n 's/.*"lease_duration":\([0-9]*\).*/\1/p')
  [ "${TTL:-0}" -lt 10 ] && login   # max_ttl in Sicht oder Token weg: neu einloggen
  CODE=$(curl -s -o /dev/null -w '%{http_code}' -H "X-Vault-Token: $TOKEN" \
    "$BAO/v1/secret/data/shop/api")
  echo "$(date +%T) renew ttl=${TTL:--} read HTTP $CODE"
done
EOF
kubectl -n shop create configmap shop-loop --from-file=loop.sh --dry-run=client \
  -o yaml | kubectl apply -f -
kubectl -n shop rollout restart deploy/shop-api-loop
sleep 75; kubectl -n shop logs deploy/shop-api-loop | sed -n '7,11p'

Erwartet (Zeiten gekürzt, Verlauf live mit gleicher TTL-Logik geprüft):

configmap/shop-loop configured
deployment.apps/shop-api-loop restarted
10:05:50 renew ttl=10 read HTTP 200
10:05:55 login
10:05:55 renew ttl=5 read HTTP 200
10:06:00 renew ttl=20 read HTTP 200
10:06:05 renew ttl=20 read HTTP 200

Der Re-Login liest die Token-Datei neu (Tag 2, Drill 4), kein 403 mehr. ./wk-check.sh ist wieder grün.

Lehre:

  • token_max_ttl ist eine harte Grenze. Renewal verlängert nur bis dorthin, danach hilft nur ein neuer Login.
  • Code, der den Re-Login nicht kann, fällt erst nach token_max_ttl auf. Im Test daher absichtlich kurze Werte setzen, wie hier.
  • Die Härtung war richtig. Die Reparatur gehört in die App, nicht in die Rolle.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Die aufgeräumte Policy

Szenario: Ein Kollege räumt die Policies auf: „Die CLI sagt doch secret/shop/api, warum steht da data/?” Kurz darauf werden die ExternalSecrets rot, ESO und OpenBao melden aber beide „läuft”.

Auslöser:

bao policy write shop-api-read - <<'HCL'
# aufgeräumt: Pfad wie in der CLI
path "secret/shop/*" {
  capabilities = ["read"]
}
HCL
kubectl -n shop annotate es --all force-sync="$(date +%s)" --overwrite
sleep 10

Zeitlimit: 10 min

Symptome:

$ ./wk-check.sh | grep ✘
✘ ExternalSecret shop-api synchron
✘ ExternalSecret shop-db synchron
✘ shop-api-loop: liest (HTTP 200)
$ kubectl -n shop get ss openbao
NAME      AGE   STATUS   CAPABILITIES   READY
openbao   1h    Valid    ReadWrite      True

Diagnose-Pfad: Store Valid, ExternalSecret rot, der Login klappt also. Die URL im Event zeigt den Pfad, den OpenBao abgelehnt hat.

kubectl -n shop get events --field-selector involvedObject.name=shop-api,\
reason=UpdateFailed -o jsonpath='{.items[-1:].message}' | grep -E 'URL|denied'
T=$(bao write -field=token auth/kubernetes/login role=shop-api \
  jwt="$(kubectl -n shop create token shop-api --audience openbao)")
for p in secret/shop/api secret/data/shop/api; do
  printf '%-22s %s\n' "$p" "$(bao token capabilities "$T" "$p")"
done
bao kv get -output-policy secret/shop/api

Erwartet (Event gekürzt, kann je nach Version abweichen; Rest live getestet):

URL: GET http://openbao.openbao.svc:8200/v1/secret/data/shop/api
    * permission denied
secret/shop/api        read
secret/data/shop/api   deny
path "secret/data/shop/api" {
  capabilities = ["read"]
}

Die Policy erlaubt einen Pfad, den es in der API nicht gibt. KV v2 liest über secret/data/… (Tag 1). Injector und CSI zeigen es nicht sofort: Der Sidecar behält die letzte gerenderte Datei, der CSI-Treiber das zuletzt gemountete Volume.

Lösung:

bao policy write shop-api-read - <<'HCL'
path "secret/data/shop/*" {
  capabilities = ["read"]
}
HCL
bao token capabilities "$T" secret/data/shop/api
kubectl -n shop annotate es --all force-sync="$(date +%s)" --overwrite
sleep 10; ./wk-check.sh | tail -1

Erwartet (letzte Zeile gekürzt, kann je nach Version abweichen):

Success! Uploaded policy: shop-api-read
read
externalsecret.external-secrets.io/shop-api annotated
externalsecret.external-secrets.io/shop-db annotated
Fehler: 0

Policies wirken sofort, auch auf schon ausgestellte Tokens: $T darf ohne neuen Login wieder lesen.

Lehre:

  • Policies sprechen API-Pfade. bao kv get -output-policy liefert die richtige Regel, statt sie aus dem CLI-Pfad zu raten.
  • „Store Valid, ExternalSecret rot” heißt fast immer Policy oder Pfad, nicht Login.
  • Policy-Änderungen gehören in Git mit einem CI-Test per bao token capabilities (Tag 14). Dieser Fehler wäre dort rot geworden.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Neues Schema, alte Verbraucher

Szenario: Das DB-Team stellt secret/shop/api auf ein „einheitliches Schema” um: password statt db_password. Geschrieben wird mit kv put, ein Kollege startet danach die CSI-App neu. Die Injector-App läuft angeblich „ganz normal weiter”.

Auslöser:

bao kv put secret/shop/api db_user=shop password=lab-db-pw-800 \
  api_key=lab-api-key-456
kubectl -n shop annotate es --all force-sync="$(date +%s)" --overwrite
kubectl -n shop rollout restart deploy/shop-api-csi
sleep 30

Zeitlimit: 15 min

Symptome:

$ ./wk-check.sh | grep ✘
✘ ExternalSecret shop-api synchron
✘ ExternalSecret shop-db synchron
✘ shop-api: Env aktuell
✘ shop-api: subPath aktuell
✘ shop-api-inj: Datei aktuell
✘ shop-api-csi: Datei aktuell
✘ alle Pods in shop Ready

Diagnose-Pfad: Drei Verbraucher, drei Fehlerbilder für dieselbe Ursache.

bao kv metadata get -format=json secret/shop/api \
  | jq -c '.data | {current_version, oldest_version}'
bao kv get -format=json secret/shop/api | jq -c '.data.data | keys'
kubectl -n shop get events --field-selector involvedObject.name=shop-db,\
reason=UpdateFailed -o jsonpath='{.items[-1:].message}{"\n"}' | fold -w 88
kubectl -n shop get events --field-selector reason=FailedMount \
  -o jsonpath='{.items[-1:].message}{"\n"}' | fold -w 88 | tail -2
kubectl -n shop exec deploy/shop-api-inj -c app -- grep DB_PASSWORD /vault/secrets/env

Erwartet (gekürzt, kann je nach Version abweichen):

{"current_version":3,"oldest_version":0}
["api_key","db_user","password"]
error processing spec.data[0] (key: shop/api), err: cannot find secret data for key
: "db_password"
… failed to mount secrets store objects for pod shop/shop-api-csi-…, err: … key "db_pas
sword" does not exist at the secret path
export DB_PASSWORD="<no value>"

ESO meldet laut, CSI blockiert den neuen Pod, der Injector schreibt still <no value> in die Datei. Die App lädt beim nächsten Start ein kaputtes Passwort. Das K8s-Secret shop-db bleibt dagegen auf dem alten Stand (deletionPolicy: Retain, Tag 4), und shop-api läuft mit dem alten Wert weiter.

Lösung: Kleinste Reparatur ist das alte Schema per rollback (Tag 1, Drill 5). Die Rotation auf lab-db-pw-800 ist damit zurückgenommen und wird später sauber nachgeholt.

V=$(bao kv metadata get -format=json secret/shop/api | jq '.data.current_version')
bao kv rollback -version=$((V - 1)) secret/shop/api | grep version
bao kv get -format=json secret/shop/api | jq -c '.data.data | keys'
kubectl -n shop annotate es --all force-sync="$(date +%s)" --overwrite
kubectl -n shop rollout status deploy/shop-api-csi --timeout=120s
sleep 25; ./wk-check.sh | tail -1

Erwartet (gekürzt, kann je nach Version abweichen):

version            4
["api_key","db_password","db_user"]
externalsecret.external-secrets.io/shop-api annotated
externalsecret.external-secrets.io/shop-db annotated
deployment "shop-api-csi" successfully rolled out
Fehler: 0

Der CSI-Mount wird von selbst neu versucht, der Injector-Sidecar rendert im Takt von template-static-secret-render-interval (20 s) neu.

Lehre:

  • Key-Namen sind ein Vertrag mit allen Verbrauchern. Ein Schemawechsel heißt: neuen Key per kv patch zusätzlich schreiben, Verbraucher umstellen, alten Key zuletzt entfernen. kv put ersetzt das ganze Secret (Tag 1, Drill 4).
  • Der Injector scheitert still. Mit vault.hashicorp.com/error-on-missing-key-<name>: "true" bricht das Rendern stattdessen ab (laut vault-k8s-Doku, im Lab nicht getestet).
  • KV-Versionen sind dein Rückweg. max_versions daher nicht zu knapp wählen.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Das Repo heißt jetzt anders

Szenario: acme/shop wird zu acme/webshop umbenannt. Seitdem scheitert jedes Deployment beim OpenBao-Login. Das Team will die Rolle „schnell auf den neuen Namen umbiegen”.

Auslöser: Ab jetzt schickt die Lab-Pipeline die Claims des umbenannten Repos.

echo 'repository=acme/webshop sub=repo:acme/webshop:ref:refs/heads/main' \
  > pipeline.claims

Zeitlimit: 5 min

Symptome:

$ ./wk-check.sh | grep ✘
✘ CI: deploy-main-Login

Diagnose-Pfad:

mint() { KEY=~/secrets-lab/tag10/ci-issuer.key ~/secrets-lab/tag10/mint-jwt.sh "$@"; }
BAO_TOKEN= bao write auth/jwt-ci/login role=deploy-main \
  jwt="$(mint $(cat pipeline.claims))" 2>&1 | tail -1
mint $(cat pipeline.claims) | jq -R 'split(".")[1] | gsub("-";"+") | gsub("_";"/")
  | @base64d | fromjson | {sub, repository, repository_id, ref}'
bao read -format=json auth/jwt-ci/role/deploy-main | jq -c '.data.bound_claims'

Erwartet (live getestet):

* error validating claims: claim "repository" does not match any associated bound claim
values
{
  "sub": "repo:acme/webshop:ref:refs/heads/main",
  "repository": "acme/webshop",
  "repository_id": "100001",
  "ref": "refs/heads/main"
}
{"ref":"refs/heads/main","repository":"acme/shop"}

Der Name hat sich geändert, die ID nicht. Die Enterprise-Notiz aus Tag 10 sagt es schon: an unveränderliche IDs binden.

Lösung:

bao write auth/jwt-ci/role/deploy-main - <<'EOF'
{
  "role_type": "jwt",
  "user_claim": "sub",
  "bound_audiences": ["openbao"],
  "bound_claims_type": "string",
  "bound_claims": {"repository_id": "100001", "ref": "refs/heads/main"},
  "claim_mappings": {"repository": "repository"},
  "token_policies": ["ci-deploy"],
  "token_ttl": "5m",
  "token_max_ttl": "10m"
}
EOF
BAO_TOKEN= bao write -field=token_policies auth/jwt-ci/login role=deploy-main \
  jwt="$(mint $(cat pipeline.claims))"; echo
BAO_TOKEN= bao write auth/jwt-ci/login role=deploy-main \
  jwt="$(mint repository=acme/evil repository_id=999)" 2>&1 | tail -1

Erwartet (live getestet):

Success! Data written to: auth/jwt-ci/role/deploy-main
[ci-deploy default]
* error validating claims: claim "repository_id" does not match any associated bound
claim values

claim_mappings hält den aktuellen Namen trotzdem als Token-Metadatum fest, das Audit-Log zeigt also weiter acme/webshop.

Lehre:

  • „Rolle auf den neuen Namen umbiegen” repariert nur bis zur nächsten Umbenennung. Und den alten Namen acme/shop kann danach jemand neu anlegen.
  • repository_id (GitHub) bzw. project_id (GitLab, Tag 12) binden, Namen nur als Metadaten mitnehmen.
  • Wer bound_subject nutzt (Tag 11), muss bei Umbenennungen auch den sub nachziehen.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Rotation kommt nicht an

Szenario: Jemand spielt shop-api „sauber aus dem Repo” neu ein. Eine Stunde später wird das DB-Passwort rotiert. ESO meldet SecretSynced, die App meldet sich trotzdem mit dem alten Passwort an.

Auslöser:

kubectl replace -f ~/secrets-lab/code/tag09/shop-api.yaml
kubectl -n shop rollout status deploy/shop-api --timeout=90s
bao kv patch secret/shop/api db_password=lab-db-pw-700 | grep version
sleep 120

Zeitlimit: 10 min

Symptome:

$ ./wk-check.sh | grep ✘
✘ shop-api: Env aktuell
✘ shop-api: subPath aktuell
$ kubectl -n shop logs deploy/shop-api --tail=1
08:14:02 env=lab-db-pw-123 vol=lab-db-pw-700 subpath=lab-db-pw-123

Diagnose-Pfad:

kubectl -n shop get es shop-db
kubectl -n shop get secret shop-db -o jsonpath='{.data.db_password}' | base64 -d; echo
kubectl -n shop get deploy shop-api -o json | jq '.metadata.annotations
  | with_entries(select(.key | test("reloader")))'
kubectl -n shop get deploy shop-api -o yaml | grep -B1 -A1 subPath

Erwartet (gekürzt, kann je nach Version abweichen):

NAME      STORETYPE     STORE     REFRESH INTERVAL   STATUS         READY
shop-db   SecretStore   openbao   15s                SecretSynced   True
lab-db-pw-700
{}
        - mountPath: /etc/db_password
          name: db
          subPath: db_password

Die Kette reißt hinter dem K8s-Secret: kubectl replace hat die Annotation secret.reloader.stakater.com/reload gelöscht, die nur per kubectl annotate gesetzt war und nie im Manifest stand. Ohne sie startet Reloader nichts neu. Das Volume ist aktuell, Env und subPath nicht (Tag 9, Drill 2).

Lösung: Annotation zurück und einmal neu starten. Reloader reagiert nur auf künftige Änderungen am Secret.

kubectl -n shop annotate deploy/shop-api \
  secret.reloader.stakater.com/reload=shop-db --overwrite
kubectl -n shop rollout restart deploy/shop-api
kubectl -n shop rollout status deploy/shop-api --timeout=90s
sleep 10; kubectl -n shop logs deploy/shop-api --tail=1

Erwartet (gekürzt, kann je nach Version abweichen):

deployment.apps/shop-api annotated
deployment.apps/shop-api restarted
deployment "shop-api" successfully rolled out
08:17:31 env=lab-db-pw-700 vol=lab-db-pw-700 subpath=lab-db-pw-700

Lehre:

  • Was nicht im Manifest steht, gibt es nach dem nächsten replace, Helm-Upgrade oder GitOps-Sync nicht mehr. Reloader-Annotationen gehören ins Repo.
  • SecretSynced beweist nur den Weg bis zum K8s-Secret. Ob der Prozess den Wert hat, zeigt erst die App selbst.
  • subPath für Secrets streichen, Env-Variablen nur mit Reloader (Tag 9, Drill 7).

Fortschritt speichern? Kostenlos registrieren

Drill 8: Alle DB-Leases widerrufen

Szenario: Ein Laptop mit DB-Zugang ist verschwunden. Die Security zieht die Notbremse und widerruft alle dynamischen DB-Credentials. Kurz darauf meldet shop-api-pg Login-Fehler bei Postgres.

Auslöser:

bao lease revoke -prefix database/creds/shop-ro-short
sleep 5

Zeitlimit: 10 min

Symptome:

$ ./wk-check.sh | grep ✘
✘ shop-api-pg: DB-Login klappt
$ kubectl -n shop logs deploy/shop-api-pg -c app --tail=1
08:31:12 psql: error: connection to server at "postgres.shop.svc" (…), port 5432 failed

Diagnose-Pfad:

bao list sys/leases/lookup/database/creds/shop-ro-short
kubectl -n openbao logs openbao-0 | grep '^{' | jq -c 'select(.type == "request"
  and (.request.path | startswith("sys/leases/revoke-prefix")))
  | {t: .time[11:19], who: .auth.display_name, path: .request.path}' | fold -w 88
kubectl -n shop exec deploy/postgres -- psql -U postgres -tAc \
  "select count(*) from pg_roles where rolname like 'v-%'"

Erwartet (gekürzt, kann je nach Version abweichen):

No value found at sys/leases/lookup/database/creds/shop-ro-short
{"t":"08:31:07","who":"token","path":"sys/leases/revoke-prefix/database/creds/shop-ro-sh
ort"}
0

Keine Leases, keine DB-User. Das Audit-Log zeigt, wer es war (hier der Root-Token, token). Der Sidecar merkt den Widerruf erst beim nächsten Renew-Versuch (lease not found) und holt dann selbst neue Credentials, im Lab nach rund einer Minute (Tag 7, Drill 6). So lange scheitert jeder Login der App.

Lösung: Im Ernstfall nicht auf den nächsten Renew-Versuch warten (bei produktiven TTLs kann der viele Minuten entfernt sein), sondern sofort neue Credentials holen lassen.

kubectl -n shop rollout restart deploy/shop-api-pg
kubectl -n shop rollout status deploy/shop-api-pg --timeout=120s
sleep 20; kubectl -n shop logs deploy/shop-api-pg -c app --tail=1
bao list sys/leases/lookup/database/creds/shop-ro-short

Erwartet (gekürzt, kann je nach Version abweichen):

deployment.apps/shop-api-pg restarted
deployment "shop-api-pg" successfully rolled out
08:33:40 v-kubernet-shop-ro--Qm3x9TfLwz0pK1sD7bYc-1791880420
Keys
----
Lq3vT8yRz0aWbN5cK7dE2fGh
pX9sM4kJ6tQ1uV3wY8zA0bCd

Zwei neue Leases: eine vom Init-Container, eine vom Sidecar (Tag 7, Drill 3).

Lehre:

  • lease revoke -prefix ist die richtige Notbremse: Der DB-User ist sofort weg, nicht erst nach max_ttl. Danach heilt jeder Zustellweg anders: Sidecar beim nächsten Renewal, ESO-Generator beim nächsten Refresh (Tag 4), Init-only und Env-Variablen nie.
  • Für den Ernstfall gehört ein Runbook dazu: Revoke, Rollout der betroffenen Apps, Nachweis per sys/leases/lookup und Audit-Log.
  • Apps mit dynamischen Credentials müssen Verbindungen neu aufbauen können. Ein Connection-Pool, der nie neu verbindet, überlebt die Notbremse nicht.

Fortschritt speichern? Kostenlos registrieren

Wertung

Volle Punkte nur in der Zeit und ohne aufgedeckten Diagnose-Pfad. Bis zur doppelten Zeit oder mit Spicken gibt es die Hälfte, danach nichts.

Drill Zeitlimit Punkte
1 Audience-Umstellung „nur kurz” 10 min 15
2 Der neue Worker hängt im Init 10 min 10
3 Nach einer Minute nur noch 403 10 min 15
4 Die aufgeräumte Policy 10 min 10
5 Neues Schema, alte Verbraucher 15 min 15
6 Das Repo heißt jetzt anders 5 min 10
7 Rotation kommt nicht an 10 min 10
8 Alle DB-Leases widerrufen 10 min 15
Summe 80 min 100

Ab 70 Punkten bist du reif für die Rufbereitschaft. Schreib für jeden verpassten Drill eine Zeile ins Runbook: Symptom, erster Befehl, Lösung.

Kontrollpunkt

Nach allen Drills muss der Endzustand sauber sein, nicht nur das Symptom weg.

cd ~/secrets-lab/tag15
ok() { echo "✔ $1"; }; nok() { echo "✘ $1"; }
./wk-check.sh >/dev/null && ok "Wettkampf-Matrix grün" || nok "Wettkampf-Matrix rot"
[ "$(bao read -field=audience auth/kubernetes/role/shop-api)" = openbao ] \
  && ok "shop-api: Audience openbao" || nok "shop-api: Audience geändert"
[ "$(bao read -field=bound_service_account_names auth/kubernetes/role/shop-api)" \
  = "[shop-api]" ] && ok "shop-api bindet nur SA shop-api" || nok "shop-api aufgebohrt"
bao read auth/kubernetes/role/shop-worker >/dev/null 2>&1 \
  && ok "eigene Rolle shop-worker" || nok "Rolle shop-worker fehlt"
bao policy read shop-api-read | grep -q 'secret/data/shop/\*' \
  && ok "shop-api-read mit data/" || nok "shop-api-read ohne data/"
grep -q '&& login' loop.sh \
  && ok "loop.sh loggt neu ein" || nok "loop.sh ohne Re-Login"
bao read -format=json auth/jwt-ci/role/deploy-main \
  | jq -e '.data.bound_claims.repository_id == "100001"' >/dev/null \
  && ok "deploy-main bindet repository_id" || nok "deploy-main bindet Namen"
kubectl -n shop get deploy shop-api -o jsonpath='{.metadata.annotations}' \
  | grep -q 'secret.reloader.stakater.com/reload' \
  && ok "shop-api mit Reloader-Annotation" || nok "Reloader-Annotation fehlt"
bao kv get -field=db_password secret/shop/api >/dev/null 2>&1 \
  && ok "Key db_password vorhanden" || nok "Schema kaputt"

Challenge

Nach dem Wettkampf will die Security wissen, welche Identität wie oft gescheitert ist. Schreib fehler-report.sh, das aus dem Audit-Log die fünf häufigsten Kombinationen aus Identität und Pfad mit Fehler zählt, einschließlich gescheiterter Logins.

Hinweis: Normale Fehler stehen in .error. Bei Logins steht der Fehler HMAC-gehasht in .response.data.error, .error bleibt dort leer.

Lösung

cat > fehler-report.sh <<'EOF'
#!/usr/bin/env bash
# Tag 15 Challenge: Fehler im Audit-Log je Identität und Pfad zählen (Top 5)
# Nutzung: ./fehler-report.sh [audit.jsonl]
jq -r 'select(.type == "response")
  | select(.error != null or .response.data.error != null)
  | [(.auth.display_name // "-"), .request.path] | @tsv' "${1:-audit.jsonl}" \
  | sort | uniq -c | sort -rn | head -5
EOF
chmod +x fehler-report.sh
kubectl -n openbao logs openbao-0 | grep '^{' > audit.jsonl
./fehler-report.sh

Erwartet (gekürzt, kann je nach Version abweichen; Zahlen und Namen hängen von deinem Wettkampf ab):

  14 kubernetes-shop-shop-api   secret/data/shop/api
   6 -  auth/kubernetes/login
   3 token  auth/jwt-ci/login
   2 -  auth/token/renew-self
   1 token  sys/leases/lookup

Die Zeile mit - ist die interessanteste: Anfragen ohne gültige Identität, etwa abgelaufene Tokens aus Drill 3 oder Logins mit falscher Audience aus Drill 1.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Diese Drills gehören als Game Day ins Quartal, im Staging mit echten Alarmen. Gemessen wird die Zeit bis zur Erkennung, nicht nur bis zur Reparatur.
  • Alarme, die diese Störungen früh zeigen: ESO-Metrik externalsecret_status_condition mit SecretSyncedError, Pods in Init:0/1 oder ContainerCreating länger als zwei Minuten, gehäufte 403 und Login-Fehler pro Identität im Audit-Log.
  • Rollen, Policies und Audiences als Code (Tag 13) mit Tests per bao token capabilities und Lab-JWTs. Drill 1, 4 und 6 wären dann im Review rot.
  • Notbremsen (Lease-Widerruf, Rolle sperren) brauchen ein Runbook mit Rollout-Liste: Wer nutzt welchen Pfad, welche Rolle, welchen Zustellweg?
  • Jeder Incident endet mit einem neuen Test: Zeile in der Wettkampf-Matrix, Capabilities-Test oder Negativ-JWT. Sonst kommt derselbe Fehler wieder.