Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 11: Policies testen

Ziel: Du baust ein Policy-Repo mit Unit-Tests (kyverno test), E2E-Tests (Chainsaw), CI-Pipeline und befristeten PolicyExceptions. · Dauer: ca. 120 min · Voraussetzung: Tag 8

Briefing

  • kyverno test prüft Policies offline gegen Beispielobjekte. Kein Cluster, Sekunden pro Lauf, ideal für jeden Pull Request.
  • kyverno apply beantwortet die Frage „Was würde passieren?“ für echte Manifeste und schreibt auf Wunsch einen PolicyReport.
  • Chainsaw testet im echten Cluster: Webhook, Ablehnung, Status. Das fängt Fehler, die offline unsichtbar bleiben.
  • Eine PolicyException ist ein Loch in der Policy. Deshalb: Ticket, Owner, Ablaufdatum, eigener Namespace und eine Policy, die genau das erzwingt.
policy-repo/
├── policies/        image-hygiene.yaml (Tag 8), exception-governance.yaml
├── exceptions/      legacy-batch.yaml
├── tests/<policy>/  kyverno-test.yaml, resources.yaml, values.yaml   → kyverno test
├── e2e/<policy>/    chainsaw-test.yaml + Pods                         → chainsaw test
└── ci/, .github/, .gitlab-ci.yml                                      → Pipeline

Drill 1: Policy-Repo anlegen

Du testest die Policy image-hygiene aus Tag 8: feste Tags, erlaubte Registries, Ressourcen.

mkdir -p ~/guard-lab/tag11 && cd ~/guard-lab/tag11
cp -R ~/books/kyverno-networkpolicy-training/code/kyverno-ops ~/guard-lab/code/
cp -R ~/guard-lab/code/kyverno-ops/tag11/policy-repo .
cd policy-repo
cp ~/guard-lab/code/kyverno/tag08/image-hygiene.yaml policies/
git init -q && git add -A && git commit -qm "Policy-Repo Tag 11"
find . -path ./.git -prune -o -type f -print | wc -l
ls tests e2e policies

Erwartet:

      15
e2e:
image-hygiene

policies:
exception-governance.yaml image-hygiene.yaml

tests:
exception-governance image-hygiene

Ein Ordner pro Policy unter tests/ hält die Testfälle klein. kyverno test . findet rekursiv jede kyverno-test.yaml.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Der erste Unit-Test

Die Testobjekte decken je genau eine Eigenschaft ab: gut, :latest, ohne Tag, :latest im initContainer, ohne Ressourcen.

grep -h '^metadata' tests/image-hygiene/resources.yaml
cat tests/image-hygiene/values.yaml

Erwartet:

metadata: {name: good, namespace: shop}
metadata: {name: latest, namespace: shop}
metadata: {name: notag, namespace: shop}
metadata: {name: init-latest, namespace: shop}
metadata: {name: nores, namespace: shop}
metadata: {name: legacy-batch-1, namespace: shop}
metadata: {name: sandbox-latest, namespace: sandbox}
apiVersion: cli.kyverno.io/v1alpha1
kind: Value
metadata:
  name: values
namespaceSelector:
- name: shop
  labels: {guard-lab: demo}
- name: sandbox
  labels: {team: sandbox}

Warum values.yaml? Offline kennt die CLI keine Namespace-Labels. Ohne sie greift der namespaceSelector (guard-lab: demo) der Policy nie.

Starte mit dem Test ohne Ausnahme (die kommt in Drill 5):

cat > tests/image-hygiene/kyverno-test.yaml <<'EOF'
apiVersion: cli.kyverno.io/v1alpha1
kind: Test
metadata:
  name: image-hygiene
policies:
- ../../policies/image-hygiene.yaml
resources:
- resources.yaml
variables: values.yaml
results:
- isValidatingPolicy: true
  policy: image-hygiene
  kind: Pod
  resources: [good]
  result: pass
