Zum Inhalt springen
Trainingslager IT-Trainingslager

Anhang B: Abschlussprüfung

Ziel: Nachweisen, dass du einen Mandanten allein sicher onboardest, absicherst, testest und im Störfall reparierst · Dauer: 150 min Praxis + 25 min Fragen · Voraussetzung: Tag 14

Regeln

  • Cluster kyverno-lab im Zustand nach dem Kontrollpunkt von Tag 14 (alles ✔). Kyverno 1.19.1, Kyverno-CLI 1.19.1, conncheck.sh, np-matrix.sh, hit-guard.sh.
  • Erlaubt: --help, kubectl explain, Anhang A, kyverno.io und kubernetes.io. Nicht erlaubt: fertige Lösungen aus den Kapiteln kopieren. Tippen, nicht kopieren.
  • Alle Dateien liegen in ~/guard-lab/pruefung. Das Prüfskript am Ende vergibt die Punkte, nicht dein Gefühl.
  • Bestanden: mindestens 70 von 100 Punkten und Aufgabe 8 voll gelöst.
mkdir -p ~/guard-lab/pruefung/{policies,tests,exceptions} && cd ~/guard-lab/pruefung
kubectl config use-context kind-kyverno-lab
alias cc=~/guard-lab/code/demo/conncheck.sh

Teil 1: Praktische Prüfung

Aufgabe 1: Mandant onboarden (10 Punkte)

Lege den Namespace tenant-x für das Team tenant-x so an, dass Kyverno ihm das komplette Mandanten-Paket gibt (Tag 9, Tag 13). Kein kubectl create netpol von Hand.

kubectl -n tenant-x get netpol -o name
kubectl get ns tenant-x \
  -o jsonpath='{.metadata.labels.pod-security\.kubernetes\.io/enforce}'; echo

Erwartet:

networkpolicy.networking.k8s.io/allow-dns
networkpolicy.networking.k8s.io/allow-monitoring
networkpolicy.networking.k8s.io/allow-same-namespace
networkpolicy.networking.k8s.io/default-deny
restricted

Aufgabe 2: Workload ausrollen (10 Punkte)

Bring die api aus ~/guard-lab/code/kyverno-ops/tag13/gitops/tenants/tenant-d/ nach tenant-x, ohne die Datei im Code-Ordner zu ändern. Sie muss alle aktiven Policies erfüllen (Image, Ressourcen, PSA, Quota).

kubectl -n tenant-x rollout status deploy api --timeout=60s

Erwartet:

deployment "api" successfully rolled out

Aufgabe 3: Zwei Seiten einer Verbindung (15 Punkte)

shop/frontend darf tenant-x/api auf dem Named Port http aufrufen, sonst niemand. Die Ingress-Policy in tenant-x heißt api-from-frontend und hat genau eine ingress-Regel mit genau einem Port. Denk an den Egress von shop (Tag 14, Drill 1).

cc shop/frontend http://api.tenant-x allow
cc default/client http://api.tenant-x deny
cc tenant-a/api http://api.tenant-x deny

Erwartet (Gründe gekürzt):

✔ erlaubt   shop/frontend -> http://api.tenant-x (HTTP 200)
✘ blockiert default/client -> http://api.tenant-x (Timeout)
✘ blockiert tenant-a/api -> http://api.tenant-x (Timeout)

Aufgabe 4: Soll-Matrix (10 Punkte)

Schreib pruefung.tsv mit mindestens 8 Zeilen, davon mindestens 4 deny. Decke tenant-x als Quelle und als Ziel ab, dazu den Scraper (Port 9113 erlaubt, 8080 nicht).

~/guard-lab/code/np-tests/np-matrix.sh pruefung.tsv | tail -1

Erwartet (bei 8 Zeilen):

8 Tests: 8 ✔, 0 ✘

Aufgabe 5: Policy mit Tests (15 Punkte)

