Zum Inhalt springen
Trainingslager IT-Trainingslager

Kapitel 9: Policy as Code (Kyverno, OPA)

In diesem Kapitel lernst du:

  • wie Admission Control in Kubernetes funktioniert und wo Policies eingreifen
  • wie du mit Kyverno Regeln schreibst (Validate, Mutate, Generate, VerifyImages) und sie sicher von Audit auf Enforce umstellst
  • wie du PolicyReports liest und Policies offline mit der Kyverno-CLI testest
  • wie du mit OPA/Rego und conftest Manifeste schon in der Pipeline prüfst (shift-left) und Rego-Policies mit opa test absicherst
  • wann Gatekeeper, wann Kyverno und wann conftest die richtige Wahl ist

Worum geht es?

Denk an den Einlass eines Rechenzentrums. Am Empfang wird jeder Besucher geprüft: Hat er einen Termin? Trägt er einen Besucherausweis? Wer keinen Ausweis hat, bekommt einen angeheftet (wenn er angemeldet ist). Wer gar nicht auf der Liste steht, kommt nicht rein. Und schon bei der Terminvereinbarung prüft die Assistenz vorab, ob der Besuch überhaupt möglich ist, damit niemand umsonst anreist.

In Kubernetes ist der Empfang die Admission Control: eine Prüfstelle im API-Server, die jede Anfrage („lege dieses Deployment an”) sehen, verändern oder ablehnen kann, bevor sie gespeichert wird. Kyverno und OPA Gatekeeper sind solche Empfangsmitarbeiter. Die Vorabprüfung bei der Terminvereinbarung ist conftest in der Pipeline: Fehler werden gefunden, bevor überhaupt jemand kubectl apply ausführt.