- isValidatingPolicy: true
  policy: image-hygiene
  kind: Pod
  resources: [latest, notag, init-latest, nores]
  result: fail
EOF
kyverno test tests/image-hygiene --remove-color

Erwartet (gekürzt):

│ ID │ POLICY        │ RULE │ RESOURCE                │ RESULT │ REASON │
│ 1  │ image-hygiene │      │ v1/Pod/shop/good        │ Pass   │ Ok     │
│ 2  │ image-hygiene │      │ v1/Pod/shop/latest      │ Pass   │ Ok     │
│ 3  │ image-hygiene │      │ v1/Pod/shop/notag       │ Pass   │ Ok     │
│ 4  │ image-hygiene │      │ v1/Pod/shop/init-latest │ Pass   │ Ok     │
│ 5  │ image-hygiene │      │ v1/Pod/shop/nores       │ Pass   │ Ok     │

Test Summary: 5 tests passed and 0 tests failed

RESULT Pass heißt: Die Erwartung stimmt, nicht „der Pod ist erlaubt“. Bei neuen CEL-Policies ist RULE leer. Es gibt keine benannten Regeln mehr, deshalb isValidatingPolicy: true statt rule:.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Test rot machen – und eine Falle

Ein Test, der nie rot wird, beweist nichts. Hänge zwei falsche Erwartungen an:

cat >> tests/image-hygiene/kyverno-test.yaml <<'EOF'
- isValidatingPolicy: true
  policy: image-hygiene
  kind: Pod
  resources: [sandbox-latest, good]
  result: fail
EOF
kyverno test tests/image-hygiene --remove-color; echo "exit=$?"

Erwartet (gekürzt, Spalte RULE weggelassen):

│ ID │ POLICY        │ RESOURCE                      │ RESULT │ REASON
│ 5  │ image-hygiene │ v1/Pod/shop/nores             │ Pass   │ Ok
│ 6  │ image-hygiene │ v1/Pod/sandbox/sandbox-latest │ Pass   │ Excluded
│ 7  │ image-hygiene │ v1/Pod/shop/good              │ Fail   │ Want fail, got pass

Test Summary: 6 tests passed and 1 tests failed

Error: 1 tests failed
exit=1

good fällt korrekt durch. Die Falle ist sandbox-latest: Der Namespace passt nicht zum namespaceSelector, die CLI meldet Excluded und wertet das als bestanden, egal was du erwartest. Nicht passende Objekte testest du also nicht mit result: fail, sondern prüfst den Selector über ein Objekt im passenden Namespace.

git checkout tests/image-hygiene/kyverno-test.yaml
kyverno test tests/image-hygiene >/dev/null 2>&1 && echo "✔ wieder grün"

Erwartet:

✔ wieder grün

Tipp: git checkout holt hier die Fassung aus Drill 1 mit Ausnahme zurück. Das ist gewollt. Drill 5 erklärt sie.

Fortschritt speichern? Kostenlos registrieren

Drill 4: kyverno apply – was würde passieren?

apply zeigt die Messages der Policy und liefert einen Exit-Code. Erst die Testobjekte, dann die echte Demo-App aus Tag 0:

kyverno apply policies/image-hygiene.yaml -r tests/image-hygiene/resources.yaml \
  --values-file tests/image-hygiene/values.yaml --remove-color; echo "exit=$?"

Erwartet (gekürzt):

Applying 1 policy rule(s) to 7 resource(s)...
policy image-hygiene -> resource shop/Pod/latest failed:
1 -  Fester Tag oder Digest nötig, nicht :latest: nginxinc/nginx-unprivileged:latest
policy image-hygiene -> resource shop/Pod/notag failed:
1 -  Fester Tag oder Digest nötig, nicht :latest: nginxinc/nginx-unprivileged
policy image-hygiene -> resource shop/Pod/nores failed:
1 -  requests.cpu, requests.memory und limits.memory fehlen bei: web

