Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 14: Wettkampf – Desaster-Drills

Ziel: Acht typische Störungen aus Netz und Admission unter Zeitdruck finden und beheben, ohne neue Lücken zu reißen. · Dauer: ca. 180 min · Voraussetzung: Tag 13 (Drill 8 zusätzlich Tag 4)

Briefing

  • Jeder Drill hat einen Auslöser. Löse ihn aus, starte dann die Stoppuhr und stoppe sie erst, wenn die Wettkampf-Matrix wieder grün ist.
  • Erst messen, dann ändern: np-matrix.sh, conncheck.sh, Events, Reports, Logs. 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.
  • Drill 1–7 laufen auf kyverno-lab, Drill 8 auf cilium-lab.
  • Alle Ausgaben mit Cluster-Bezug sind nicht live getestet. Live geprüft sind die Kyverno-CLI 1.19.1 (Drill 3, 7, Challenge) und die Syntax aller Dateien.
 Störung ──► Symptom (Matrix ✘, Event, Log) ──► Diagnose ──► kleinste Reparatur
                                                     └──► dauerhafte Lehre (Git, Policy)

Drill 0: Aufstellung (ohne Zeit)

Ein definierter Startzustand: Registry und Lab-CA aus Tag 10, Kyverno-HA aus Tag 12, Policies aus Tag 8 bis 13. Alles kommt frisch aus ~/guard-lab/code.

mkdir -p ~/guard-lab/tag14 && cd ~/guard-lab/tag14
kubectl config use-context kind-kyverno-lab
alias cc=~/guard-lab/code/demo/conncheck.sh
cp -R ~/guard-lab/code/kyverno-ops/tag13/{policies,tests} .
(cd ~/guard-lab/tag10 && ./setup-registry.sh)
ARCH=$(kubectl get node -o jsonpath='{.items[0].status.nodeInfo.architecture}')
crane copy --insecure --platform linux/$ARCH \
  nginxinc/nginx-unprivileged:1.31-alpine localhost:5001/shop/web:1.31 2>/dev/null
helm upgrade kyverno kyverno/kyverno -n kyverno --version 3.9.1 \
  -f ~/guard-lab/tag12/values-ha.yaml \
  --set-file global.caCertificates.data=$HOME/guard-lab/tag10/certs/registry.crt \
  --wait --timeout 5m
kubectl -n kyverno rollout restart deploy kyverno-admission-controller \
  kyverno-background-controller kyverno-reports-controller
kubectl -n kyverno rollout status deploy kyverno-admission-controller --timeout=180s

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

✔ kyverno-lab-control-plane vertraut kind-registry:5000
✔ Registry erreichbar: https://localhost:5001
Release "kyverno" has been upgraded. Happy Helming!
deployment "kyverno-admission-controller" successfully rolled out

Warum die CA noch einmal? values-ha.yaml aus Tag 12 enthält sie nicht. Jedes helm upgrade -f values-ha.yaml ohne --set-file wirft sie still hinaus, und Tag 10 endet mit x509: certificate signed by unknown authority.

Jetzt die Policies und die Vorlage für das Monitoring:

K=~/guard-lab/code/kyverno
kubectl apply -f $K/tag08/image-hygiene.yaml \
  -f ~/guard-lab/tag10/verify-shop-images.yaml \
  -f ~/guard-lab/tag11/policy-repo/policies/exception-governance.yaml \
  -f ~/guard-lab/tag12/no-privileged-vap.yaml \
  -f $K/tag09/tenant-netpol.yaml -f policies/
kubectl patch gpol tenant-netpol --type merge \
  -p '{"spec":{"evaluation":{"generateExisting":{"enabled":true}}}}'
kubectl create namespace netpol-templates
kubectl apply -f $K/tag09/tpl-allow-monitoring.yaml -f $K/tag09/clone-monitoring.yaml
sleep 20
kubectl get netpol -n tenant-a

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

NAME                   POD-SELECTOR   AGE
allow-dns              <none>         15s
allow-monitoring       tier=api       12s
allow-same-namespace   <none>         2d
default-deny           <none>         15s

Die Soll-Matrix für den ganzen Wettkampf, geprüft mit np-matrix.sh aus Tag 6:

cat > wettkampf.tsv <<'EOF'
# von                 nach                                 soll
default/client        http://frontend.shop                 allow
shop/frontend         http://api.shop                      allow
shop/api              tcp://db.shop:5432                   allow
tenant-a/api          http://api.tenant-a                  allow
tenant-a/api          http://api.tenant-b                  deny
tenant-b/api          http://api.tenant-a                  deny
default/client        http://api.tenant-a                  deny
monitoring/scraper    http://api.tenant-a:9113/metrics     allow
monitoring/scraper    http://api.tenant-b:9113/metrics     allow
monitoring/scraper    http://api.tenant-a                  deny
EOF
M=~/guard-lab/code/np-tests/np-matrix.sh
$M wettkampf.tsv | tail -1

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

10 Tests: 10 ✔, 0 ✘

Nicht grün? Dann stimmt der Startzustand nicht. Erst reparieren, dann starten.

Achtung: Arbeite nur im Lab. Mehrere Auslöser sind bewusst brutal (Webhooks löschen, Labels an Plattform-Namespaces). In Produktion gehören sie in ein Game-Day- Protokoll mit Freigabe.

Fortschritt speichern? Kostenlos registrieren

Drill 1: Egress-Härtung ohne DNS

Szenario: Das shop-Team will „Datenabfluss verhindern” und erlaubt Egress nur noch innerhalb des Namespace. Zwei Minuten später meldet der Support: Bestellungen hängen.

