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 testabsicherst- 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|Enforceein. Ab Kyverno 1.13 gibt esfailureActiondirekt 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 mitkyverno versionbzw.helm list -n kyverno. Neuere Kyverno-Versionen bringen außerdem CEL-basierte Policy-Typen wieValidatingPolicymit; die klassischeClusterPolicyaus 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:
inputist 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 listeläuft über alle Elemente.not ausdruckist wahr, wenn der Ausdruck falsch oder nicht definiert ist. Fehlende Felder sind in Rego „undefiniert”, nichtnull.
Merke: Seit OPA 1.0 ist die Rego-v1-Syntax Standard:
ifvor dem Regelrumpf undcontainsfür Mengenregeln sind Pflicht. Die Zeileimport rego.v1schadet 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 nochdeny[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
enforcementActionmitdeny,dryrunoderwarn. - conftest läuft in der Pipeline oder lokal auf
Dateien. Es sucht standardmäßig Rego-Dateien im Ordner
policy/mitpackage mainund wertet die Regelndeny,violationundwarnaus.
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 nodesErwartete 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 -1Lege 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 }
EOFAuffä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 podsErwartete 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 clusterpolicyErwartete 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
containersprüft Kyverno jedes Element gegen das Muster. =(initContainers)heißt: Wenn es Init-Container gibt, gilt dieselbe Regel für sie.excludenimmt 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 implizitnginx: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.yamlWende 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-labelsErwartete 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.0Beide 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 -AErwartete 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:latestErwartete 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.0Erwartet: 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.yamlErwartet: 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.yamlErwartete 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.yamlErwartet: 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
EOFJetzt 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
resultsnochresource(Einzahl). Bei Fehlermeldungen zum Schema prüfekyverno test --helpund 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])
}
EOFWas hier passiert:
containerist eine Hilfsmenge. Zwei Regeln mit demselben Kopf bedeuten ODER: Container aus Workloads oder aus Pods.pod_specist ein Wert, der je nach Art des Objekts definiert ist. Für einenServiceist er undefiniert; dann greifen die Regeln nicht.not c.resources.limits.memoryist wahr, wenn das Feld fehlt. Du musst nicht jede Ebene einzeln prüfen.warnstattdenybeim Label: In der Pipeline erinnert das, blockiert aber nicht, weil Kyverno im Cluster das Label im Namespacedemoohnehin 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 sarifwird von neueren conftest-Versionen ebenfalls unterstützt (sieheconftest 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/ -vErwartete 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 podsErwartet: 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.yamlAchtung: Gatekeeper-Templates im Feld
regowerden klassisch in der älteren v0-Syntax geschrieben (ohneif/contains), wie hier gezeigt. Neuere Gatekeeper-Versionen erlauben Rego v1 über einencode-Block mit Versionsangabe. Prüfe dazu die Doku deiner Gatekeeper-Version. Beachte auch: Gatekeeper übergibt das Objekt unterinput.review.object, conftest direkt alsinput.
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.27Mit 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-seclabSchritt 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 10001Die 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.yamlDas 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:
- Ergänze
policies/baseline.yamlum eine Kyverno-Regelkein-privileged(zuerst Audit). - Ergänze
tests/resources.yamlum einen Podprivilegiertundtests/kyverno-test.yamlum passende Erwartungen. - Schreibe die gleiche Regel in Rego in
policy/k8s.regound einen Test inpolicy/k8s_test.rego. - Lass
kyverno test tests/undopa 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): falseDie 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: passRego-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: trueignoreTlog 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
failureActionauf Regelebene. - Mit
kyverno applyundkyverno testprüfst du Policies offline und automatisiert in der Pipeline. - Rego-Policies in aktueller v1-Syntax
(
deny contains msg if) prüfst du mitconftest testund sicherst sie mitopa testab. - 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.