pass: 1, fail: 5, warn: 0, error: 0, skip: 0
exit=1
kyverno apply policies/image-hygiene.yaml -r ~/guard-lab/code/demo/ \
  --values-file ~/guard-lab/code/kyverno/tag08/values.yaml -t --remove-color
kyverno apply policies/image-hygiene.yaml -r ~/guard-lab/code/demo/ \
  --values-file ~/guard-lab/code/kyverno/tag08/values.yaml \
  --policy-report --output-format json 2>/dev/null | jq -c '{kind, summary}'

Erwartet:

Applying 1 policy rule(s) to 21 resource(s)...
│ ID │ POLICY        │ RULE │ RESOURCE                 │ RESULT │ REASON │
│ 1  │ image-hygiene │      │ shop/Deployment/frontend │ Pass   │        │
│ 2  │ image-hygiene │      │ shop/Deployment/api      │ Pass   │        │
│ 3  │ image-hygiene │      │ shop/Deployment/db       │ Pass   │        │
│ 4  │ image-hygiene │      │ tenant-a/Deployment/api  │ Pass   │        │
{"kind":"ClusterReport","summary":{"pass":4,"fail":0,"warn":0,"error":0,"skip":0}}

Warum Deployments, obwohl die Policy nur pods matcht? Autogen: Kyverno leitet aus Pod-Policies automatisch Regeln für Deployments, StatefulSets, Jobs usw. ab. Der Report hat das neue Format openreports.io/v1alpha1 (Tag 7).

Fortschritt speichern? Kostenlos registrieren

Drill 5: PolicyException – eng, befristet, begründet

Ein Batch-Job in shop darf bis Jahresende :latest nutzen. Die Ausnahme lebt in einem eigenen Namespace und trifft per CEL genau diese Pods:

sed -n '/^spec:/,$p' exceptions/legacy-batch.yaml

Erwartet:

spec:
  policyRefs:
  - name: image-hygiene
    kind: ValidatingPolicy
  matchConditions:
  - name: nur-shop-legacy-batch
    expression: >-
      object.metadata.namespace == 'shop' &&
      object.metadata.name.startsWith('legacy-batch')
  expiresAt: "2026-12-31T23:59:59Z"
  properties:
    ticket: SEC-4711
    owner: team-shop
    reason: Batch-Image bekommt bis Jahresende feste Tags

expiresAt und properties sind echte API-Felder im CRD von Kyverno 1.19. Die Ausnahme gilt für die ganze Policy, nicht für einzelne Validierungen. Kleine Policies machen Ausnahmen also kleiner.

grep -A2 '^exceptions' tests/image-hygiene/kyverno-test.yaml
kyverno test tests/image-hygiene --remove-color | grep -E 'legacy|Summary'

Erwartet:

exceptions:
- ../../exceptions/legacy-batch.yaml
variables: values.yaml
│ 6  │ image-hygiene │ exception │ v1/Pod/shop/legacy-batch-1 │ Pass   │ Ok     │
Test Summary: 6 tests passed and 0 tests failed

Achtung: Die CLI (1.19.1) ignoriert expiresAt. Eine abgelaufene Ausnahme wird offline weiter als skip gewertet. Ablauf testest du nur im Cluster (Drill 7).

Fortschritt speichern? Kostenlos registrieren

Drill 6: Governance für Ausnahmen

Wer eine PolicyException anlegen darf, kann jede Policy aushebeln. Drei Schutzschichten: eigener Namespace (Kyverno-Flag), RBAC auf diesen Namespace und eine Policy, die Ticket, Owner und maximal 90 Tage Laufzeit erzwingt.

sed -n '/validations:/,$p' policies/exception-governance.yaml
kyverno test tests/exception-governance --remove-color | grep -E '│ [0-9]|Summary'