Auslöser:

cat > egress-lockdown.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: egress-lockdown
  namespace: shop
spec:
  podSelector: {}
  policyTypes: [Egress]
  egress:
  - to:
    - podSelector: {}         # "nur im eigenen Namespace"
EOF
kubectl apply -f egress-lockdown.yaml; sleep 15

Zeitlimit: 5 min

Symptome:

$ kubectl exec client -- curl -s -o /dev/null -w '%{http_code}\n' http://frontend.shop/
200
$ kubectl exec client -- curl -s -o /dev/null -w '%{http_code}\n' \
    http://frontend.shop/api/orders
502

Diagnose-Pfad:

$M wettkampf.tsv | grep '✘'
kubectl -n shop logs deploy/frontend --tail=3 | grep -o 'could not be resolved.*'
kubectl -n shop exec deploy/frontend -- nslookup api.shop.svc.cluster.local
kubectl -n shop get netpol
kubectl -n shop describe netpol egress-lockdown | sed -n '/Spec/,$p'

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

shop/frontend          http://api.shop                    allow  ✘ deny
could not be resolved (110: Operation timed out)
;; connection timed out; no servers could be reached
NAME              POD-SELECTOR   AGE
egress-lockdown   <none>         1m
  Allowing egress traffic:
    To Port: <any> (traffic allowed to all ports)
    To:
      PodSelector: <none>

Das frontend lebt, nur /api/ scheitert: nginx löst api.shop alle 10 s neu auf. CoreDNS liegt in kube-system, und dahin ist Egress jetzt zu (Tag 2, Drill 1).

Lösung:

kubectl apply -f ~/guard-lab/tag02/allow-dns.yaml
sleep 5
$M wettkampf.tsv | tail -1

Erwartet (gekürzt, nicht live getestet):

networkpolicy.networking.k8s.io/allow-dns created
10 Tests: 10 ✔, 0 ✘

Die Härtung bleibt, DNS kommt additiv dazu. Die Policy nicht löschen, das Team wollte sie.

Lessons:

  • Egress-Default-Deny und allow-dns sind ein Paar. Rolle nie das eine ohne das andere.
  • „Seite lädt, Funktion kaputt” ist das typische Bild: Ingress ok, Egress-DNS weg.
  • conncheck.sh meldet hier „Timeout”, nicht „DNS-Fehler”: Die Anfrage verhungert.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Kyverno weg, failurePolicy Fail

Szenario: Ein Kollege testet „mal schnell” ein Kyverno-Update von Hand. Danach geht kein Deployment mehr durch, und das Zurückskalieren hilft nicht.

Auslöser:

kubectl -n kyverno scale deploy kyverno-admission-controller --replicas=0
kubectl -n kyverno set image deploy/kyverno-admission-controller \
  kyverno=reg.kyverno.io/kyverno/kyverno:v1.19.99

Zeitlimit: 10 min

Symptome:

$ kubectl -n shop rollout restart deploy frontend
error: failed to patch: Internal error occurred: failed calling webhook
"…validate.kyverno.svc-fail": failed to call webhook: Post "https://kyverno-svc
.kyverno.svc:443/…": no endpoints available for service "kyverno-svc"

Diagnose-Pfad:

kubectl -n kyverno get deploy kyverno-admission-controller
kubectl -n kyverno get endpointslice -l kubernetes.io/service-name=kyverno-svc
kubectl get validatingwebhookconfigurations -l webhook.kyverno.io/managed-by=kyverno \
  -o custom-columns=NAME:.metadata.name,POLICY:.webhooks[*].failurePolicy
kubectl -n kyverno scale deploy kyverno-admission-controller --replicas=3
sleep 20
kubectl -n kyverno get pods -l app.kubernetes.io/component=admission-controller

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

NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
kyverno-admission-controller   0/0     0            0           3d
NAME                ADDRESSTYPE   PORTS     ENDPOINTS   AGE
kyverno-svc-xxxxx   IPv4          <unset>   <unset>     3d
NAME                                      POLICY
kyverno-resource-validating-webhook-cfg   Fail,Ignore,Fail
...
kyverno-admission-controller-7f9c…-4kq2p   0/1   ImagePullBackOff   0   20s

Webhooks registriert, kein Endpoint, neues Image existiert nicht. Skalieren allein heilt nichts.

Lösung: Erst Notausgang, dann Ursache, dann Beweis.

kubectl -n shop run priv --image=nginxinc/nginx-unprivileged:1.31-alpine \
  --privileged --dry-run=server -o name 2>&1 | tail -1
kubectl delete validatingwebhookconfiguration,mutatingwebhookconfiguration \
  -l webhook.kyverno.io/managed-by=kyverno
kubectl -n shop rollout restart deploy frontend
kubectl -n kyverno rollout undo deploy kyverno-admission-controller
kubectl -n kyverno rollout status deploy kyverno-admission-controller --timeout=180s
sleep 15
kubectl get validatingwebhookconfigurations -l webhook.kyverno.io/managed-by=kyverno \
  --no-headers | wc -l
kubectl -n shop run x -l app=x --image=nginxinc/nginx-unprivileged:latest \
  --dry-run=server -o name 2>&1 | sed 's/.*denied the request: //'

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

The pods "priv" is invalid: : ValidatingAdmissionPolicy 'no-privileged' with binding
'no-privileged-binding' denied request: Privilegierte Container sind verboten.
validatingwebhookconfiguration.admissionregistration.k8s.io "kyverno-…" deleted
...
deployment.apps/frontend restarted
deployment.apps/kyverno-admission-controller rolled back
deployment "kyverno-admission-controller" successfully rolled out
4
Policy image-hygiene failed: Fester Tag oder Digest nötig, nicht :latest:
nginxinc/nginx-unprivileged:latest