Policy as Code heißt: Die Hausordnung steht nicht in einem PDF, sondern als versionierte, getestete Dateien in Git. Jede Änderung läuft durch Review und Pipeline, genau wie Anwendungscode.

  Entwickler                Pipeline (shift-left)          Cluster (Admission)
 +-----------+   push   +-------------------------+     +--------------------------+
 | k8s/*.yaml| -------> | conftest test k8s/      |     | kube-apiserver           |
 +-----------+          | kyverno apply / test    |     |   1. Authentifizierung   |
                        +-----------+-------------+     |   2. Autorisierung (RBAC)|
                                    | ok                |   3. Mutating Admission  |
                                    v                   |      (Kyverno mutate)    |
                        +-------------------------+     |   4. Schema-Validierung  |
                        | kubectl apply / Argo CD | --> |   5. Validating Admission|
                        +-------------------------+     |      (Kyverno validate)  |
                                                        |   6. Speichern in etcd   |
                                                        +-------------+------------+
                                                                      |
                                       PolicyReports (Hintergrund-Scan) <-+

Die Konzepte in einfach

Admission Control in drei Sätzen

Der API-Server ruft bei jeder schreibenden Anfrage registrierte Admission Webhooks auf. Es gibt zwei Sorten: Mutating Webhooks dürfen das Objekt verändern (zum Beispiel ein Label ergänzen), Validating Webhooks dürfen nur ja oder nein sagen. Erst wird mutiert, dann validiert. Deshalb kann eine Validierungsregel sich darauf verlassen, dass vorher gesetzte Standardwerte schon da sind.

Merke: Admission Control sieht nur Anfragen, die ab jetzt ankommen. Bereits laufende Objekte werden nicht nachträglich abgelehnt. Dafür gibt es den Hintergrund-Scan, der Verstöße in PolicyReports meldet.

Kubernetes bringt mit Pod Security Admission (PSA) schon eine eingebaute, aber starre Prüfung mit (Stufen privileged, baseline, restricted per Namespace-Label). Für eigene Regeln wie „nur Images aus unserer Registry” brauchst du eine Policy-Engine.

Kyverno: Policies in YAML

Kyverno ist eine Policy-Engine, die speziell für Kubernetes gebaut wurde. Policies sind Kubernetes-Ressourcen in YAML; du musst keine neue Sprache lernen. Eine ClusterPolicy gilt clusterweit, eine Policy nur in ihrem Namespace. Jede Policy besteht aus Regeln (rules) mit einem match/exclude-Teil (für welche Objekte?) und genau einer Aktion:

Regeltyp Was er tut Beispiel
validate erlauben oder ablehnen kein :latest-Tag
mutate Objekt verändern Label team ergänzen
generate zusätzliche Objekte erzeugen NetworkPolicy für jeden neuen Namespace
verifyImages Signaturen/Attestations prüfen nur mit eigenem Cosign-Key signierte Images

Validierungen schreibst du meist als Muster (pattern). Das Muster sieht aus wie ein Ausschnitt des Objekts, mit Platzhaltern:

Ausdruck Bedeutung
"?*" irgendein nicht-leerer Wert
"!*:latest" darf nicht auf :latest enden
"a/* \| b/*" beginnt mit a/ oder b/
=(feld): wenn das Feld existiert, muss es passen
+(feld): (in mutate) nur setzen, wenn es noch fehlt

Praktisch: Schreibst du eine Regel für Pod, erzeugt Kyverno automatisch passende Regeln für Deployments, StatefulSets, Jobs usw. (Autogen). Diese Regeln heißen dann autogen-<regelname>. Du siehst den Namen später in Fehlermeldungen.

Audit vs. Enforce

Jede Validierungsregel läuft in einem von zwei Modi:

  • Audit: Verstöße werden nur protokolliert (PolicyReport). Die Anfrage geht durch.
  • Enforce: Verstöße werden abgelehnt. Die Anfrage scheitert mit einer Fehlermeldung.

Der sichere Weg ist immer: erst Audit, Reports auswerten, Teams Zeit zum Nachbessern geben, dann Enforce. Wer direkt mit Enforce startet, legt im schlimmsten Fall Deployments in Produktion lahm.

Achtung (Versionshinweis): Bis Kyverno 1.12 stellst du den Modus für die ganze Policy mit spec.validationFailureAction: Audit|Enforce ein. Ab Kyverno 1.13 gibt es failureAction direkt in der Regel (rules[].validate.failureAction), das alte Feld ist veraltet (deprecated), funktioniert aber noch. In diesem Kapitel nutzen wir die neue Schreibweise. Prüfe deine Version mit kyverno version bzw. helm list -n kyverno. Neuere Kyverno-Versionen bringen außerdem CEL-basierte Policy-Typen wie ValidatingPolicy mit; die klassische ClusterPolicy aus diesem Kapitel bleibt unterstützt.

Ein weiteres Feld wird oft verwechselt: spec.failurePolicy (Fail oder Ignore) regelt, was passiert, wenn Kyverno selbst nicht erreichbar ist. Fail heißt: Ohne Kyverno wird nichts mehr zugelassen. Das ist sicher, kann aber den Cluster blockieren.

PolicyReports

Kyverno schreibt Ergebnisse in PolicyReport-Ressourcen (Namespace-bezogen) und ClusterPolicyReport-Ressourcen (clusterweite Objekte). Das Format stammt von der Kubernetes Policy Working Group (API-Gruppe wgpolicyk8s.io) und wird auch von anderen Werkzeugen genutzt. Jeder Report zählt pass, fail, warn, error und skip und listet die Einzelergebnisse. Da es normale Kubernetes-Ressourcen sind, kannst du sie mit kubectl, Monitoring oder einer Oberfläche wie Policy Reporter auswerten.

OPA und Rego: die Grundlagen

OPA (Open Policy Agent) ist eine allgemeine Policy-Engine. Sie ist nicht auf Kubernetes beschränkt; dieselbe Sprache prüft Terraform-Pläne, API-Anfragen oder Dockerfiles. Die Sprache heißt Rego.

Rego denkt in Regeln, die Mengen befüllen. Eine typische Prüfregel liest sich so: „Die Menge deny enthält die Nachricht msg, wenn alle folgenden Bedingungen wahr sind.”

package main

import rego.v1

deny contains msg if {
    input.kind == "Deployment"
    some c in input.spec.template.spec.containers
    endswith(c.image, ":latest")
    msg := sprintf("Container '%s' nutzt :latest", [c.name])
}

Die wichtigsten Bausteine:

  • input ist das geprüfte Dokument (hier das Manifest als JSON).
  • Jede Zeile im Block ist eine Bedingung; alle müssen wahr sein (logisches UND).
  • Mehrere Regeln mit gleichem Kopf ergeben ein logisches ODER.
  • some c in liste läuft über alle Elemente.
  • not ausdruck ist wahr, wenn der Ausdruck falsch oder nicht definiert ist. Fehlende Felder sind in Rego „undefiniert”, nicht null.

Merke: Seit OPA 1.0 ist die Rego-v1-Syntax Standard: if vor dem Regelrumpf und contains für Mengenregeln sind Pflicht. Die Zeile import rego.v1 schadet in OPA 1.x nicht und macht dieselbe Datei auch mit älteren OPA-/conftest-Versionen (ab OPA 0.59) lauffähig. Ältere Beispiele im Netz nutzen noch deny[msg] { ... }, das ist die v0-Syntax.

Gatekeeper vs. conftest

OPA gibt es in zwei typischen Einsatzformen für Kubernetes:

  • Gatekeeper läuft im Cluster als Admission Webhook. Du schreibst ein ConstraintTemplate (die Rego-Logik plus ein Schema für Parameter) und daraus beliebig viele Constraints (konkrete Anwendung mit Parametern, zum Beispiel erlaubte Registries). Der Modus heißt hier enforcementAction mit deny, dryrun oder warn.
  • conftest läuft in der Pipeline oder lokal auf Dateien. Es sucht standardmäßig Rego-Dateien im Ordner policy/ mit package main und wertet die Regeln deny, violation und warn aus.

conftest ist shift-left: Fehler werden im Merge Request gefunden, nicht erst beim Deployment. Das ersetzt die Admission Control nicht, denn jemand kann an der Pipeline vorbei mit kubectl deployen. Beides zusammen ergibt Verteidigung in der Tiefe.

Kyverno oder OPA?

Kriterium Kyverno OPA (Gatekeeper/conftest)
Sprache YAML-Muster, optional CEL/JMESPath Rego
Einstieg sehr leicht für K8s-Teams steilere Lernkurve
Mutate/Generate eingebaut Mutation in Gatekeeper begrenzt
Signaturprüfung eingebaut (verifyImages) nur über Zusatzwerkzeuge
Außerhalb von K8s kaum Terraform, APIs, CI, beliebiges JSON
Offline-Tests kyverno test opa test, conftest verify

Eine häufige Kombination in der Praxis: Kyverno im Cluster, weil es Kubernetes-nah ist und Signaturen prüfen kann, und conftest in der Pipeline für Kubernetes-Manifeste, Terraform und andere Konfigurationen.

Policies testen

Policies sind Code und können Fehler haben. Eine fehlerhafte Enforce-Policy blockiert legitime Deployments, eine zu lasche lässt alles durch. Deshalb gehören zu jeder Policy Testfälle: ein Beispiel, das durchgehen muss, und je ein Beispiel pro Verstoß. Kyverno nutzt dafür eine kyverno-test.yaml, OPA Rego-Testregeln, die mit test_ beginnen.

Hands-on-Lab: Hausordnung für den Cluster seclab

Schritt 1: Vorbereitung

mkdir -p ~/seclab/kap09/{policies,tests,k8s,beispiele,policy}
cd ~/seclab/kap09
kubectl config use-context kind-seclab
kubectl get nodes

Erwartete Ausgabe:

NAME                   STATUS   ROLES           AGE   VERSION
seclab-control-plane   Ready    control-plane   ...   v1.3x.x

Prüfe die Werkzeuge:

kyverno version && conftest --version && opa version | head -1

Lege ein gehärtetes Deployment an, das alle Regeln dieses Kapitels erfüllt. Es nutzt das Image aus Kapitel 0:

cat > k8s/deployment.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: demo-app
  namespace: demo
spec:
  replicas: 1
  selector:
    matchLabels: { app: demo-app }
  template:
    metadata:
      labels: { app: demo-app }
    spec:
      securityContext:
        runAsNonRoot: true
        runAsUser: 10001
      containers:
        - name: demo-app
          image: reg-build:5000/demo-app:1.0.0
          ports: [{ containerPort: 8000 }]
          securityContext:
            allowPrivilegeEscalation: false
            capabilities: { drop: ["ALL"] }
          resources:
            requests: { cpu: 50m, memory: 64Mi }
            limits: { cpu: 250m, memory: 128Mi }
EOF

Auffällig: Das Label team fehlt absichtlich. Das ergänzt gleich eine Mutate-Regel.

Schritt 2: Kyverno per Helm installieren

helm repo add kyverno https://kyverno.github.io/kyverno/
helm repo update
helm install kyverno kyverno/kyverno -n kyverno --create-namespace --wait
kubectl -n kyverno get pods

Erwartete Ausgabe (Namen gekürzt):

NAME                                             READY   STATUS    RESTARTS   AGE
kyverno-admission-controller-...                 1/1     Running   0          1m
kyverno-background-controller-...                1/1     Running   0          1m
kyverno-cleanup-controller-...                   1/1     Running   0          1m
kyverno-reports-controller-...                   1/1     Running   0          1m

Die vier Controller teilen sich die Arbeit: Der Admission-Controller beantwortet Webhooks, der Background-Controller erledigt Generate und nachträgliche Mutationen, der Reports-Controller schreibt PolicyReports, der Cleanup-Controller löscht Ressourcen nach Regeln.

Tipp: In einer abgeschotteten Umgebung kommen Chart und Images aus deinem Spiegel (siehe Kapitel 3). Welche Values die Image-Registry steuern, zeigt helm show values kyverno/kyverno. Notiere dir die installierte Chart- und App-Version; die Kyverno-CLI sollte zur gleichen Minor-Version passen.

Schritt 3: Basis-Policy im Audit-Modus

Die erste ClusterPolicy bündelt vier Regeln: erlaubte Registries, kein :latest, runAsNonRoot und Ressourcen-Limits.

cat > policies/baseline.yaml <<'EOF'
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: seclab-baseline
  annotations:
    policies.kyverno.io/title: Seclab-Grundregeln fuer Pods
spec:
  background: true
  rules:
    - name: nur-interne-registries
      match:
        any:
          - resources: { kinds: [Pod] }
      exclude:
        any:
          - resources:
              namespaces: [kube-system, kyverno, local-path-storage]
      validate:
        failureAction: Audit
        message: "Images nur aus reg-build:5000 oder reg-ziel:5000."
        pattern:
          spec:
            =(initContainers):
              - image: "reg-build:5000/* | reg-ziel:5000/*"
            containers:
              - image: "reg-build:5000/* | reg-ziel:5000/*"
    - name: kein-latest
      match:
        any:
          - resources: { kinds: [Pod] }
      exclude:
        any:
          - resources:
              namespaces: [kube-system, kyverno, local-path-storage]
      validate:
        failureAction: Audit
        message: "Das Tag :latest ist nicht erlaubt. Feste Version oder Digest nutzen."
        pattern:
          spec:
            containers:
              - image: "!*:latest"
    - name: run-as-non-root
      match:
        any:
          - resources: { kinds: [Pod] }
      exclude:
        any:
          - resources:
              namespaces: [kube-system, kyverno, local-path-storage]
      validate:
        failureAction: Audit
        message: "spec.securityContext.runAsNonRoot muss true sein."
        pattern:
          spec:
            securityContext:
              runAsNonRoot: true
    - name: ressourcen-limits
      match:
        any:
          - resources: { kinds: [Pod] }
      exclude:
        any:
          - resources:
              namespaces: [kube-system, kyverno, local-path-storage]
      validate:
        failureAction: Audit
        message: "CPU- und Memory-Limits sind Pflicht."
        pattern:
          spec:
            containers:
              - resources:
                  limits:
                    cpu: "?*"
                    memory: "?*"
EOF
kubectl apply -f policies/baseline.yaml
kubectl get clusterpolicy

Erwartete Ausgabe (Spalten je nach Version leicht anders):

NAME              ADMISSION   BACKGROUND   READY   AGE   MESSAGE
seclab-baseline   true        true         True    5s    Ready

Ein paar Erklärungen zum Muster:

  • Bei Listen wie containers prüft Kyverno jedes Element gegen das Muster.
  • =(initContainers) heißt: Wenn es Init-Container gibt, gilt dieselbe Regel für sie.
  • exclude nimmt System-Namespaces aus. Kyverno filtert einige davon zusätzlich schon über seine eigene Konfiguration, aber explizit ist besser lesbar.

Achtung: Ein Image ohne Tag (nginx) bedeutet implizit nginx:latest, wird von "!*:latest" aber nicht erkannt. Hier hilft die Registry-Regel indirekt, weil fremde Images ohnehin abgelehnt werden. Für eine strengere Prüfung kannst du zusätzlich Digests verlangen ("*@sha256:*"), passend zu Kapitel 5.

Schritt 4: Label team mutieren und erzwingen

Jetzt die zweite Policy mit zwei Regeln. Die Mutate-Regel setzt im Namespace demo einen Standardwert, falls das Label fehlt. Die Validate-Regel verlangt das Label clusterweit für Deployments.

cat > policies/team-label.yaml <<'EOF'
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: team-label
spec:
  background: true
  rules:
    - name: team-standard-in-demo
      match:
        any:
          - resources:
              kinds: [Deployment]
              namespaces: [demo]
      mutate:
        patchStrategicMerge:
          metadata:
            labels:
              +(team): team-demo
    - name: team-pflicht
      match:
        any:
          - resources: { kinds: [Deployment] }
      exclude:
        any:
          - resources:
              namespaces: [kube-system, kyverno, local-path-storage]
      validate:
        failureAction: Audit
        message: "Deployments brauchen das Label 'team' (Ansprechpartner)."
        pattern:
          metadata:
            labels:
              team: "?*"
EOF
kubectl apply -f policies/team-label.yaml

Wende das gehärtete Deployment an und prüfe das Label:

kubectl create namespace demo --dry-run=client -o yaml | kubectl apply -f -
kubectl apply -f k8s/deployment.yaml
kubectl -n demo get deployment demo-app --show-labels

Erwartete Ausgabe:

NAME       READY   UP-TO-DATE   AVAILABLE   AGE   LABELS
demo-app   1/1     1            1           10s   team=team-demo

Das Label steht nicht in deiner Datei, Kyverno hat es beim Anlegen ergänzt. Weil Mutation vor Validierung läuft, ist auch die Regel team-pflicht erfüllt.

Merke: Mutate-Regeln greifen bei Anlegen und Ändern. Mit GitOps (Argo CD, Flux) führt eine Mutation dazu, dass der Live-Zustand vom Git-Stand abweicht. Plane das ein, zum Beispiel indem du Labels lieber in Git setzt und nur Standardwerte mutierst.

Schritt 5: Verstöße im Audit-Modus erzeugen und PolicyReports lesen

Lege zwei Deployments an, die gegen Regeln verstoßen:

kubectl -n demo create deployment web-latest --image=nginx:latest
kubectl create deployment ohne-team --image=reg-build:5000/demo-app:1.0.0

Beide werden angelegt, denn Audit blockiert nicht. Nach kurzer Zeit (Hintergrund-Scan und Reports-Controller brauchen einige Sekunden) schaust du in die Reports:

kubectl get policyreport -A

Erwartete Ausgabe (Namen sind UIDs, gekürzt):

NAMESPACE  NAME      KIND        NAME        PASS  FAIL  WARN  ERROR  SKIP  AGE
default    0c1e...   Deployment  ohne-team   1     3     0     0      0     20s
default    7a9d...   Pod         ohne-team-… 1     2     0     0      0     20s
demo       3f1c...   Deployment  demo-app    5     0     0     0      0     2m
demo       9b27...   Deployment  web-latest  1     4     0     0      0     20s
...

Jede Zeile gehört zu einer Ressource. demo-app hat keine Fehler. web-latest verstößt gegen die Registry-Regel, :latest, runAsNonRoot und Limits. ohne-team stammt zwar aus der richtigen Registry, hat aber kein team-Label, kein runAsNonRoot und keine Limits.

Details liest du so:

kubectl get policyreport -n demo -o yaml \
  | yq '.items[].results[] | select(.result == "fail")
        | {"policy": .policy, "rule": .rule, "message": .message}'

Erwartet: Einträge wie rule: autogen-kein-latest mit der Nachricht aus der Policy. Das Präfix autogen- zeigt, dass die Pod-Regel automatisch auf das Deployment übertragen wurde.

Tipp: Eine schnelle Gesamtübersicht über alle Fehler im Cluster bekommst du mit kubectl get policyreport -A -o json | jq '[.items[].summary.fail] | add'. Diese Zahl ist eine gute Kennzahl für dein Monitoring.

Schritt 6: Auf Enforce umstellen

Jetzt stellst du die Validierungsregeln scharf. Weil failureAction pro Regel gesetzt ist, ersetzt du alle Vorkommen:

sed -i.bak 's/failureAction: Audit/failureAction: Enforce/' \
  policies/baseline.yaml policies/team-label.yaml
grep -c "failureAction: Enforce" policies/*.yaml
kubectl apply -f policies/

Erwartet: policies/baseline.yaml:4 und policies/team-label.yaml:1. (sed -i.bak funktioniert auf Linux und macOS gleichermaßen.)

Räume die Testobjekte auf und versuche erneut, das schlechte Deployment anzulegen:

kubectl -n demo delete deployment web-latest
kubectl delete deployment ohne-team
kubectl -n demo create deployment web-latest --image=nginx:latest

Erwartete Ausgabe (gekürzt):

error: failed to create deployment: admission webhook "validate.kyverno.svc-fail"
denied the request:

resource Deployment/demo/web-latest was blocked due to the following policies

seclab-baseline:
  autogen-kein-latest: 'validation error: Das Tag :latest ist nicht erlaubt. ...'
  autogen-nur-interne-registries: 'validation error: Images nur aus ...'
  autogen-ressourcen-limits: 'validation error: CPU- und Memory-Limits ...'
  autogen-run-as-non-root: 'validation error: spec.securityContext.runAsNonRoot ...'

Genau so soll es sein: Die Fehlermeldung nennt Policy, Regel und eine verständliche Begründung. Deshalb lohnt es sich, message sorgfältig zu formulieren.

Prüfe auch das Label im Namespace default, wo keine Mutation greift:

kubectl create deployment ohne-team --image=reg-build:5000/demo-app:1.0.0

Erwartet: Ablehnung durch team-label mit der Regel team-pflicht (und zusätzlich durch die Baseline-Regeln, weil runAsNonRoot und Limits fehlen).

Das gehärtete Deployment geht weiterhin durch:

kubectl apply -f k8s/deployment.yaml

Erwartet: deployment.apps/demo-app unchanged oder configured, keine Ablehnung.

Schritt 7: Kyverno-CLI offline: apply

Die Kyverno-CLI braucht keinen Cluster. Damit prüfst du Manifeste in der Pipeline mit genau denselben Policies, die im Cluster gelten.

cat > beispiele/schlecht.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
  namespace: demo
spec:
  selector:
    matchLabels: { app: web }
  template:
    metadata:
      labels: { app: web }
    spec:
      containers:
        - name: web
          image: docker.io/library/nginx:latest
EOF
kyverno apply policies/ --resource beispiele/schlecht.yaml

Erwartete Ausgabe (gekürzt):

Applying 3 policy rule(s) to 1 resource(s)...

policy seclab-baseline -> resource demo/Deployment/web failed:
1. autogen-kein-latest: validation error: Das Tag :latest ist nicht erlaubt. ...
2. autogen-nur-interne-registries: validation error: Images nur aus ...
...
pass: 1, fail: 4, warn: 0, error: 0, skip: ...

Die Zahl der angewendeten Regeln und die Zählung können je nach CLI-Version leicht abweichen. Wichtig ist fail: 4. Danach gegen das gute Manifest:

kyverno apply policies/ --resource k8s/deployment.yaml

Erwartet: fail: 0. Die CLI zeigt dabei auch, dass die Mutate-Regel das Label team ergänzen würde.

Schritt 8: Kyverno-CLI offline: test

kyverno apply ist gut zum Ausprobieren. Für automatisierte Tests mit festen Erwartungen nutzt du kyverno test. Lege zuerst Testressourcen an, je ein Pod pro Verstoß und einen guten:

cat > tests/resources.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata: { name: gut }
spec:
  securityContext: { runAsNonRoot: true }
  containers:
    - name: app
      image: reg-build:5000/demo-app:1.0.0
      resources: { limits: { cpu: 100m, memory: 64Mi } }
---
apiVersion: v1
kind: Pod
metadata: { name: fremde-registry }
spec:
  securityContext: { runAsNonRoot: true }
  containers:
    - name: app
      image: docker.io/library/nginx:1.27
      resources: { limits: { cpu: 100m, memory: 64Mi } }
---
apiVersion: v1
kind: Pod
metadata: { name: mit-latest }
spec:
  securityContext: { runAsNonRoot: true }
  containers:
    - name: app
      image: reg-build:5000/demo-app:latest
      resources: { limits: { cpu: 100m, memory: 64Mi } }
---
apiVersion: v1
kind: Pod
metadata: { name: als-root }
spec:
  containers:
    - name: app
      image: reg-build:5000/demo-app:1.0.0
      resources: { limits: { cpu: 100m, memory: 64Mi } }
---
apiVersion: v1
kind: Pod
metadata: { name: ohne-limits }
spec:
  securityContext: { runAsNonRoot: true }
  containers:
    - name: app
      image: reg-build:5000/demo-app:1.0.0
EOF

Jetzt die Testdefinition. Sie sagt für jede Regel, welche Ressourcen bestehen und welche scheitern müssen:

cat > tests/kyverno-test.yaml <<'EOF'
apiVersion: cli.kyverno.io/v1alpha1
kind: Test
metadata:
  name: seclab-baseline-tests
policies:
  - ../policies/baseline.yaml
resources:
  - resources.yaml
results:
  - policy: seclab-baseline
    rule: nur-interne-registries
    kind: Pod
    resources: [gut, mit-latest, als-root, ohne-limits]
    result: pass
  - policy: seclab-baseline
    rule: nur-interne-registries
    kind: Pod
    resources: [fremde-registry]
    result: fail
  - policy: seclab-baseline
    rule: kein-latest
    kind: Pod
    resources: [mit-latest]
    result: fail
  - policy: seclab-baseline
    rule: run-as-non-root
    kind: Pod
    resources: [als-root]
    result: fail
  - policy: seclab-baseline
    rule: ressourcen-limits
    kind: Pod
    resources: [ohne-limits]
    result: fail
  - policy: seclab-baseline
    rule: ressourcen-limits
    kind: Pod
    resources: [gut]
    result: pass
EOF
kyverno test tests/

Erwartete Ausgabe (gekürzt):

Loading test  ( tests/kyverno-test.yaml ) ...
  Loading values/variables ...
  Loading policies ...
  Loading resources ...
  Applying 1 policy to 5 resources ...
  Checking results ...

| ID | POLICY          | RULE                   | RESOURCE           | RESULT | REASON |
| 1  | seclab-baseline | nur-interne-registries | v1/Pod/default/gut | Pass   | Ok     |
...
Test Summary: 9 tests passed and 0 tests failed

Jede Kombination aus Regel und Ressource zählt als ein Test. Ändere testweise in tests/kyverno-test.yaml bei mit-latest das Ergebnis auf pass und lass den Test erneut laufen: Jetzt meldet die CLI einen fehlgeschlagenen Test und endet mit Exit-Code ungleich 0. So fällt in der Pipeline auf, wenn jemand eine Policy versehentlich aufweicht.

Achtung: In älteren CLI-Versionen hieß das Feld in results noch resource (Einzahl). Bei Fehlermeldungen zum Schema prüfe kyverno test --help und die Doku deiner Version.

Schritt 9: OPA/Rego-Policy für conftest

Jetzt dieselben Regeln in Rego, für die Prüfung in der Pipeline. conftest sucht standardmäßig im Ordner policy/ nach package main.

cat > policy/k8s.rego <<'EOF'
package main

import rego.v1

erlaubte_registries := ["reg-build:5000/", "reg-ziel:5000/"]

workloads := {"Deployment", "StatefulSet", "DaemonSet", "Job"}

# Alle Container einsammeln, egal ob Pod oder Workload
container contains c if {
    input.kind in workloads
    some c in input.spec.template.spec.containers
}

container contains c if {
    input.kind == "Pod"
    some c in input.spec.containers
}

pod_spec := input.spec.template.spec if input.kind in workloads

pod_spec := input.spec if input.kind == "Pod"

erlaubt(image) if {
    some prefix in erlaubte_registries
    startswith(image, prefix)
}

deny contains msg if {
    some c in container
    not erlaubt(c.image)
    msg := sprintf(
        "Container '%s': Image '%s' nicht aus erlaubter Registry",
        [c.name, c.image],
    )
}

deny contains msg if {
    some c in container
    endswith(c.image, ":latest")
    msg := sprintf("Container '%s': Tag :latest ist nicht erlaubt", [c.name])
}

deny contains msg if {
    some c in container
    not c.resources.limits.memory
    msg := sprintf("Container '%s': Memory-Limit fehlt", [c.name])
}

deny contains msg if {
    some c in container
    not c.resources.limits.cpu
    msg := sprintf("Container '%s': CPU-Limit fehlt", [c.name])
}

deny contains msg if {
    pod_spec
    not pod_spec.securityContext.runAsNonRoot
    msg := sprintf(
        "%s '%s': runAsNonRoot muss true sein",
        [input.kind, input.metadata.name],
    )
}

warn contains msg if {
    input.kind in workloads
    not input.metadata.labels.team
    msg := sprintf("%s '%s': Label 'team' fehlt", [input.kind, input.metadata.name])
}
EOF

Was hier passiert:

  • container ist eine Hilfsmenge. Zwei Regeln mit demselben Kopf bedeuten ODER: Container aus Workloads oder aus Pods.
  • pod_spec ist ein Wert, der je nach Art des Objekts definiert ist. Für einen Service ist er undefiniert; dann greifen die Regeln nicht.
  • not c.resources.limits.memory ist wahr, wenn das Feld fehlt. Du musst nicht jede Ebene einzeln prüfen.
  • warn statt deny beim Label: In der Pipeline erinnert das, blockiert aber nicht, weil Kyverno im Cluster das Label im Namespace demo ohnehin ergänzt.

Jetzt prüfen:

conftest test k8s/

Erwartete Ausgabe:

WARN - k8s/deployment.yaml - main - Deployment 'demo-app': Label 'team' fehlt

6 tests, 5 passed, 1 warning, 0 failures, 0 exceptions

Die genaue Zahl der Tests hängt davon ab, wie conftest die Regeln zählt; wichtig ist 0 failures. Und das schlechte Beispiel:

conftest test beispiele/schlecht.yaml
echo "Exit-Code: $?"

Erwartete Ausgabe (gekürzt):

WARN - beispiele/schlecht.yaml - main - Deployment 'web': Label 'team' fehlt
FAIL - beispiele/schlecht.yaml - main - Container 'web': Image 'docker.io/...' nicht ...
FAIL - beispiele/schlecht.yaml - main - Container 'web': Tag :latest ist nicht erlaubt
FAIL - beispiele/schlecht.yaml - main - Container 'web': Memory-Limit fehlt
FAIL - beispiele/schlecht.yaml - main - Container 'web': CPU-Limit fehlt
FAIL - beispiele/schlecht.yaml - main - Deployment 'web': runAsNonRoot muss true sein
...
Exit-Code: 1

Tipp: Mit conftest test --output json k8s/ bekommst du maschinenlesbare Ergebnisse für die Pipeline; --output sarif wird von neueren conftest-Versionen ebenfalls unterstützt (siehe conftest test --help). So landen die Ergebnisse im selben Berichtsformat wie die Scanner aus Kapitel 8.

Schritt 10: Rego-Policies mit opa test absichern

Tests in Rego sind Regeln, deren Name mit test_ beginnt. Sie liegen typischerweise in einer Datei *_test.rego neben der Policy.

cat > policy/k8s_test.rego <<'EOF'
package main

import rego.v1

# Hilfsfunktion: baut ein Deployment mit Image und runAsNonRoot-Wert
deployment(image, non_root) := {
    "kind": "Deployment",
    "metadata": {"name": "t", "labels": {"team": "demo"}},
    "spec": {"template": {"spec": {
        "securityContext": {"runAsNonRoot": non_root},
        "containers": [{
            "name": "app",
            "image": image,
            "resources": {"limits": {"cpu": "100m", "memory": "64Mi"}},
        }],
    }}},
}

test_gutes_deployment_erlaubt if {
    count(deny) == 0 with input as deployment("reg-build:5000/demo-app:1.0.0", true)
}

test_latest_verboten if {
    msgs := deny with input as deployment("reg-build:5000/demo-app:latest", true)
    some msg in msgs
    contains(msg, ":latest")
}

test_fremde_registry_verboten if {
    msgs := deny with input as deployment("docker.io/library/nginx:1.27", true)
    some msg in msgs
    contains(msg, "nicht aus erlaubter Registry")
}

test_root_verboten if {
    msgs := deny with input as deployment("reg-ziel:5000/demo-app:1.0.0", false)
    some msg in msgs
    contains(msg, "runAsNonRoot")
}

test_service_wird_ignoriert if {
    count(deny) == 0 with input as {"kind": "Service", "metadata": {"name": "s"}}
}
EOF
opa test policy/ -v

Erwartete Ausgabe:

policy/k8s_test.rego:
data.main.test_gutes_deployment_erlaubt: PASS (1.1ms)
data.main.test_latest_verboten: PASS (0.9ms)
data.main.test_fremde_registry_verboten: PASS (0.8ms)
data.main.test_root_verboten: PASS (0.8ms)
data.main.test_service_wird_ignoriert: PASS (0.4ms)
--------------------------------------------------------------------------------
PASS: 5/5

Das Schlüsselwort with input as … ersetzt input nur für diesen Ausdruck. So testest du die Policy mit erfundenen Eingaben, ganz ohne Dateien. Dieselben Tests führt auch conftest verify aus.

Zusätzlich lohnt sich ein Format- und Syntax-Check, den du in die Pipeline übernimmst:

opa fmt --list --fail policy/
opa check policy/

Beide Befehle sollten nichts ausgeben und mit Exit-Code 0 enden. Die zwei Dateien sind hier genau so abgedruckt, wie opa fmt (OPA 1.4) sie schreibt: Einrückung mit Tabulatoren, mehrzeilige Aufrufe und Objekte mit nachgestelltem Komma. Listet opa fmt --list bei dir trotzdem eine Datei, hat sich beim Abtippen eine Abweichung eingeschlichen oder deine OPA-Version formatiert anders. Dann formatierst du mit opa fmt -w policy/ und lässt opa test policy/ noch einmal laufen; am Verhalten ändert die Formatierung nichts. In der Pipeline sorgt --fail dafür, dass unformatierte Policies den Job rot machen.

Schritt 11: Gatekeeper kurz gezeigt (optional)

Gatekeeper und Kyverno gleichzeitig im selben Cluster zu betreiben ist möglich, aber verwirrend. Probiere Gatekeeper deshalb in einem zweiten, kurzlebigen Cluster:

kind create cluster --name seclab-gk
helm repo add gatekeeper https://open-policy-agent.github.io/gatekeeper/charts
helm install gatekeeper gatekeeper/gatekeeper \
  -n gatekeeper-system --create-namespace --wait
kubectl -n gatekeeper-system get pods

Erwartet: Pods gatekeeper-audit-… und gatekeeper-controller-manager-… im Status Running.

Das ConstraintTemplate enthält die Logik und das Parameterschema:

cat > ~/seclab/kap09/gk-template.yaml <<'EOF'
apiVersion: templates.gatekeeper.sh/v1
kind: ConstraintTemplate
metadata:
  name: k8sallowedrepos
spec:
  crd:
    spec:
      names:
        kind: K8sAllowedRepos
      validation:
        openAPIV3Schema:
          type: object
          properties:
            repos:
              type: array
              items: { type: string }
  targets:
    - target: admission.k8s.gatekeeper.sh
      rego: |
        package k8sallowedrepos

        violation[{"msg": msg}] {
          container := input.review.object.spec.containers[_]
          not startswith_any(container.image, input.parameters.repos)
          msg := sprintf("Image %v nicht erlaubt", [container.image])
        }

        startswith_any(img, repos) {
          startswith(img, repos[_])
        }
EOF
kubectl apply -f ~/seclab/kap09/gk-template.yaml

Achtung: Gatekeeper-Templates im Feld rego werden klassisch in der älteren v0-Syntax geschrieben (ohne if/contains), wie hier gezeigt. Neuere Gatekeeper-Versionen erlauben Rego v1 über einen code-Block mit Versionsangabe. Prüfe dazu die Doku deiner Gatekeeper-Version. Beachte auch: Gatekeeper übergibt das Objekt unter input.review.object, conftest direkt als input.

Der Constraint wendet das Template mit Parametern an, zunächst nur beobachtend:

cat > ~/seclab/kap09/gk-constraint.yaml <<'EOF'
apiVersion: constraints.gatekeeper.sh/v1beta1
kind: K8sAllowedRepos
metadata:
  name: nur-interne-registries
spec:
  enforcementAction: dryrun
  match:
    kinds:
      - apiGroups: [""]
        kinds: ["Pod"]
    excludedNamespaces: [kube-system, gatekeeper-system]
  parameters:
    repos: ["reg-build:5000/", "reg-ziel:5000/"]
EOF
kubectl apply -f ~/seclab/kap09/gk-constraint.yaml
kubectl run test --image=nginx:1.27

Mit dryrun wird der Pod angelegt. Nach dem nächsten Audit-Lauf (standardmäßig etwa jede Minute) siehst du den Verstoß im Status:

kubectl get k8sallowedrepos nur-interne-registries \
  -o jsonpath='{.status.totalViolations}{"\n"}'

Erwartet: mindestens 1. Setze enforcementAction: deny, wende den Constraint erneut an und starte einen zweiten Pod mit kubectl run test2 --image=nginx:1.27. Jetzt lehnt Gatekeeper mit einer Meldung der Form admission webhook "validation.gatekeeper.sh" denied the request: [nur-interne-registries] Image nginx:1.27 nicht erlaubt ab.

Danach den Test-Cluster wieder löschen und zurück zu seclab:

kind delete cluster --name seclab-gk
kubectl config use-context kind-seclab

Schritt 12: In die Pipeline einbauen

Für die Pipeline brauchst du ein Job-Image, das kyverno, conftest und opa enthält. Ein offizielles Image mit allen dreien gibt es nicht. Du baust es deshalb selbst, nach demselben Muster wie das Werkzeug-Image in Kapitel 7: kleine Basis, gepinnte Versionen, geprüfte Prüfsummen. Speichere den folgenden Inhalt als ~/seclab/kap09/Dockerfile.policy-tools:

# Werkzeug-Image fuer den Job policy-check (Kapitel 9)
FROM alpine:3.20
ARG OPA_URL=https://github.com/open-policy-agent/opa/releases/download/v1.4.2
ARG CT_URL=https://github.com/open-policy-agent/conftest/releases/download/v0.56.0
ARG KY_URL=https://github.com/kyverno/kyverno/releases/download/v1.13.4
WORKDIR /tmp
RUN apk add --no-cache ca-certificates curl \
 && curl -fsSLo opa "$OPA_URL/opa_linux_amd64_static" \
 && curl -fsSLo conftest.tgz "$CT_URL/conftest_0.56.0_Linux_x86_64.tar.gz" \
 && curl -fsSLo kyverno.tgz "$KY_URL/kyverno-cli_v1.13.4_linux_x86_64.tar.gz" \
 && printf '%s  %s\n' \
      2c0ccdbbe0b8e2a5d12d9c42d92f1f34f494ffb32d1f3c4ddc36101be637d66f opa \
      620f41640d63bbde1646a108ce2816ba54c980466ceebb7e754dda2d508e8cd5 conftest.tgz \
      abd318dbb971ab6de2bbe3b7226f4a03230d5c9c651df8a29b6b5e085a55aeeb kyverno.tgz \
    | sha256sum -c - \
 && tar -xzf conftest.tgz conftest && tar -xzf kyverno.tgz kyverno \
 && install -m 0755 opa conftest kyverno /usr/local/bin/ \
 && rm -f opa conftest kyverno conftest.tgz kyverno.tgz
WORKDIR /
USER 10001

Die Prüfsummen stammen aus den Dateien opa_linux_amd64_static.sha256 und checksums.txt der jeweiligen GitHub-Release. Stimmt eine Datei nicht, bricht sha256sum -c den Build ab. OPA 1.4.2 ist die Version, mit der die Rego-Dateien oben formatiert sind.

cd ~/seclab/kap09
docker build --platform linux/amd64 \
  -t localhost:5001/tools/policy-tools:1.0.0 - < Dockerfile.policy-tools
docker push localhost:5001/tools/policy-tools:1.0.0
docker run --rm localhost:5001/tools/policy-tools:1.0.0 \
  sh -c 'opa version | head -1; conftest --version; kyverno version'

Erwartet: drei Zeilen mit OK im Build-Log, ein Digest beim Push und die Versionen 1.4.2, 0.56.0 und 1.13.4. Die Binärdateien sind für amd64; auf einem Mac mit Apple Silicon läuft das Image per Emulation. Für ein natives arm64-Image tauschst du Dateinamen und Prüfsummen gegen die arm64-Varianten derselben Releases.

Sicherheit: Im Lab lädt der Build direkt von GitHub. In der air-gapped Umgebung kommen die drei Dateien über die Zonenübergabe (siehe Kapitel 4) oder aus einem Raw-Repository in Nexus (siehe Kapitel 3). Die Prüfsummen im Dockerfile bleiben dieselben.

Ergänze jetzt in der .gitlab-ci.yml aus Kapitel 8 einen Job in der Stage security, der beide Policy-Werkzeuge offline ausführt:

policy-check:
  stage: security
  image: reg-build:5000/tools/policy-tools:1.0.0   # Dockerfile.policy-tools
  script:
    - opa fmt --list --fail policy/
    - opa test policy/
    - conftest test k8s/
    - kyverno test tests/
    - kyverno apply policies/ --resource k8s/deployment.yaml

Das Image liegt wie das SBOM-Werkzeug aus Kapitel 7 in reg-build, nicht im Docker-Hub-Proxy von Nexus: Es ist dein eigenes Artefakt, kein gespiegeltes. Wichtig: Die Policies im Repository und im Cluster müssen dieselben sein. In der Praxis liegen sie in einem eigenen Policy-Repository, aus dem Argo CD den Cluster versorgt und das die Pipeline-Jobs der Anwendungsteams einbinden.

Schritt 13: Aufräumen

Wenn du direkt mit Kapitel 10 oder 11 weitermachst, kannst du Kyverno laufen lassen; stelle die Policies dann aber zurück auf Audit, damit spätere Labs nicht unerwartet blockiert werden:

cd ~/seclab/kap09
sed -i.bak 's/failureAction: Enforce/failureAction: Audit/' policies/*.yaml
kubectl apply -f policies/

Zum vollständigen Entfernen löschst du zuerst die Policies, dann Kyverno, und prüfst, dass keine Webhooks übrig sind:

kubectl delete -f policies/
helm uninstall kyverno -n kyverno
kubectl get validatingwebhookconfigurations,mutatingwebhookconfigurations \
  | grep -i kyverno || echo "keine Kyverno-Webhooks mehr"

Erwartet: keine Kyverno-Webhooks mehr. Das Deployment demo-app im Namespace demo darf bleiben.

Fortschritt speichern? Kostenlos registrieren

Typische Stolperfallen

Symptom Ursache Lösung
Nach Kyverno-Deinstallation schlagen alle kubectl apply fehl Verwaiste Webhooks mit failurePolicy: Fail Webhook-Konfigurationen prüfen und löschen
Policy greift nicht, READY ist False Syntax- oder Schemafehler in der Policy kubectl describe clusterpolicy <name> lesen
Pods von Deployments werden abgelehnt, das Deployment selbst nicht Autogen deaktiviert oder Regel nur für Pod Autogen-Annotation prüfen, Fehler im ReplicaSet-Event suchen (kubectl get events)
PolicyReports bleiben leer background: false oder Reports-Controller läuft nicht background: true, Pods im Namespace kyverno prüfen
:latest-Regel erkennt nginx nicht Fehlendes Tag heißt implizit latest Registry-Regel oder Digest-Pflicht ergänzen
conftest findet keine Regeln Falsches Paket oder Ordner package main und Ordner policy/, sonst --policy/--namespace
rego_parse_error: ... if Alte OPA/conftest-Version ohne v1-Unterstützung Werkzeuge aktualisieren oder import rego.v1 ergänzen
GitOps zeigt dauerhaft „OutOfSync” Kyverno-Mutation verändert Live-Objekt Werte in Git setzen oder Feld in Argo CD ignorieren

Übung: Privilegierte Container verbieten

Erweitere die Hausordnung um eine Regel: Kein Container darf securityContext.privileged: true setzen. Fehlt das Feld, ist das in Ordnung.

Deine Aufgabe:

  1. Ergänze policies/baseline.yaml um eine Kyverno-Regel kein-privileged (zuerst Audit).
  2. Ergänze tests/resources.yaml um einen Pod privilegiert und tests/kyverno-test.yaml um passende Erwartungen.
  3. Schreibe die gleiche Regel in Rego in policy/k8s.rego und einen Test in policy/k8s_test.rego.
  4. Lass kyverno test tests/ und opa test policy/ grün laufen.

Hinweis 1

Das Feld ist optional. Welcher Kyverno-Anker sagt „wenn das Feld existiert, muss es diesen Wert haben”? Du hast ihn bei den Init-Containern schon gesehen. Brauchst du ihn auf mehreren Ebenen?

Hinweis 2

In Rego reicht eine einfache Gleichheit: Ist c.securityContext.privileged == true, wird die Nachricht erzeugt. Fehlt das Feld, ist der Ausdruck undefiniert und die Regel greift nicht. Für den Test kannst du ein Deployment-Objekt direkt hinschreiben oder die Hilfsfunktion um einen Parameter erweitern.

Lösung

Kyverno-Regel (in rules von policies/baseline.yaml ergänzen):

    - name: kein-privileged
      match:
        any:
          - resources: { kinds: [Pod] }
      exclude:
        any:
          - resources:
              namespaces: [kube-system, kyverno, local-path-storage]
      validate:
        failureAction: Audit
        message: "Privilegierte Container sind verboten."
        pattern:
          spec:
            containers:
              - =(securityContext):
                  =(privileged): false

Die beiden =( )-Anker bedeuten: Wenn securityContext existiert und darin privileged steht, muss der Wert false sein. Fehlt eines davon, ist die Regel erfüllt.

Testressource (an tests/resources.yaml anhängen):

---
apiVersion: v1
kind: Pod
metadata: { name: privilegiert }
spec:
  securityContext: { runAsNonRoot: true }
  containers:
    - name: app
      image: reg-build:5000/demo-app:1.0.0
      securityContext: { privileged: true }
      resources: { limits: { cpu: 100m, memory: 64Mi } }

Erwartungen (an results in tests/kyverno-test.yaml anhängen):

  - policy: seclab-baseline
    rule: kein-privileged
    kind: Pod
    resources: [privilegiert]
    result: fail
  - policy: seclab-baseline
    rule: kein-privileged
    kind: Pod
    resources: [gut]
    result: pass

Rego-Regel und Test:

deny contains msg if {
    some c in container
    c.securityContext.privileged == true
    msg := sprintf("Container '%s': privileged ist verboten", [c.name])
}
test_privileged_verboten if {
    d := deployment("reg-build:5000/demo-app:1.0.0", true)
    c := object.union(d.spec.template.spec.containers[0],
        {"securityContext": {"privileged": true}})
    inp := object.union(d, {"spec": {"template": {"spec": {"containers": [c]}}}})
    msgs := deny with input as inp
    some msg in msgs
    contains(msg, "privileged")
}

object.union führt Objekte rekursiv zusammen; Listen werden dabei ersetzt, nicht gemischt. Deshalb baust du den geänderten Container zuerst und setzt dann die ganze Liste neu. Wer es lesbarer mag, schreibt das Test-Objekt einfach komplett aus.

Abschließend:

kyverno test tests/ && opa test policy/

Erwartet: Test Summary: 11 tests passed and 0 tests failed und PASS: 6/6.

Fortschritt speichern? Kostenlos registrieren

Aus der Praxis

Policy-Repository mit Lebenszyklus. In größeren Organisationen gibt es ein eigenes Repository für Policies, mit Code-Ownern aus dem Plattform- oder Security-Team. Jede Policy hat Tests, eine Beschreibung (Annotationen wie policies.kyverno.io/title und description) und einen Status. Neue Regeln laufen nach einem festen Muster: zwei bis vier Wochen Audit, PolicyReports auswerten, betroffene Teams informieren, dann Enforce. Die Übergangsfrist und der Umgang mit Ausnahmen werden mit den Teams vereinbart (siehe Kapitel 10).

Ausnahmen kontrolliert. Kyverno bietet dafür die Ressource PolicyException. Damit nimmst du eine bestimmte Ressource von einer bestimmten Regel aus, ohne die Policy zu ändern. Ausnahmen gehören, wie die Ignore-Dateien in Kapitel 8, ins Review mit Begründung, Owner und Ablaufdatum (zum Beispiel als Annotation, die ein Job regelmäßig prüft). Je nach Version musst du die Funktion in Kyverno erst aktivieren und auf bestimmte Namespaces beschränken; sonst könnte jeder mit Schreibrechten sich selbst ausnehmen.

Verteidigung in der Tiefe. In einer regulierten oder air-gapped Umgebung wird an mehreren Stellen geprüft: conftest und kyverno apply im Merge Request, Kyverno im Cluster als letzte Instanz, PolicyReports im Monitoring. Dazu prüft eine verifyImages-Regel, dass nur Images mit deinem eigenen Cosign-Schlüssel aus Kapitel 5 laufen. Das sieht etwa so aus:

      verifyImages:
        - imageReferences: ["reg-ziel:5000/*"]
          failureAction: Enforce
          mutateDigest: true
          attestors:
            - entries:
                - keys:
                    publicKeys: |-
                      -----BEGIN PUBLIC KEY-----
                      (Inhalt von ~/seclab/kap05/cosign.pub)
                      -----END PUBLIC KEY-----
                    rekor:
                      ignoreTlog: true
                      url: https://rekor.sigstore.dev   # wird nicht kontaktiert
                    ctlog:
                      ignoreSCT: true

ignoreTlog und ignoreSCT sind nötig, weil wir offline ohne Transparenzlog signieren. mutateDigest: true schreibt den geprüften Digest ins Pod-Manifest, damit genau das geprüfte Image läuft. Für eine Registry ohne TLS wie im Lab muss Kyverno zusätzlich mit dem Flag --allowInsecureRegistry laufen. Das vollständige Zusammenspiel baust du im Abschlussprojekt (siehe Kapitel 11).

Betrieb und Verfügbarkeit. Kyverno ist nach der Installation ein kritischer Teil des Clusters: Mit failurePolicy: Fail kann ohne Kyverno nichts mehr deployt werden. Deshalb läuft der Admission-Controller in Produktion mit mehreren Replikas, PodDisruptionBudget und eigenen Alarmen. Kyverno stellt Prometheus-Metriken bereit, etwa zu Policy-Ergebnissen und Webhook-Latenzen. Typische Alarme: Webhook-Latenz steigt, Admission-Controller nicht bereit, Zahl der fail-Ergebnisse steigt sprunghaft.

Audit-Nachweis. Prüfer fragen: Welche Regeln galten zu welchem Zeitpunkt, und wurden sie durchgesetzt? Die Antwort liegt im Git-Verlauf des Policy-Repositorys (wer hat was wann geändert und wer hat es freigegeben), in Argo CD (welcher Stand war im Cluster ausgerollt) und in den PolicyReports bzw. Kubernetes-Audit-Logs (welche Anfragen wurden abgelehnt). Exportiere PolicyReports regelmäßig in dein zentrales Logging, denn im Cluster werden sie überschrieben.

Interviewfragen

F: Was ist Admission Control, und welche zwei Arten von Webhooks gibt es? A: Admission Control ist eine Prüfstufe im API-Server nach Authentifizierung und Autorisierung, aber vor dem Speichern. Mutating Webhooks dürfen Objekte verändern, Validating Webhooks dürfen sie nur zulassen oder ablehnen. Mutation läuft vor Validierung.

F: Wie führst du eine neue Policy ein, ohne Produktion zu gefährden? A: Zuerst im Audit-Modus ausrollen, PolicyReports auswerten und betroffene Teams informieren. Nach einer vereinbarten Übergangsfrist auf Enforce umstellen. Vorher Policy-Tests in der Pipeline, damit die Regel nachweislich das Richtige erlaubt und ablehnt.

F: Was ist der Unterschied zwischen failureAction und failurePolicy in Kyverno? A: failureAction (früher validationFailureAction) legt fest, ob ein Regelverstoß nur protokolliert (Audit) oder abgelehnt wird (Enforce). failurePolicy legt fest, was passiert, wenn Kyverno selbst nicht erreichbar ist: Fail blockiert dann alle betroffenen Anfragen, Ignore lässt sie durch.

F: Kyverno oder OPA Gatekeeper, wann nimmst du was? A: Kyverno ist für Kubernetes-Teams leichter zu lernen, weil Policies YAML sind, und bringt Mutate, Generate und Signaturprüfung mit. OPA mit Rego ist allgemeiner und auch für Terraform, APIs oder CI-Prüfungen nutzbar. Häufig kombiniert man Kyverno im Cluster mit conftest in der Pipeline.

F: Warum reicht conftest in der Pipeline nicht aus? A: Weil jemand an der Pipeline vorbei direkt deployen kann, zum Beispiel per kubectl mit ausreichenden Rechten. conftest gibt frühes Feedback, Admission Control ist die verbindliche letzte Instanz. Beides zusammen ist Verteidigung in der Tiefe.

F: Wie testest du Policies? A: Für Kyverno mit kyverno test und einer kyverno-test.yaml, die für jede Regel erwartete Pass- und Fail-Ressourcen festlegt. Für Rego mit opa test und Testregeln, die mit test_ beginnen und with input as nutzen. Beide laufen offline in der Pipeline.

F: Was zeigt ein PolicyReport? A: Pro Ressource die Ergebnisse aller passenden Policy-Regeln mit pass, fail, warn, error und skip. Er entsteht bei Admission und beim Hintergrund-Scan, also auch für Objekte, die schon vor der Policy existierten. Damit misst man im Audit-Modus, wie viele Objekte eine Regel verletzen würden.

F: Was ist ein ConstraintTemplate in Gatekeeper? A: Es enthält die Rego-Logik und definiert eine neue CRD mit Parameterschema. Ein Constraint ist eine Instanz davon mit konkreten Parametern, Geltungsbereich und enforcementAction (deny, dryrun, warn). So schreibt man die Logik einmal und wendet sie mehrfach an.

Zusammenfassung

Das hast du gelernt:

  • Admission Control prüft jede schreibende Anfrage im API-Server; erst wird mutiert, dann validiert, bestehende Objekte deckt der Hintergrund-Scan ab.
  • Kyverno-Policies sind YAML mit vier Regeltypen: Validate, Mutate, Generate und VerifyImages; Pod-Regeln werden per Autogen auf Workloads übertragen.
  • Neue Regeln laufen erst im Audit-Modus, werden über PolicyReports ausgewertet und dann auf Enforce gestellt; ab Kyverno 1.13 per failureAction auf Regelebene.
  • Mit kyverno apply und kyverno test prüfst du Policies offline und automatisiert in der Pipeline.
  • Rego-Policies in aktueller v1-Syntax (deny contains msg if) prüfst du mit conftest test und sicherst sie mit opa test ab.
  • Gatekeeper trennt Logik (ConstraintTemplate) und Anwendung (Constraint); conftest bringt dieselbe Sprache shift-left in die Pipeline.
  • Policies sind kritischer Betriebsbestandteil: versioniert, getestet, überwacht, mit kontrollierten Ausnahmen und nachvollziehbarer Audit-Spur.