ValidatingPolicy tenant-no-external-svc: In Namespaces mit Label tenant sind Services vom Typ NodePort und LoadBalancer verboten (Deny). Die Meldung nennt Service und Typ. Dazu ein Test unter tests/no-external-svc/ mit mindestens einem pass und zwei fail, der den Hit-Guard aus Tag 14 besteht.

kyverno test tests --remove-color | grep Summary
~/guard-lab/tag14/hit-guard.sh tests/*/
kubectl -n tenant-x create service nodeport probe --tcp=80:8080 --dry-run=server \
  2>&1 | sed 's/.*denied the request: //'

Erwartet (erste zwei Zeilen live getestet mit der Lösungsskizze):

Test Summary: 3 tests passed and 0 tests failed
✔ tests/no-external-svc/ prüft echte Objekte
Policy tenant-no-external-svc failed: Service probe: Typ NodePort ist für Mandanten
verboten (Ingress/Gateway nutzen)

Aufgabe 6: Befristete Ausnahme (10 Punkte)

Das Team braucht für einen Partner-Test sieben Tage lang einen LoadBalancer edge in tenant-x. PolicyException edge-lb: nur dieser eine Service, Ablauf in höchstens 7 Tagen, mit Ticket und Owner (sonst greift exception-governance).

kubectl -n tenant-x create service loadbalancer edge --tcp=80:8080 \
  --dry-run=server -o name
kubectl -n tenant-x create service loadbalancer other --tcp=80:8080 \
  --dry-run=server -o name 2>&1 | grep -o 'für Mandanten verboten'

Erwartet:

service/edge
für Mandanten verboten

Aufgabe 7: Leitplanke ohne Webhook (10 Punkte)

ValidatingPolicy no-hostnetwork: Pods mit hostNetwork: true sind in allen Namespaces mit guard-lab=demo verboten, und zwar auch dann, wenn Kyverno ausfällt (Tag 12).

kubectl get validatingadmissionpolicy no-hostnetwork -o name
kubectl -n shop run hn --image=curlimages/curl:8.22.0 --dry-run=server \
  --overrides='{"spec":{"hostNetwork":true}}' 2>&1 \
  | grep -o "ValidatingAdmissionPolicy 'no-hostnetwork'"

Erwartet:

validatingadmissionpolicy.admissionregistration.k8s.io/no-hostnetwork
ValidatingAdmissionPolicy 'no-hostnetwork'

Aufgabe 8: Störung beheben (20 Punkte, Pflicht)

Erst wenn Aufgabe 3 grün ist: Führe den Block aus, ohne ihn zu entschlüsseln. Er baut genau eine Störung ein. Finde und behebe sie in höchstens 15 Minuten, ohne api-from-frontend zu löschen.

B=a3ViZWN0bCAtbiB0ZW5hbnQteCBwYXRjaCBuZXRwb2wgYXBpLWZyb20tZnJvbnRlbmQgLS10eXBl
B=${B}IGpzb24gLXAgJ1t7Im9wIjoicmVwbGFjZSIsInBhdGgiOiIvc3BlYy9pbmdyZXNzLzAvcG9y
B=${B}dHMvMC9wb3J0IiwidmFsdWUiOjgwfV0nID4vZGV2L251bGwgJiYgZWNobyAnU3TDtnJ1bmcg
B=${B}YWt0aXYnCg==
echo "$B" | base64 -d | sh

Erwartet:

Störung aktiv

Danach muss cc shop/frontend http://api.tenant-x allow wieder ✔ zeigen. Schreib Ursache und Fix in einem Satz in stoerung.txt.

Punkte

Aufgabe Punkte erreicht
1 Mandant onboarden 10
2 Workload ausrollen 10
3 Zwei Seiten einer Verbindung 15
4 Soll-Matrix 10
5 Policy mit Tests 15
6 Befristete Ausnahme 10
7 Leitplanke ohne Webhook 10
8 Störung beheben (Pflicht) 20
Summe 100

Prüfskript

cat > ~/guard-lab/pruefung/pruefung-check.sh <<'EOF'
#!/usr/bin/env bash
# pruefung-check.sh - wertet die praktische Abschlussprüfung aus (Anhang B)
cd ~/guard-lab/pruefung || exit 2
CC=~/guard-lab/code/demo/conncheck.sh
M=~/guard-lab/code/np-tests/np-matrix.sh
G=~/guard-lab/tag14/hit-guard.sh
sum=0
pt() {  # pt <aufgabe> <punkte> <text> <befehl...>
  local a=$1 p=$2 t=$3; shift 3
  if "$@" >/dev/null 2>&1; then
    echo "✔ A$a $t (+$p)"; sum=$((sum + p))
  else
    echo "✘ A$a $t (0 von $p)"
  fi
}
lbl() { [ "$(kubectl get ns tenant-x -o jsonpath="{.metadata.labels.$1}")" = "$2" ]; }
np3() { for n in default-deny allow-dns allow-same-namespace; do
          kubectl -n tenant-x get netpol "$n" || return 1; done; }
ready() { [ "$(kubectl -n tenant-x get deploy api \
            -o jsonpath='{.status.readyReplicas}')" -ge 1 ]; }
tsv() { [ "$(grep -cv '^#' pruefung.tsv)" -ge 8 ] \
          && [ "$(grep -c ' deny$' pruefung.tsv)" -ge 4 ]; }
vready() { [ "$(kubectl get vpol tenant-no-external-svc \
             -o jsonpath='{.status.conditionStatus.ready}')" = true ]; }
svc() { kubectl -n tenant-x create service "$1" "$2" --tcp=80:8080 \
          --dry-run=server; }
nsvc() { ! svc "$@"; }
unit() { kyverno test tests && "$G" tests/*/; }
expiry() {
  local e now max
  e=$(kubectl -n policy-exceptions get policyexceptions.policies.kyverno.io edge-lb \
    -o jsonpath='{.spec.expiresAt}')
  now=$(date -u +%Y-%m-%dT%H:%M:%SZ)
  max=$(date -u -v+7d +%Y-%m-%dT%H:%M:%SZ 2>/dev/null \
    || date -u -d '+7 days' +%Y-%m-%dT%H:%M:%SZ)
  [[ -n $e && $e > $now && ! $e > $max ]]
}
hostnet() { kubectl -n shop run hn --image=curlimages/curl:8.22.0 --dry-run=server \
  --overrides='{"spec":{"hostNetwork":true}}' 2>&1 | grep -q 'hostNetwork ist'; }