Die erste Zeile ist die gute Nachricht: Die native VAP aus Tag 12 wirkt auch ohne Kyverno. rollout undo holt das alte Image zurück, die Replikas stehen schon auf 3. Kyverno legt seine Webhooks beim Start selbst neu an.

Lessons:

  • Webhooks löschen ist der Notausgang, kein Fix. Bis Kyverno wieder läuft, gilt nur, was als VAP oder PSA im API-Server liegt. Zeitfenster im Incident-Protokoll festhalten.
  • Kyverno nie per kubectl set image ändern. Versionen nur per Helm und Git (Tag 12).
  • kube-system und kyverno sind ausgenommen. Sonst sperrt sich der Cluster beim Neustart selbst aus, und der Notausgang ist der einzige Weg.

Fortschritt speichern? Kostenlos registrieren

Drill 3: GeneratingPolicy verteilt einen Fehler

Szenario: Die Plattform „vereinfacht” tenant-onboarding: allow-same-namespace soll nur Ingress regeln. Der Rollout erreicht dank synchronize jeden Mandanten in Sekunden.

Auslöser:

sed 's/"policyTypes": dyn(\["Ingress", "Egress"\]),/"policyTypes": dyn(["Ingress"]),/' \
  policies/tenant-onboarding.yaml > tenant-onboarding-v2.yaml
kubectl apply -f tenant-onboarding-v2.yaml; sleep 20

Zeitlimit: 10 min

Symptome: Innerhalb aller Mandanten bricht der Verkehr weg, zwischen Mandanten bleibt alles dicht. Eine Reparatur von Hand hält nur Sekunden.

tenant-a/api           http://api.tenant-a                allow  ✘ deny
10 Tests: 9 ✔, 1 ✘

Diagnose-Pfad:

kubectl -n tenant-a describe netpol allow-same-namespace | grep -E 'egress|Types'
kubectl get netpol -A -l generate.kyverno.io/policy-name=tenant-onboarding \
  -o custom-columns=NS:.metadata.namespace,TYPES:.spec.policyTypes
diff policies/tenant-onboarding.yaml tenant-onboarding-v2.yaml
kyverno apply tenant-onboarding-v2.yaml \
  -r ~/guard-lab/code/kyverno-ops/tag13/tenant-d.yaml --remove-color \
  | sed -n '/allow-same-namespace/,/^---/p' | grep -A1 policyTypes

Erwartet (diff und kyverno apply live getestet, Rest gekürzt):

  Not affecting egress traffic
  Policy Types: Ingress
NS         TYPES
tenant-a   ["Ingress"]
tenant-b   ["Ingress"]
tenant-d   ["Ingress"]
36c36
<             "policyTypes": dyn(["Ingress", "Egress"]),
---
>             "policyTypes": dyn(["Ingress"]),
    policyTypes:
        - Ingress

Die egress-Regel steht noch im Objekt, wird ohne Egress in policyTypes aber ignoriert. default-deny sperrt damit auch den Verkehr im eigenen Namespace.

Lösung: Die Quelle reparieren, nicht die Kopien.

kubectl -n tenant-a patch netpol allow-same-namespace --type merge \
  -p '{"spec":{"policyTypes":["Ingress","Egress"]}}'; sleep 10
kubectl -n tenant-a get netpol allow-same-namespace -o jsonpath='{.spec.policyTypes}'
echo
kubectl apply -f policies/tenant-onboarding.yaml; sleep 20
$M wettkampf.tsv | tail -1

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

networkpolicy.networking.k8s.io/allow-same-namespace patched
["Ingress"]
generatingpolicy.policies.kyverno.io/tenant-onboarding configured
10 Tests: 10 ✔, 0 ✘

Der Hotfix im Namespace wird zurückgedreht (Tag 9, Drill 4). Erst die korrigierte Policy verteilt sich wieder überall.

Lessons:

  • synchronize verteilt Fehler genauso schnell wie Korrekturen. Generierte Policies brauchen dieselben Tests wie handgeschriebene: kyverno apply gegen einen Beispiel-Namespace zeigt das Ergebnis vor dem Merge.
  • Im Incident immer die Policy im Git fixen. Hand-Patches an generierten Objekten sind verlorene Minuten.
  • Ein Matrix-Fall „innerhalb des Mandanten erlaubt” gehört in jede Soll-Matrix, nicht nur die Verbote.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Unsigniertes Hotfix-Image im Incident

Szenario: Produktionsfehler im Shop. Der Hotfix ist gebaut, aber der Signierschritt der CI ist ausgefallen. verify-shop-images (Tag 10) lässt das Image nicht durch. Der Incident-Manager will den Hotfix in 10 Minuten live sehen.

Auslöser:

crane copy --insecure localhost:5001/shop/web:1.31 localhost:5001/shop/hotfix:1.31 \
  2>/dev/null
kubectl -n shop create deploy hotfix --image=kind-registry:5000/shop/hotfix:1.31 \
  --dry-run=client -o yaml \
  | kubectl set resources --local -f - --requests=cpu=10m,memory=16Mi \
    --limits=memory=64Mi -o yaml > hotfix.yaml
kubectl apply -f hotfix.yaml

Zeitlimit: 10 min

Symptome:

Error from server: error when creating "hotfix.yaml": admission webhook "…" denied the
request: Policy verify-shop-images failed: Image ist nicht mit dem Lab-Key signiert.