Erwartet (gekürzt, Spalten RULE und REASON weggelassen):

  validations:
  - expression: >-
      ['ticket', 'owner'].all(k, k in variables.props)
    message: properties.ticket und properties.owner sind Pflicht.
  - expression: has(object.spec.expiresAt)
    message: Ohne spec.expiresAt keine Ausnahme.
  - expression: >-
      !has(object.spec.expiresAt) ||
      timestamp(object.spec.expiresAt) < time.now() + duration('2160h')
    message: Ausnahmen laufen spätestens nach 90 Tagen ab.
│ 1 │ exception-governance │ …/PolicyException/policy-exceptions/ok          │ Pass │
│ 2 │ exception-governance │ …/PolicyException/policy-exceptions/ohne-ticket │ Pass │
│ 3 │ exception-governance │ …/PolicyException/policy-exceptions/fuer-immer  │ Pass │
Test Summary: 3 tests passed and 0 tests failed

time.now() ist Kyvernos CEL-Zeitbibliothek. Das Kubernetes-übliche now() kennt der Compiler nicht. Im Cluster schaltest du Ausnahmen nur für einen Namespace frei:

kubectl config use-context kind-kyverno-lab
kubectl create namespace policy-exceptions
helm upgrade kyverno kyverno/kyverno -n kyverno --version 3.9.1 \
  -f ~/guard-lab/code/kyverno/tag07/values-lab.yaml \
  --set features.policyExceptions.enabled=true \
  --set features.policyExceptions.namespace=policy-exceptions --wait
kubectl -n kyverno get deploy kyverno-admission-controller \
  -o jsonpath='{.spec.template.spec.containers[0].args}' | tr ',' '\n' \
  | grep -i exception

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

namespace/policy-exceptions created
Release "kyverno" has been upgraded. Happy Helming!
"--enablePolicyException=true"
"--exceptionNamespace=policy-exceptions"

Die beiden Flags hat helm template mit Chart 3.9.1 bestätigt. Jetzt Governance-Policy, Ausnahme und ein Test im Cluster:

kubectl apply -f policies/exception-governance.yaml
kubectl apply --dry-run=server -f tests/exception-governance/exceptions.yaml
kubectl apply -f policies/image-hygiene.yaml -f exceptions/legacy-batch.yaml
cat <<'EOF' | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata: {name: legacy-batch-1, namespace: shop}
spec:
  containers:
  - name: job
    image: curlimages/curl:latest
    command: [sleep, "60"]
    resources: {requests: {cpu: 10m, memory: 16Mi}, limits: {memory: 32Mi}}
EOF

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

validatingpolicy.policies.kyverno.io/exception-governance created
policyexception.policies.kyverno.io/ok created (server dry run)
Error from server: admission webhook "…" denied the request: Policy
exception-governance failed: properties.ticket und properties.owner sind Pflicht.
Error from server: admission webhook "…" denied the request: Policy
exception-governance failed: Ausnahmen laufen spätestens nach 90 Tagen ab.
validatingpolicy.policies.kyverno.io/image-hygiene configured
policyexception.policies.kyverno.io/legacy-batch-latest created
pod/legacy-batch-1 created

--dry-run=server schickt die Objekte durch alle Admission-Webhooks, speichert aber nichts. So landet die Test-Ausnahme ok (sie trifft jeden Pod) nie im Cluster.

Sicherheit: Gib Teams per RBAC höchstens create auf PolicyExceptions in policy-exceptions, nie update/delete auf Policies. Freigabe läuft über Git und Review, nicht über kubectl.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Chainsaw – E2E im echten Cluster

Chainsaw legt pro Test einen Wegwerf-Namespace an, führt Schritte aus und räumt auf. Der namespaceTemplate gibt ihm das Label, auf das image-hygiene reagiert.