port() { [ "$(kubectl -n tenant-x get netpol api-from-frontend \
           -o jsonpath='{.spec.ingress[0].ports[0].port}')" != 80 ]; }
pt 1 4 "tenant-x trägt tenant=x"  lbl tenant x
pt 1 3 "Baseline-Policies generiert"  np3
PSA='pod-security\.kubernetes\.io/enforce'
pt 1 3 "PSA restricted"  lbl "$PSA" restricted
pt 2 10 "api in tenant-x bereit"  ready
pt 3 5 "frontend -> api.tenant-x"  "$CC" shop/frontend http://api.tenant-x allow
pt 3 5 "client -> api.tenant-x verboten"  "$CC" default/client http://api.tenant-x deny
pt 3 5 "tenant-a -> api.tenant-x verboten"  "$CC" tenant-a/api http://api.tenant-x deny
pt 4 4 "Matrix mit >= 8 Zeilen, >= 4 deny"  tsv
pt 4 6 "Matrix grün"  "$M" pruefung.tsv
pt 5 3 "tenant-no-external-svc bereit"  vready
pt 5 4 "NodePort abgelehnt"  nsvc nodeport probe
pt 5 3 "ClusterIP erlaubt"  svc clusterip probe
pt 5 5 "kyverno test und hit-guard grün"  unit
pt 6 4 "LoadBalancer edge erlaubt"  svc loadbalancer edge
pt 6 2 "LoadBalancer other abgelehnt"  nsvc loadbalancer other
pt 6 4 "Ausnahme läuft in <= 7 Tagen ab"  expiry
pt 7 5 "VAP no-hostnetwork vorhanden"  kubectl get validatingadmissionpolicy \
                                              no-hostnetwork