Diagnose-Pfad:

kubectl -n kyverno logs deploy/kyverno-admission-controller --since=5m \
  | grep -oE 'no signatures found|x509: [a-z ]+' | sort | uniq -c
crane ls --insecure localhost:5001/shop/hotfix
kubectl get ivpol verify-shop-images -o jsonpath='{.spec.matchImageReferences}'
echo

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

      1 no signatures found
1.31
[{"glob":"kind-registry:5000/shop/*"}]

no signatures found heißt: Policy richtig, Image wirklich unsigniert. Steht dort x509: certificate signed by unknown authority, fehlt Kyverno die Lab-CA (Drill 0), und jedes Image scheitert. Das wäre ein anderer Incident.

Lösung: Eine Ausnahme, so eng und so kurz wie möglich, mit Ticket. Danach nachsignieren und die Ausnahme sofort wieder entfernen.

BIS=$(date -u -v+24H +%Y-%m-%dT%H:%M:%SZ)   # Linux: date -u -d '+24 hours' +%FT%TZ
cat > hotfix-exception.yaml <<EOF
# Tag 14: Notfall-Ausnahme - unsigniertes Hotfix-Image, 24 h, Ticket Pflicht
apiVersion: policies.kyverno.io/v1
kind: PolicyException
metadata:
  name: hotfix-web-unsigned
  namespace: policy-exceptions
spec:
  policyRefs:
  - name: verify-shop-images
    kind: ImageValidatingPolicy
  matchConditions:
  - name: nur-shop-hotfix
    expression: >-
      object.metadata.namespace == 'shop' &&
      object.metadata.?labels[?'app'].orValue('') == 'hotfix'
  expiresAt: "$BIS"
  properties:
    ticket: INC-0815
    owner: team-shop
    reason: Hotfix ohne Signatur, CI-Signierschritt ausgefallen
EOF
kyverno apply ~/guard-lab/tag11/policy-repo/policies/exception-governance.yaml \
  -r hotfix-exception.yaml --remove-color | tail -1
kubectl apply -f hotfix-exception.yaml
kubectl apply -f hotfix.yaml
kubectl -n shop rollout status deploy hotfix --timeout=90s

Erwartet (erste Zeile live getestet, Rest gekürzt, nicht live getestet):

pass: 1, fail: 0, warn: 0, error: 0, skip: 0
policyexception.policies.kyverno.io/hotfix-web-unsigned created
deployment.apps/hotfix created
deployment "hotfix" successfully rolled out

Nach dem Incident holst du die Signatur nach (Schlüssel und offline.json aus Tag 10) und beweist, dass es ohne Ausnahme geht:

cd ~/guard-lab/tag10
D=$(crane digest --insecure localhost:5001/shop/hotfix:1.31)
cosign sign --registry-cacert certs/registry.crt --key cosign.key \
  --signing-config offline.json -y "localhost:5001/shop/hotfix@$D"
cosign attest --registry-cacert certs/registry.crt --key cosign.key \
  --signing-config offline.json -y --type spdxjson --predicate sbom.spdx.json \
  "localhost:5001/shop/hotfix@$D"
cd ~/guard-lab/tag14
kubectl -n policy-exceptions delete policyexceptions.policies.kyverno.io \
  hotfix-web-unsigned
kubectl -n shop rollout restart deploy hotfix
kubectl -n shop rollout status deploy hotfix --timeout=90s

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

policyexception.policies.kyverno.io "hotfix-web-unsigned" deleted
deployment.apps/hotfix restarted
deployment "hotfix" successfully rolled out

Warum auch die SBOM? verify-shop-images prüft Signatur und SPDX-Attestation (Tag 10). Die SBOM aus Tag 10 passt, denn der Digest ist derselbe.

Lessons:

  • Eine Ausnahme ist im Incident das richtige Werkzeug, die Policy abschalten nie. exception-governance (Tag 11) erzwingt Ticket, Owner und Ablauf.
  • Eng schneiden: eine Policy, ein Namespace, ein Label. expiresAt in Stunden, nicht in Monaten. Den Rest räumt delete-expired-exceptions auf (Tag 12).
  • Prüfe zuerst die Kyverno-Logs: Signatur fehlt, Schlüssel falsch, CA fehlt oder Registry weg sind vier verschiedene Incidents mit derselben Meldung an den Client.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Label-Drift öffnet die Mandantengrenze

Szenario: Ein Team legt tenant-e an und kopiert dafür das Manifest des monitoring-Namespace. Niemand merkt etwas, bis ein Pentest Metriken anderer Mandanten aus tenant-e abruft.

Auslöser:

cat > tenant-e.yaml <<'EOF'
apiVersion: v1
kind: Namespace
metadata:
  name: tenant-e
  labels: {guard-lab: demo, team: platform, purpose: monitoring}   # kopiert
EOF
kubectl apply -f tenant-e.yaml
sed 's/namespace: default/namespace: tenant-e/' ~/guard-lab/code/demo/40-client.yaml \
  | kubectl apply -f -
kubectl -n tenant-e wait --for=condition=Ready pod/client --timeout=60s

Zeitlimit: 10 min

Symptome:

$ cc tenant-e/client http://api.tenant-a:9113/metrics deny
✔ erlaubt   tenant-e/client -> http://api.tenant-a:9113/metrics (HTTP 200)
  <-- erwartet: deny

Diagnose-Pfad:

kubectl get ns tenant-e --show-labels
kubectl get netpol -n tenant-e
kubectl -n tenant-a describe netpol allow-monitoring | sed -n '/Allowing/,/Not/p'
kubectl get ns -l purpose=monitoring

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