CS=0.2.15; OS=$(uname -s | tr A-Z a-z); ARCH=$(uname -m | sed s/x86_64/amd64/)
mkdir -p /private/tmp/chainsaw
curl -sL "https://github.com/kyverno/chainsaw/releases/download/v$CS/\
chainsaw_${OS}_${ARCH}.tar.gz" | tar xz -C /private/tmp/chainsaw chainsaw
alias chainsaw=/private/tmp/chainsaw/chainsaw
chainsaw version | head -1
grep -nE 'name: [a-z-]+$|ready|\$error|- error' e2e/image-hygiene/chainsaw-test.yaml

Erwartet:

Version: 0.2.15
5:  name: image-hygiene
12:  - name: policy-bereit
21:            name: image-hygiene
24:              ready: true
25:  - name: guter-pod-darf
31:  - name: latest-wird-abgelehnt
37:            ($error != null): true
38:    - error:

Drei Schritte: Policy ist ready, guter Pod wird angelegt, :latest wird abgelehnt ($error gesetzt) und existiert danach nicht (error:-Operation). Erst prüfen, dann laufen lassen:

chainsaw lint test -f e2e/image-hygiene/chainsaw-test.yaml
chainsaw test e2e/ --report-format JUNIT-TEST --report-name chainsaw

Erwartet (Lint live getestet; Testlauf gekürzt, nicht live getestet, kann abweichen):

Processing input...
The document is valid
Version: 0.2.15
Loading tests...
- image-hygiene (e2e/image-hygiene)
Running tests...
=== RUN   chainsaw
=== RUN   chainsaw/image-hygiene
--- PASS: chainsaw (…)
    --- PASS: chainsaw/image-hygiene (…)
PASS
Tests Summary...
- Passed  tests 1
- Failed  tests 0
- Skipped tests 0

Tipp: Mit --skip-delete bleibt der Test-Namespace nach dem Lauf stehen. So debuggst du einen roten Schritt mit kubectl weiter.

Fortschritt speichern? Kostenlos registrieren

Drill 8: CI-Pipeline – GitHub Actions und GitLab CI

Zwei Stufen: unit (CLI, Sekunden, jeder Pull Request) und e2e (kind + Kyverno + Chainsaw, Minuten). Ein Detail kostet sonst eine Stunde: kyverno test -o junit mischt Log-Zeilen und die Summary in stdout. Das Skript schneidet pro Testordner sauberes XML heraus.