pt 7 5 "hostNetwork-Pod abgelehnt (VAP)"  hostnet
pt 8 5 "Port in api-from-frontend repariert" port
pt 8 15 "Störung behoben: frontend -> api" \
  "$CC" shop/frontend http://api.tenant-x allow
echo "Summe: $sum von 100"
EOF
chmod +x ~/guard-lab/pruefung/pruefung-check.sh
~/guard-lab/pruefung/pruefung-check.sh

Erwartet bei voller Lösung (gekürzt, nicht live getestet):

✔ A1 tenant-x trägt tenant=x (+4)
✔ A1 Baseline-Policies generiert (+3)
...
✔ A8 Störung behoben: frontend -> api (+15)
Summe: 100 von 100

pt führt jeden Prüfbefehl aus und zählt nur bei Exit 0. Der Port-Test in A8 prüft ingress[0].ports[0], deshalb verlangt Aufgabe 3 genau eine Regel mit einem Port.

Lösungsskizze

Erst nach der Prüfung lesen.

  • A1: kubectl create ns tenant-x -l guard-lab=demo,team=tenant-x,tenant=x. Die GeneratingPolicies und die PSA-Mutation erledigen den Rest.
  • A2: sed 's/tenant-d/tenant-x/g' …/10-api.yaml | kubectl apply -f -.
  • A3: In tenant-x Ingress von namespaceSelector kubernetes.io/metadata.name: shop UND podSelector app: frontend auf Port http. In shop eine Egress-Policy für app: frontend zu tenant-x/app: api auf 8080.
  • A4: Zeilen wie in Tag 14, wettkampf.tsv, mit tenant-x statt tenant-a.
  • A6: policyRefs auf tenant-no-external-svc, matchConditions auf Namespace und Name, expiresAt per date -u -v+7d, properties.ticket und owner.
  • A8: Der Block setzt den Port in api-from-frontend auf 80, den Service-Port (Tag 1, Drill 3). Zurück auf http.

A5 und A7 (beide mit der Kyverno-CLI 1.19.1 geprüft):

# policies/tenant-no-external-svc.yaml (Auszug ab spec)
spec:
  validationActions: [Deny]
  matchConstraints:
    resourceRules:
    - apiGroups: [""]
      apiVersions: [v1]
      operations: [CREATE, UPDATE]
      resources: [services]
    namespaceSelector:
      matchExpressions:
      - {key: tenant, operator: Exists}
  validations:
  - expression: >-
      !(object.spec.?type.orValue('ClusterIP') in ['NodePort', 'LoadBalancer'])
    messageExpression: >-
      'Service ' + object.metadata.name + ': Typ ' + object.spec.type +
      ' ist für Mandanten verboten (Ingress/Gateway nutzen)'
---
# policies/no-hostnetwork.yaml (Auszug ab spec)
spec:
  autogen:
    validatingAdmissionPolicy:
      enabled: true
  validationActions: [Deny]
  matchConstraints:
    resourceRules:
    - apiGroups: [""]
      apiVersions: [v1]
      operations: [CREATE, UPDATE]
      resources: [pods]
    namespaceSelector:
      matchLabels:
        guard-lab: demo
  validations:
  - expression: "!object.spec.?hostNetwork.orValue(false)"
    message: hostNetwork ist in Demo-Namespaces verboten.

Warum shop und nicht tenant-x als Testort in A7? tenant-x hat PSA restricted. Pod Security lehnt hostNetwork dort schon vor der VAP ab, die Prüfung sähe die falsche Meldung.

Teil 2: Wissensfragen