NAME       STATUS   AGE   LABELS
tenant-e   Active   2m    guard-lab=demo,kubernetes.io/metadata.name=tenant-e,…
No resources found in tenant-e namespace.
  Allowing ingress traffic:
    To Port: 9113/TCP
    From:
      NamespaceSelector: purpose=monitoring
NAME         STATUS   AGE
monitoring   Active   5d
tenant-e     Active   2m

Zwei Fehler greifen ineinander: Ohne Label tenant hat tenant-e kein Default Deny (Egress offen). Und mit purpose=monitoring gilt es in jedem Mandanten als Monitoring (Tag 3, Drill 6: Labels als Vertrag).

Lösung: Erst die Labels richtig, dann die Vorlage härten, damit ein falsches Label allein nie wieder reicht.

kubectl label ns tenant-e purpose- team=tenant-e tenant=e --overwrite
kubectl -n netpol-templates patch netpol allow-monitoring --type json -p '[{"op":
  "replace","path":"/spec/ingress/0/from","value":[{"namespaceSelector":{
  "matchLabels":{"kubernetes.io/metadata.name":"monitoring"}},
  "podSelector":{"matchLabels":{"app":"scraper"}}}]}]'
sleep 20
kubectl get netpol -n tenant-e
cc tenant-e/client http://api.tenant-a:9113/metrics deny
$M wettkampf.tsv | tail -1

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

namespace/tenant-e labeled
networkpolicy.networking.k8s.io/allow-monitoring patched
NAME                   POD-SELECTOR   AGE
allow-dns              <none>         15s
allow-monitoring       tier=api       15s
allow-same-namespace   <none>         15s
default-deny           <none>         15s
✘ blockiert tenant-e/client -> http://api.tenant-a:9113/metrics (Timeout)
10 Tests: 10 ✔, 0 ✘

Das Label tenant löst Generierung aus, die geänderte Vorlage synchronisiert sich in alle Mandanten (Tag 9, Drill 6). Die neue Quelle ist UND aus kubernetes.io/metadata.name und app=scraper, das kann kein Team fälschen.

Lessons:

  • Kopierte Manifeste kopieren Berechtigungen mit. Selbst gesetzte Labels wie purpose sind nur so sicher wie die Regel, die sie schützt (Challenge).
  • Fremde Namespaces immer über kubernetes.io/metadata.name selektieren (Tag 3).
  • Kein Default Deny ist kein Fehler, den eine Policy meldet. require-default-deny (Tag 13) prüft nur Namespaces mit tenant. Fehlt das Label, fehlt auch die Prüfung.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Rollout sperrt das Monitoring aus

Szenario: Die Plattform will Quota und Pod Security „auch für monitoring” und hängt dem Namespace das Mandanten-Label an. Kurz danach feuern alle Alarme TargetDown.

Auslöser:

kubectl label ns monitoring tenant=platform
sleep 20

Zeitlimit: 10 min

Symptome:

$ kubectl -n monitoring logs deploy/scraper --tail=3
FAIL shop
FAIL tenant-a
FAIL tenant-b

Diagnose-Pfad:

$M wettkampf.tsv | grep '✘'
kubectl get netpol,resourcequota,rolebinding -n monitoring \
  -L generate.kyverno.io/policy-name
kubectl get ns monitoring -o json | jq -c .metadata.labels

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

monitoring/scraper     http://api.tenant-a:9113/metrics   allow  ✘ deny
monitoring/scraper     http://api.tenant-b:9113/metrics   allow  ✘ deny
NAME                                           …   POLICY-NAME
networkpolicy…/allow-dns                       …   tenant-netpol
networkpolicy…/allow-monitoring                …   clone-monitoring
networkpolicy…/allow-same-namespace            …   tenant-onboarding
networkpolicy…/default-deny                    …   tenant-netpol
resourcequota/tenant-quota                     …   tenant-onboarding
rolebinding…/team-edit                         …   tenant-onboarding
{"guard-lab":"demo",…,"pod-security.kubernetes.io/enforce":"restricted",…,
"tenant":"platform"}

Ein Label, sechs Objekte und drei PSA-Labels. default-deny sperrt den Egress des Scrapers, team-edit gibt der Gruppe platform ganz nebenbei edit im Namespace.

Lösung: Label entfernen reicht nicht. Generierte Objekte und Mutationen bleiben stehen (Tag 9, Drill 7), du räumst sie gezielt ab:

kubectl label ns monitoring tenant- pod-security.kubernetes.io/enforce- \
  pod-security.kubernetes.io/enforce-version- pod-security.kubernetes.io/warn-
P=tenant-netpol,tenant-onboarding,clone-monitoring
kubectl -n monitoring delete netpol,resourcequota,rolebinding \
  -l "generate.kyverno.io/policy-name in ($P)"
sleep 15
kubectl -n monitoring logs deploy/scraper --tail=3
$M wettkampf.tsv | tail -1

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

namespace/monitoring unlabeled
networkpolicy.networking.k8s.io "allow-dns" deleted from monitoring namespace
...
rolebinding.rbac.authorization.k8s.io "team-edit" deleted from monitoring namespace
ok   shop
ok   tenant-a
ok   tenant-b
10 Tests: 10 ✔, 0 ✘

Kommen die Objekte nach dem Löschen zurück, matcht der Namespace noch eine GeneratingPolicy: Labels erneut prüfen.