sh ci/kyverno-junit.sh; echo "exit=$?"
grep -ho 'tests="[0-9]*" failures="[0-9]*"' reports/*.xml | sort -u
rm -rf reports

Erwartet:

exit=0
tests="3" failures="0"
tests="6" failures="0"

Die GitHub-Pipeline nutzt die offiziellen Actions. Prüfe sie lokal mit actionlint:

grep -nE 'uses:|run:' .github/workflows/policies.yaml
go run github.com/rhysd/actionlint/cmd/actionlint@latest \
  .github/workflows/policies.yaml && echo "✔ actionlint"

Erwartet:

12:    - uses: actions/checkout@v7
13:    - uses: kyverno/[email protected]
17:      run: sh ci/kyverno-junit.sh
18:    - uses: actions/upload-artifact@v7
27:    - uses: actions/checkout@v7
28:    - uses: helm/[email protected]
32:      run: |
36:    - uses: kyverno/[email protected]
38:      run: chainsaw test e2e/ --report-format JUNIT-TEST --report-name chainsaw
✔ actionlint

GitLab hat kein kind-Action. Der Job startet kind in Docker-in-Docker. Der API-Server muss dann über den Service-Namen docker erreichbar sein und ein passendes Zertifikat haben:

cat ci/kind-dind.yaml
grep -nE 'kind create|sed -i|chainsaw test' .gitlab-ci.yml

Erwartet:

# kind im GitLab-Runner: API-Server über den Service-Namen "docker" erreichbar
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
networking:
  apiServerAddress: "0.0.0.0"
  apiServerPort: 6443
kubeadmConfigPatches:
- |
  kind: ClusterConfiguration
  apiServer:
    certSANs: [docker, localhost, 127.0.0.1]
45:  - kind create cluster --name policy-ci --config ci/kind-dind.yaml
46:  - sed -i 's#https://0.0.0.0:#https://docker:#' ~/.kube/config
50:  - chainsaw test e2e/ --report-format JUNIT-TEST --report-name chainsaw

Achtung: Die GitLab-Pipeline ist nur statisch geprüft (YAML, Download-URLs). Der Runner braucht privileged = true für docker:dind. Ohne das bleibt nur der Unit-Job.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

#!/usr/bin/env bash
cd ~/guard-lab/tag11/policy-repo
ok() { echo "✔ $1"; }; nok() { echo "✘ $1"; }
kyverno test . >/dev/null 2>&1 && ok "kyverno test grün" || nok "kyverno test grün"
grep -q 'exceptions:' tests/image-hygiene/kyverno-test.yaml \
  && ok "Test kennt die Ausnahme" || nok "Test kennt die Ausnahme"
grep -q 'expiresAt:' exceptions/legacy-batch.yaml \
  && ok "Ausnahme befristet" || nok "Ausnahme befristet"
/private/tmp/chainsaw/chainsaw lint test -f e2e/image-hygiene/chainsaw-test.yaml \
  >/dev/null 2>&1 && ok "Chainsaw-Test valide" || nok "Chainsaw-Test valide"
sh ci/kyverno-junit.sh >/dev/null 2>&1 && ls reports/kyverno-*.xml >/dev/null \
  && ok "JUnit-Berichte" || nok "JUnit-Berichte"
rm -rf reports

Challenge

Schreibe einen zusätzlichen Testfall in tests/image-hygiene/: Ein Deployment web-latest in shop mit :latest muss durchfallen, obwohl die Policy nur Pods matcht.

Hinweis: Autogen erzeugt die Deployment-Variante; im Ergebnis steht kind: Deployment und die Ressource als shop/web-latest.

Lösung

{ echo '---'; cat ~/guard-lab/code/kyverno-ops/tag11/challenge-deploy.yaml; } \
  >> tests/image-hygiene/resources.yaml
cat >> tests/image-hygiene/kyverno-test.yaml <<'EOF'
- isValidatingPolicy: true
  policy: image-hygiene
  kind: Deployment
  resources: [shop/web-latest]
  result: fail
EOF
kyverno test tests/image-hygiene --remove-color | grep -E 'Deployment|Summary'

Erwartet (gekürzt, Spalte RULE weggelassen):

│ 7  │ image-hygiene │ apps/v1/Deployment/shop/web-latest │ Pass   │ Excluded │
│ 8  │ image-hygiene │ apps/v1/Deployment/shop/web-latest │ Pass   │ Ok       │
Test Summary: 8 tests passed and 0 tests failed

Zwei Zeilen, weil die Basis-Policy das Deployment ausschließt und die Autogen-Variante es prüft.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Policy-Repo wie Anwendungscode behandeln: Branch-Schutz, Review durch Security, Pflicht- Checks unit und e2e vor dem Merge, Versionierung per Tag.
  • E2E gegen dieselbe Kyverno- und Kubernetes-Version wie Produktion fahren. Eine Version-Matrix fängt CEL-Unterschiede vor dem Upgrade (Tag 12).
  • PolicyExceptions nur per Merge Request in policy-exceptions, mit Ticket, Owner und expiresAt. Abgelaufene Objekte räumt eine DeletingPolicy weg (Tag 12).
  • kyverno apply --generate-exceptions erzeugt noch Ausnahmen im alten Format kyverno.io/v2beta1 (1.19.1). Für CEL-Policies schreibst du sie selbst.
  • Neue Policies erst mit validationActions: [Audit] ausrollen, PolicyReports eine Woche auswerten, dann auf Deny umstellen.