Je 1 Punkt, Bestehensgrenze 18 von 25. Antworte in einem Satz.

  1. Was gilt für einen Pod, den keine NetworkPolicy auswählt, und was, sobald eine Policy ihn für Ingress auswählt?
  2. Warum gibt es in NetworkPolicy kein Deny-Feld, und wie verbindet Kubernetes mehrere Policies?
  3. Worin unterscheiden sich - namespaceSelector + podSelector (ein Strich) und zwei Striche unter from?
  4. Welchen Port trägst du für einen Service port: 80 mit targetPort: 8080 ein, und warum?
  5. Warum bricht eine Egress-Default-Deny-Policy fast immer die Anwendung, und was gehört dazu?
  6. Was brauchst du, damit zwei Pods in zwei Namespaces mit Deny All in beide Richtungen sprechen?
  7. Warum ist kubernetes.io/metadata.name als Namespace-Selektor sicherer als team oder purpose?
  8. Warum ist ipBlock für Ziele im Cluster ungeeignet?
  9. Wie zeigt sich ein L7-Verbot von Cilium beim Client, und warum meldet conncheck.sh dabei „erlaubt”?
  10. Was braucht eine toFQDNs-Regel zusätzlich, und was passiert ohne?
  11. Was bedeutet policy-verdict:none INGRESS DENIED in hubble observe?
  12. Wozu dient enableDefaultDeny: false in einer CiliumClusterwideNetworkPolicy?
  13. Nenne die Reihenfolge der Auswertung bei ClusterNetworkPolicy, NetworkPolicy und Baseline-Tier.
  14. Was macht action: Pass im Admin-Tier?
  15. Was unterscheidet validationActions Audit, Warn und Deny?
  16. Was ist Autogen in Kyverno, und welchen Vorteil hat es für Teams?
  17. Warum zeigt die Kyverno-CLI eine Mutation von imagePullPolicy, die im Cluster nie passiert?
  18. Was bewirkt synchronize in einer GeneratingPolicy, und was passiert beim Löschen der Policy mit den erzeugten NetworkPolicies?
  19. Warum brauchst du generateExisting beim Einführen von Default Deny, und welche Gefahr hat es?
  20. Was bedeutet Excluded in kyverno test, und warum ist es gefährlich?
  21. Wozu dient die Werte-Datei (values.yaml) bei kyverno apply und kyverno test?
  22. Welche drei Felder machen eine PolicyException im Lab regelkonform, und wer räumt abgelaufene Ausnahmen auf?
  23. Was passiert bei failurePolicy: Fail, wenn kein Admission-Pod läuft, und was ist der Notausgang?
  24. Wann lässt du Kyverno zusätzlich eine native ValidatingAdmissionPolicy erzeugen, und welche Grenze hat das?
  25. Pod Security Admission oder Kyverno: Was macht welches Werkzeug im Mandanten-Modell dieses Buchs?