Lessons:

  • Ein Trigger-Label ist ein Rollout-Schalter für alles, was daran hängt: Netz, Quota, RBAC, PSA. Vor dem Setzen kyverno apply gegen den Namespace laufen lassen (Tag 13, Drill 5) und die Liste lesen.
  • Plattform-Namespaces sind keine Mandanten. Will das Monitoring Default Deny, bekommt es eigene Policies mit Egress zu allen Scrape-Zielen.
  • Der Scraper-Log ist der schnellste Sensor im Lab, in Produktion up == 0 pro Target.

Fortschritt speichern? Kostenlos registrieren

Drill 7: CI grün, Cluster rot

Szenario: Ein Pull Request stellt no-world-egress auf das neue Label-Schema tenant-tier um. kyverno test ist grün, Review durch, Merge, Rollout. Eine Woche später findet das Audit 0.0.0.0/0 in drei Mandanten.

Auslöser:

ALT='- {key: tenant, operator: Exists}'
NEU='- {key: tenant-tier, operator: In, values: [standard]}'
sed -i.bak "s/$ALT/$NEU/" policies/no-world-egress.yaml
kyverno test tests/no-world-egress --remove-color | grep Summary   # das war die CI
kubectl apply -f policies/no-world-egress.yaml

Zeitlimit: 10 min

Symptome:

Test Summary: 4 tests passed and 0 tests failed
$ kubectl apply --dry-run=server -f tests/no-world-egress/netpols.yaml
networkpolicy.networking.k8s.io/api-to-db created (server dry run)
networkpolicy.networking.k8s.io/internet created (server dry run)
networkpolicy.networking.k8s.io/alles-raus created (server dry run)
...

Diagnose-Pfad:

kyverno test tests/no-world-egress --remove-color \
  | awk -F'│' '/│ [0-9]/ {print $5, $6, $7}'
kyverno apply policies/no-world-egress.yaml -r tests/no-world-egress/netpols.yaml \
  -f tests/no-world-egress/values.yaml --remove-color | tail -1
kubectl get ns -l tenant-tier

Erwartet (die ersten fünf Zeilen live getestet, gekürzt):

 networking.k8s.io/v1/NetworkPolicy/tenant-a/api-to-db      Pass   Excluded
 networking.k8s.io/v1/NetworkPolicy/tenant-a/dns-ueberall   Pass   Excluded
 networking.k8s.io/v1/NetworkPolicy/tenant-a/internet       Pass   Excluded
 networking.k8s.io/v1/NetworkPolicy/tenant-a/alles-raus     Pass   Excluded
pass: 0, fail: 0, warn: 0, error: 0, skip: 0
No resources found

Die Falle aus Tag 11, Drill 3: Excluded zählt als bestanden, auch wenn du fail erwartest. Der neue Selector trifft weder im Test (values.yaml kennt tenant-tier nicht) noch im Cluster (kein Namespace trägt es) irgendetwas.

Lösung: Zurückrollen, dann die CI so schärfen, dass ein Test ohne Treffer rot wird.

mv policies/no-world-egress.yaml.bak policies/no-world-egress.yaml
kubectl apply -f policies/no-world-egress.yaml
cat > hit-guard.sh <<'EOF'
#!/usr/bin/env bash
# hit-guard.sh - jeder Test-Ordner muss mindestens ein Objekt wirklich prüfen
#
#   hit-guard.sh <test-ordner>...
#
# Exit 0 = jeder Ordner hat ein Ergebnis mit REASON "Ok", 1 = nur Excluded/Skip.
set -uo pipefail
rc=0
for d in "$@"; do
  out=$(kyverno test "$d" --remove-color 2>&1)
  if grep -Eq '│ (Pass|Fail) +│ Ok ' <<<"$out"; then
    echo "✔ $d prüft echte Objekte"
  else
    echo "✘ $d: kein Objekt geprüft (nur Excluded?)"
    rc=1
  fi
done
exit $rc
EOF
chmod +x hit-guard.sh
./hit-guard.sh tests/*/

Erwartet (live getestet):

✔ tests/no-world-egress/ prüft echte Objekte
✔ tests/require-default-deny/ prüft echte Objekte

Mit der kaputten Fassung meldet das Skript ✘ tests/no-world-egress/: kein Objekt geprüft (nur Excluded?) und Exit 1. Gehört als zweiter Schritt hinter kyverno test in die Pipeline aus Tag 11.

Lessons:

  • Grün heißt nur „Erwartung erfüllt”. Ein Test, der nichts prüft, ist immer grün.
  • values.yaml ist eine Kopie der Cluster-Labels und veraltet still. Erzeuge sie aus dem Cluster (kubectl get ns -o json | jq …) oder prüfe sie gegen ihn.
  • Label-Umbauten zuerst im Cluster (Namespaces labeln), dann die Policies umstellen. Nie umgekehrt.

Fortschritt speichern? Kostenlos registrieren

Drill 8: toFQDNs nach CDN-Wechsel

Szenario: Ein Kollege hat letzte Woche client-fqdn (Tag 4) „entschlackt”: IPs aus dig statt Domains, weil „der DNS-Proxy ein Single Point of Failure ist”. Heute hat das CDN von example.com die Adressen gewechselt.

Dieser Drill läuft auf cilium-lab. Bau ihn wie in Tag 4, Drill 1–2, mit Demo-App (zählt nicht zur Zeit). Mit 8 GB RAM für Docker laufen beide Cluster single-node nebeneinander, sonst erst den Kontrollpunkt für kyverno-lab, dann löschen.

kubectl config use-context kind-cilium-lab
kubectl apply -f ~/guard-lab/code/cilium/client-fqdn.yaml
TIMEOUT=5 cc default/client https://example.com allow

Auslöser:

cat > client-fqdn-pinned.yaml <<'EOF'
apiVersion: cilium.io/v2
kind: CiliumNetworkPolicy
metadata:
  name: client-fqdn            # gleicher Name: ersetzt die Policy aus Tag 4
  namespace: default
spec:
  endpointSelector:
    matchLabels:
      app: client
  egress:
  - toEndpoints:
    - matchLabels:
        k8s:io.kubernetes.pod.namespace: kube-system
        k8s-app: kube-dns
    toPorts:
    - ports:
      - port: "53"
        protocol: ANY
  - toCIDR:
    - 192.0.2.80/32            # "IP von letzter Woche" (Doku-Netz, simuliert)
    toPorts:
    - ports:
      - port: "443"
        protocol: TCP
EOF
kubectl apply -f client-fqdn-pinned.yaml

Zeitlimit: 10 min

Symptome:

✘ blockiert default/client -> https://example.com (Timeout)
✘ blockiert default/client -> https://api.github.com (Timeout)

Diagnose-Pfad:

kubectl exec client -- nslookup example.com | grep -A1 '^Name'
hubble observe -P --from-pod default/client --verdict DROPPED --last 3
kubectl get cnp client-fqdn -o yaml | yq '.spec.egress[] | keys'

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

Name:   example.com
Address: 23.192.228.84
... default/client:40112 (ID:23412) -> 23.192.228.84:443 (world) Policy denied
  DROPPED (TCP Flags: SYN)
- toEndpoints
- toPorts
- toCIDR
- toPorts

DNS geht, die Verbindung zur aktuellen IP wird verworfen. Die Policy kennt nur noch eine IP, die nicht mehr stimmt.

Lösung, Runde 1: zurück zu Domains. Erst ein halber Fix, wie er im Stress passiert: toFQDNs wieder rein, die DNS-Regel bleibt reines L4.

yq 'del(.spec.egress[0].toPorts[0].rules)' ~/guard-lab/code/cilium/client-fqdn.yaml \
  | kubectl apply -f -
TIMEOUT=5 cc default/client https://docs.github.com
kubectl -n kube-system exec ds/cilium -c cilium-agent -- \
  cilium-dbg fqdn cache list | grep -c docs.github

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

ciliumnetworkpolicy.cilium.io/client-fqdn configured
✘ blockiert default/client -> https://docs.github.com (Timeout)
0

docs.github.com passt auf *.github.com, landet aber nie im FQDN-Cache: Ohne rules.dns läuft DNS am Proxy vorbei, Cilium lernt keine IPs (Tag 4, Drill 6). Schon bekannte Namen funktionieren noch, bis ihre Cache-Einträge ablaufen. Das macht den Fehler tückisch.

Lösung, Runde 2: die Originaldatei aus dem Git.

kubectl apply -f ~/guard-lab/code/cilium/client-fqdn.yaml
TIMEOUT=5 cc default/client https://docs.github.com allow
TIMEOUT=5 cc default/client https://example.com allow
TIMEOUT=5 cc default/client https://kubernetes.io deny

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

ciliumnetworkpolicy.cilium.io/client-fqdn configured
✔ erlaubt   default/client -> https://docs.github.com (HTTP 200)
✔ erlaubt   default/client -> https://example.com (HTTP 200)
✘ blockiert default/client -> https://kubernetes.io (Timeout)

Lessons:

  • CDN- und SaaS-IPs wechseln ohne Ankündigung. toCIDR nur für Netze, die dir oder dem Partner vertraglich gehören.
  • toFQDNs braucht immer eine DNS-Regel mit rules.dns zu kube-dns. Ein Test mit einem neuen Namen beweist das, ein bekannter Name nicht.
  • Der DNS-Proxy ist tatsächlich im Datenpfad. Die Antwort darauf ist Monitoring und Kapazität (Enterprise-Notiz), nicht das Abschalten.

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 Egress-Härtung ohne DNS 5 min 10
2 Kyverno weg, failurePolicy Fail 10 min 15
3 GeneratingPolicy verteilt einen Fehler 10 min 15
4 Unsigniertes Hotfix-Image 10 min 15
5 Label-Drift zwischen Mandanten 10 min 10
6 Monitoring ausgesperrt 10 min 10
7 CI grün, Cluster rot 10 min 15
8 toFQDNs nach CDN-Wechsel 10 min 10
Summe 75 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.

#!/usr/bin/env bash
cd ~/guard-lab/tag14 || exit 1
ok() { echo "✔ $1"; }; nok() { echo "✘ $1"; }
CC=~/guard-lab/code/demo/conncheck.sh; M=~/guard-lab/code/np-tests/np-matrix.sh
kubectl config use-context kind-kyverno-lab >/dev/null
CC=$CC $M wettkampf.tsv >/dev/null && ok "Wettkampf-Matrix grün" \
  || nok "Wettkampf-Matrix rot"
D=deploy/kyverno-admission-controller
img=$(kubectl -n kyverno get $D -o jsonpath='{.spec.template.spec.containers[0].image}')
[[ $img == *:v1.19.1 ]] && ok "Kyverno-Image v1.19.1" || nok "Kyverno-Image: $img"
r=$(kubectl -n kyverno get $D -o jsonpath='{.status.readyReplicas}')
[ "${r:-0}" -ge 3 ] && ok "Admission 3 Replikas" || nok "Admission: ${r:-0} Replikas"
kubectl -n shop run t -l app=t --image=nginxinc/nginx-unprivileged:latest \
  --dry-run=server >/dev/null 2>&1 \
  && nok ":latest kommt durch" || ok ":latest abgelehnt"
kubectl -n shop get netpol allow-dns >/dev/null 2>&1 \
  && ok "shop hat allow-dns" || nok "shop ohne allow-dns"
[ "$(kubectl get ns -l purpose=monitoring -o name)" = namespace/monitoring ] \
  && ok "purpose nur an monitoring" || nok "purpose an fremden Namespaces"
kubectl get ns monitoring -o jsonpath='{.metadata.labels.tenant}' | grep -q . \
  && nok "monitoring ist noch Mandant" || ok "monitoring ist kein Mandant"
k=$(kubectl get vpol no-world-egress \
  -o jsonpath='{.spec.matchConstraints.namespaceSelector.matchExpressions[0].key}')
[ "$k" = tenant ] && ok "no-world-egress trifft Mandanten" || nok "Selector: $k"
./hit-guard.sh tests/*/ >/dev/null && ok "hit-guard grün" || nok "hit-guard rot"
kubectl -n policy-exceptions get policyexceptions.policies.kyverno.io \
  hotfix-web-unsigned >/dev/null 2>&1 \
  && nok "Hotfix-Ausnahme noch da" || ok "Hotfix-Ausnahme entfernt"