Lösungsschlüssel

  1. Ohne Auswahl ist alles erlaubt; ausgewählt ist für Ingress alles verboten, was keine Regel erlaubt (Tag 1).
  2. Policies erlauben nur; mehrere Policies ergeben die Vereinigung ihrer Erlaubnisse.
  3. Ein Strich ist UND (Pods mit X in Namespaces mit Y), zwei Striche sind ODER.
  4. 8080 bzw. den Named Port, denn die Policy sieht das Paket nach dem DNAT am Pod.
  5. Sie sperrt auch DNS zu CoreDNS; allow-dns (UDP und TCP 53 zu kube-dns) gehört immer dazu.
  6. Egress beim Sender und Ingress beim Empfänger, dazu DNS beim Sender.
  7. Es wird vom API-Server gesetzt und lässt sich nicht überschreiben; eigene Labels kann jeder mit patch namespaces setzen.
  8. Ob ipBlock auf Pod-IPs greift, ist nicht spezifiziert, Pod-IPs wechseln, und Service-IPs sieht die Policy nie.
  9. Als HTTP 403 vom Envoy; die TCP-Verbindung stand, und conncheck.sh wertet jeden HTTP-Status als erlaubt.
  10. Eine DNS-Regel mit rules.dns zu kube-dns; ohne sie lernt der DNS-Proxy keine IPs, und neue Namen werden verworfen.
  11. Keine Regel hat gepasst, der Default Deny des Endpoints hat das Paket verworfen.
  12. Die Policy schaltet die erfassten Pods nicht in Default Deny, sie verbietet nur, was in ingressDeny/egressDeny steht.
  13. Admin-Tier, dann NetworkPolicies des Namespace, dann Baseline-Tier nur für Pods ohne NetworkPolicy.
  14. Es beendet die Auswertung im Admin-Tier und überlässt die Entscheidung den NetworkPolicies.
  15. Audit meldet nur im PolicyReport, Warn lässt durch und warnt den Client, Deny lehnt ab.
  16. Kyverno leitet aus Pod-Regeln Regeln für Deployments, Jobs & Co. ab; Fehler zeigen sich direkt beim apply statt still am ReplicaSet.
  17. Der API-Server setzt Defaults vor den Mutating-Webhooks; die CLI kennt kein Defaulting.
  18. Gelöschte oder geänderte Kopien werden zurückgesetzt; nach dem Löschen der Policy bleiben die NetworkPolicies im Test (1.19.1) stehen.
  19. Ohne sie bekommen bestehende Namespaces nichts; mit ihr greift Default Deny sofort überall und sperrt z. B. das Monitoring aus.
  20. Das Objekt passt nicht zur Auswahl der Policy und zählt immer als bestanden, auch wenn fail erwartet ist; ein Test kann so grün sein, ohne etwas zu prüfen.
  21. Sie liefert offline Namespace-Labels und Variablen, ohne die namespaceSelector nichts trifft.
  22. expiresAt, properties.ticket und properties.owner; delete-expired-exceptions (DeletingPolicy) räumt stündlich auf.
  23. Jeder passende Request wird abgelehnt; Notausgang: Kyverno-Webhooks löschen, Kyverno reparieren, es legt sie neu an.
  24. Für Sicherheitsregeln, die auch bei Kyverno-Ausfall gelten müssen; nur reines Kubernetes-CEL, keine Kyverno-Bibliotheken und kein Autogen.
  25. PSA restricted ist das ausfallsichere Fundament pro Mandant; Kyverno generiert Netz, Quota und RBAC und prüft alles, was PSA nicht kann.

Teil 3: Selbsteinschätzung

Thema kann ich im Lab gemacht
Default Deny, Selektoren, UND/ODER (Tag 1) [ ] [ ]
DNS, Ports, ipBlock, Host-Traffic (Tag 2) [ ] [ ]
Mandanten, Monitoring, Labels als Vertrag (Tag 3) [ ] [ ]
Cilium L7, toFQDNs, Entities, Hubble (Tag 4) [ ] [ ]
CCNP und ClusterNetworkPolicy (Tag 5) [ ] [ ]
Soll-Matrix, policy-assistant, CI (Tag 6) [ ] [ ]
Kyverno installieren, Audit vs. Deny (Tag 7) [ ] [ ]
ValidatingPolicy mit CEL (Tag 8) [ ] [ ]
MutatingPolicy und GeneratingPolicy (Tag 9) [ ] [ ]
cosign, SBOM, ImageValidatingPolicy (Tag 10) [ ] [ ]
kyverno test, Chainsaw, PolicyException (Tag 11) [ ] [ ]
HA, failurePolicy, Metriken, Cleanup (Tag 12) [ ] [ ]
Onboarding, GitOps, PSA vs. Kyverno (Tag 13) [ ] [ ]
Desaster-Drills unter Zeitdruck (Tag 14) [ ] [ ]

Jede Zeile ohne zwei Kreuze: das Kapitel noch einmal durcharbeiten.