if kubectl config get-contexts kind-cilium-lab >/dev/null 2>&1; then
  kubectl config use-context kind-cilium-lab >/dev/null
  for u in https://example.com https://docs.github.com; do
    TIMEOUT=5 $CC default/client "$u" allow >/dev/null \
      && ok "cilium: client -> $u" || nok "cilium: client -> $u"
  done
fi

Challenge

Verhindere Drill 5 und 6 per Admission: Eine ValidatingPolicy protect-ns-labels erlaubt das Label purpose nur am Namespace monitoring, und jeder Namespace mit Präfix tenant- braucht das Label tenant. Teste offline gegen vier Namespaces.

Hinweis: startsWith() und der in-Operator auf die Label-Map reichen; hol die Labels einmal per .?labels.orValue({}) in eine Variable.

Lösung

cd ~/guard-lab/tag14
cat > protect-ns-labels.yaml <<'EOF'
# Tag 14: Plattform-Labels an Namespaces schützen (Label-Drift verhindern)
apiVersion: policies.kyverno.io/v1
kind: ValidatingPolicy
metadata:
  name: protect-ns-labels
spec:
  validationActions: [Deny]
  matchConstraints:
    resourceRules:
    - apiGroups: [""]
      apiVersions: [v1]
      operations: [CREATE, UPDATE]
      resources: [namespaces]
  variables:
  - name: name
    expression: object.metadata.name
  - name: labels
    expression: object.metadata.?labels.orValue({})
  validations:
  - expression: >-
      !('purpose' in variables.labels) || variables.name == 'monitoring'
    messageExpression: >-
      'Namespace ' + variables.name + ': Label purpose ist reserviert (nur monitoring)'
  - expression: >-
      !variables.name.startsWith('tenant-') || 'tenant' in variables.labels
    messageExpression: >-
      'Namespace ' + variables.name + ': Mandanten-Namespaces brauchen das Label tenant'
EOF
cat > drift-ns.yaml <<'EOF'
apiVersion: v1
kind: Namespace
metadata:
  name: tenant-e
  labels: {guard-lab: demo, team: platform, purpose: monitoring}
---
apiVersion: v1
kind: Namespace
metadata:
  name: tenant-f
  labels: {guard-lab: demo, team: tenant-f, tenent: f}
---
apiVersion: v1
kind: Namespace
metadata:
  name: tenant-g
  labels: {guard-lab: demo, team: tenant-g, tenant: g}
---
apiVersion: v1
kind: Namespace
metadata:
  name: monitoring
  labels: {guard-lab: demo, team: platform, purpose: monitoring}
EOF
kyverno apply protect-ns-labels.yaml -r drift-ns.yaml --remove-color

Erwartet (live getestet):

Applying 1 policy rule(s) to 4 resource(s)...
policy protect-ns-labels -> resource /Namespace/tenant-e failed:
1 -  Namespace tenant-e: Label purpose ist reserviert (nur monitoring)
policy protect-ns-labels -> resource /Namespace/tenant-f failed:
1 -  Namespace tenant-f: Mandanten-Namespaces brauchen das Label tenant

pass: 2, fail: 2, warn: 0, error: 0, skip: 0

tenant-e verletzt beide Regeln, gemeldet wird nur die erste (Tag 8, Drill 2). Der Tippfehler tenent in tenant-f fällt auf, monitoring und tenant-g bestehen. Drill 6 verhindert die Policy nicht: monitoring heißt nicht tenant-…. Dafür brauchst du eine dritte Regel, etwa „tenant nie an Namespaces mit purpose“.

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.
  • Für jeden Drill ein Runbook mit Notausgang: Webhooks löschen, Ausnahme anlegen, Policy zurückrollen. Die Rechte dafür liegen bei einer Break-Glass-Gruppe, nicht bei allen.
  • Alarme, die diese Störungen früh zeigen: Hubble-Drops mit policy-verdict:none, kyverno_admission_requests_total{request_allowed="false"}, up == 0 pro Target, fehlende Kyverno-Endpoints, wachsende DNS-Proxy-Latenz.
  • Trigger-Labels (tenant, purpose) und GeneratingPolicies laufen durch Change-Review wie Code. Vorher kyverno apply gegen echte Namespaces, nachher die Soll-Matrix.
  • Jeder Incident endet mit einem neuen Test: Matrix-Zeile, kyverno test-Fall oder Chainsaw-Schritt. Sonst kommt derselbe Fehler wieder.