Tag 9: Mutate und Generate
Ziel: Mit
MutatingPolicysichere Defaults setzen und mitGeneratingPolicyjedem Mandanten-Namespace automatisch Default-Deny und DNS-Freigabe mitgeben. · Dauer: ca. 90 min · Voraussetzung: Tag 3, Tag 8
Briefing
MutatingPolicyändert Objekte im Admission-Request, bevor sie validiert werden:ApplyConfiguration(Merge wie Server-Side Apply) oderJSONPatch.GeneratingPolicyerzeugt neue Objekte, ausgelöst durch einen „Trigger” (hier: ein Namespace). Das erledigt der Background-Controller, nicht der Webhook.synchronizehält erzeugte Objekte im Sollzustand: gelöscht wird neu angelegt, geändert wird zurückgedreht.generateExistingbehandelt auch Trigger, die es schon vor der Policy gab.
kubectl create ns tenant-c (tenant=c)
└─> Admission: GeneratingPolicy matcht ──> UpdateRequest
└─> Background-Controller ──> default-deny + allow-dns in tenant-c
Drill 1: Defaults per MutatingPolicy
Die Validate-Policies aus Tag 8 räumst du weg, damit heute nur Mutate
und Generate wirken. Die Dateien bleiben in
~/guard-lab/tag08.
mkdir -p ~/guard-lab/tag09 && cd ~/guard-lab/tag09
kubectl delete vpol --all
cp ~/guard-lab/code/kyverno/tag09/*.yaml .
sed -n '/mutations:/,/JSONPatch/p' pod-defaults.yamlErwartet:
mutations:
- patchType: ApplyConfiguration
applyConfiguration:
expression: >-
Object{
metadata: Object.metadata{
labels: {"guard-lab/defaults": "applied"}
},
spec: Object.spec{
securityContext: Object.spec.securityContext{
runAsNonRoot: object.spec.?securityContext.?runAsNonRoot
.orValue(true),
seccompProfile: Object.spec.securityContext.seccompProfile{
type: object.spec.?securityContext.?seccompProfile.?type
.orValue("RuntimeDefault")
}
}
}
}
- patchType: JSONPatchObject{…} beschreibt nur die Felder, die du setzen
willst. Kyverno merged sie wie Server-Side Apply ins Objekt.
orValue() sorgt dafür, dass ein bewusst gesetzter Wert des
Teams erhalten bleibt: Default heißt „nur wenn leer”.
Achtung: Map-Schlüssel mit Schrägstrich gehen nicht als Feldname (
Object.metadata.labels{"guard-lab/defaults": …}ist ein Syntaxfehler). Nimm ein Map-Literal{"…": "…"}, das wird ebenfalls gemerged.
kubectl apply -f pod-defaults.yaml
kubectl get mpol
kubectl apply -f plain-pod.yaml
kubectl -n shop get pod plain -o json | jq -c '{labels: .metadata.labels,
sc: .spec.securityContext, pull: [.spec.containers[].imagePullPolicy]}'Erwartet:
mutatingpolicy.policies.kyverno.io/pod-defaults created
NAME AGE READY
pod-defaults 4s true
pod/plain created
{"labels":{"app":"plain","guard-lab/defaults":"applied"},"sc":{"runAsNonRoot":true,
"seccompProfile":{"type":"RuntimeDefault"}},"pull":["IfNotPresent","Always"]}
Label und Pod-securityContext sind gesetzt. Der
Container side behält sein explizites
Always.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Die Defaulting-Falle bei imagePullPolicy
Naheliegende Idee: „Setze imagePullPolicy: IfNotPresent,
wenn das Feld fehlt.” In der Kyverno-CLI funktioniert das. Im Cluster
nie:
kubectl run latest -n default -l app=latest --image=nginxinc/nginx-unprivileged:latest \
--dry-run=server -o jsonpath='{.spec.containers[0].imagePullPolicy}{"\n"}'
kubectl run tagged -n default -l app=x --image=nginxinc/nginx-unprivileged:1.31-alpine \
--dry-run=server -o jsonpath='{.spec.containers[0].imagePullPolicy}{"\n"}'Erwartet:
Always
IfNotPresent
Der API-Server setzt Defaults (Always bei
:latest oder ohne Tag, sonst IfNotPresent),
bevor Mutating-Webhooks laufen. Für Kyverno fehlt das
Feld also nie. Die CLI kennt kein Defaulting und zeigt dir eine
Mutation, die im Cluster nicht passiert. Darum mutiert
pod-defaults etwas Sinnvolleres: Bei einem Digest ist
Always nutzlos, denn der Inhalt kann sich nicht ändern.
sed -n '/JSONPatch/,$p' pod-defaults.yaml | sed -n '3,12p'
I=nginxinc/nginx-unprivileged@sha256:\
33594ea8c022029e6607bafee25871d224b5f7ca6e17c68d187b68718513a5b1
kubectl run dig -n shop -l app=dig --image=$I --image-pull-policy=Always \
--dry-run=server -o jsonpath='{.spec.containers[0].imagePullPolicy}{"\n"}'Erwartet:
expression: >-
object.spec.containers.map(c, object.spec.containers.indexOf(c))
.filter(i, object.spec.containers[i].image.contains("@sha256:") &&
object.spec.containers[i].imagePullPolicy == "Always")
.map(i, JSONPatch{
op: "replace",
path: "/spec/containers/" + string(i) + "/imagePullPolicy",
value: "IfNotPresent"
})
IfNotPresent
JSONPatch braucht Indizes im Pfad. Darum wandelt
map(… indexOf(c)) die Container erst in ihre Positionen
um.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Default-Deny für jeden neuen Mandanten
Das Muster aus Tag 1 und 2 (Default-Deny plus DNS) soll kein Team
mehr vergessen können. Trigger ist jeder Namespace mit dem Label
tenant.
kubectl -n shop delete pod plain
sed -n '/matchConstraints/,/- name: policies/p' tenant-netpol.yaml
grep -A1 '^ generate' tenant-netpol.yamlErwartet:
matchConstraints:
resourceRules:
- apiGroups: [""]
apiVersions: [v1]
operations: [CREATE, UPDATE]
resources: [namespaces]
objectSelector:
matchExpressions:
- {key: tenant, operator: Exists}
variables:
- name: ns
expression: object.metadata.name
- name: labels
expression: >-
{"guard-lab/tenant": object.metadata.labels["tenant"]}
- name: policies
generate:
- expression: generator.Apply(variables.ns, variables.policies)Die Variable policies ist eine Liste mit beiden
NetworkPolicies als CEL-Maps (im Code ansehen). dyn() um
die Werte braucht CEL, weil die Map gemischte Typen enthält.
generator.Apply(namespace, liste) legt alles im
Ziel-Namespace an. Bei Namespace-Objekten prüft
objectSelector die Labels des Namespace selbst.
kubectl apply -f tenant-netpol.yaml
kubectl get gpol
cat ns-c.yaml | grep labels
kubectl apply -f ns-c.yaml
sleep 5
kubectl -n tenant-c get netpol -L guard-lab/tenant,app.kubernetes.io/managed-byErwartet:
generatingpolicy.policies.kyverno.io/tenant-netpol created
NAME AGE
tenant-netpol 4s
labels: {guard-lab: demo, team: tenant-c, tenant: c}
namespace/tenant-c created
NAME POD-SELECTOR AGE TENANT MANAGED-BY
allow-dns <none> 5s c kyverno
default-deny <none> 5s c kyverno
managed-by=kyverno und weitere
generate.kyverno.io/*-Labels setzt Kyverno selbst. Über sie
findet es seine Objekte wieder. Jetzt der Beweis mit einem Client im
neuen Namespace:
sed 's/namespace: default/namespace: tenant-c/' ~/guard-lab/code/demo/40-client.yaml \
| kubectl apply -f -
kubectl -n tenant-c wait --for=condition=Ready pod/client --timeout=60s
kubectl -n tenant-c exec client -- nslookup api.shop.svc.cluster.local \
| grep -A1 '^Name'
alias cc=~/guard-lab/code/demo/conncheck.sh # wie in Tag 1
cc tenant-c/client http://api.shop
cc default/client http://api.shopErwartet:
pod/client created
pod/client condition met
Name: api.shop.svc.cluster.local
Address: 10.96.92.233
✘ blockiert tenant-c/client -> http://api.shop (Timeout)
✔ erlaubt default/client -> http://api.shop (HTTP 200)
DNS geht, alles andere ist zu. Genau das Verhalten aus Tag 2, nur ohne Handarbeit.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Synchronisation – löschen und ändern zwecklos
kubectl -n tenant-c delete netpol default-deny
sleep 8
kubectl -n tenant-c get netpol
kubectl -n tenant-c patch netpol allow-dns --type merge \
-p '{"spec":{"policyTypes":["Ingress","Egress"],"ingress":[{}]}}'
sleep 8
kubectl -n tenant-c get netpol allow-dns -o jsonpath='{.spec.policyTypes}{"\n"}'Erwartet:
networkpolicy.networking.k8s.io "default-deny" deleted from tenant-c namespace
NAME POD-SELECTOR AGE
allow-dns <none> 30s
default-deny <none> 8s
networkpolicy.networking.k8s.io/allow-dns patched
["Egress"]
Der Patch hätte allen Ingress erlaubt (ingress: [{}]).
Kyverno hat ihn zurückgedreht. Wer Ausnahmen braucht, schreibt eine
zusätzliche NetworkPolicy. Die wirken additiv (Tag 1),
und die generierten bleiben unangetastet.
Achtung: Synchronisation ist kein Schutz gegen Admins. Wer NetworkPolicies löschen darf, öffnet das Netz für einige Sekunden. RBAC bleibt die erste Linie.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Bestehende Namespaces nachziehen
tenant-a und tenant-b gab es schon vor der
Policy. Sie haben nichts bekommen:
kubectl get netpol -n tenant-a
kubectl patch gpol tenant-netpol --type merge \
-p '{"spec":{"evaluation":{"generateExisting":{"enabled":true}}}}'
sleep 10
kubectl get netpol -A -l app.kubernetes.io/managed-by=kyverno
cc monitoring/scraper http://api.tenant-a:9113/metricsErwartet:
No resources found in tenant-a namespace.
generatingpolicy.policies.kyverno.io/tenant-netpol patched
NAMESPACE NAME POD-SELECTOR AGE
tenant-a allow-dns <none> 10s
tenant-a default-deny <none> 10s
tenant-b allow-dns <none> 10s
tenant-b default-deny <none> 10s
tenant-c allow-dns <none> 53s
tenant-c default-deny <none> 31s
✘ blockiert monitoring/scraper -> http://api.tenant-a:9113/metrics (Timeout)
generateExisting holt alle passenden Bestandsobjekte
nach. Und sofort ist das Monitoring kaputt: Default-Deny gilt auch für
den Scraper. Genau das passiert beim Kunden, wenn Default-Deny „mal
eben” für alle Namespaces aktiviert wird. Erst Freigaben generieren,
dann Deny.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Klonen aus einem Vorlagen-Namespace
Das Plattform-Team pflegt Standard-Freigaben einmal im Namespace
netpol-templates. Eine zweite GeneratingPolicy klont sie in
jeden Mandanten.
kubectl create ns netpol-templates
kubectl apply -f tpl-allow-monitoring.yaml
sed -n '/variables:/,$p' clone-monitoring.yamlErwartet:
namespace/netpol-templates created
networkpolicy.networking.k8s.io/allow-monitoring created
variables:
- name: source
expression: >-
resource.Get("networking.k8s.io/v1", "networkpolicies",
"netpol-templates", "allow-monitoring")
generate:
- expression: generator.Apply(object.metadata.name, [variables.source])resource.Get() liest das Quellobjekt,
generator.Apply() legt es als Kopie an. Das ist der „Clone
Source”-Modus.
kubectl apply -f clone-monitoring.yaml
sleep 10
kubectl get netpol -A | grep allow-monitoring
cc monitoring/scraper http://api.tenant-a:9113/metrics
cc monitoring/scraper http://api.tenant-a/Erwartet:
generatingpolicy.policies.kyverno.io/clone-monitoring created
netpol-templates allow-monitoring tier=api 10s
tenant-a allow-monitoring tier=api 10s
tenant-b allow-monitoring tier=api 10s
tenant-c allow-monitoring tier=api 10s
✔ erlaubt monitoring/scraper -> http://api.tenant-a:9113/metrics (HTTP 200)
✘ blockiert monitoring/scraper -> http://api.tenant-a/ (Timeout)
Metriken ja, Anwendung nein. Jetzt ändert das Plattform-Team die Vorlage:
kubectl -n netpol-templates patch netpol allow-monitoring --type json \
-p '[{"op":"add","path":"/spec/ingress/0/ports/-",
"value":{"protocol":"TCP","port":9114}}]'
sleep 20
C='NS:.metadata.namespace,NAME:.metadata.name'
C="$C,PORTS:.spec.ingress[0].ports[*].port"
kubectl get netpol -A -o "custom-columns=$C" | grep -E '^NS|monitoring'Erwartet:
networkpolicy.networking.k8s.io/allow-monitoring patched
NS NAME PORTS
netpol-templates allow-monitoring 9113,9114
tenant-a allow-monitoring 9113,9114
tenant-b allow-monitoring 9113,9114
tenant-c allow-monitoring 9113,9114
Die Änderung an spec wurde in alle Kopien
synchronisiert. Ein reines Label an der Vorlage dagegen kam im Test
(Kyverno 1.19.1) nicht an, bis der Trigger-Namespace selbst geändert
wurde. Verlass dich bei Metadaten also nicht auf die
Synchronisation.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Lebenszyklus – was bleibt, was geht?
kubectl label ns tenant-c tenant-
sleep 10
kubectl -n tenant-c get netpol --no-headers | wc -l
kubectl delete gpol tenant-netpol
sleep 30
kubectl get netpol -A -l generate.kyverno.io/policy-name=tenant-netpol \
--no-headers | wc -lErwartet:
namespace/tenant-c unlabeled
3
generatingpolicy.policies.kyverno.io "tenant-netpol" deleted
6
Beides bleibt stehen. Ohne Label matcht der
objectSelector nicht mehr, Kyverno sieht das Update gar
nicht. Und auch nach dem Löschen der Policy bleiben die NetworkPolicies.
Die Kyverno-Doku beschreibt für die Daten-Quelle mit
synchronize ein Mitlöschen, in 1.19.1 beobachtet: Sie
bleiben. Für Netzwerksicherheit ist das die gute Richtung, denn eine
versehentlich gelöschte Policy öffnet kein Netz. Aufräumen musst du
selbst:
kubectl delete netpol -A -l generate.kyverno.io/policy-name=tenant-netpol
kubectl -n netpol-templates delete netpol allow-monitoring
sleep 12
kubectl get netpol -AErwartet (gekürzt):
networkpolicy.networking.k8s.io "allow-dns" deleted from tenant-a namespace
...
networkpolicy.networking.k8s.io "allow-monitoring" deleted from netpol-templates
namespace
No resources found
Beim Klon gilt dagegen wie dokumentiert: Quelle gelöscht, Kopien gelöscht. Zum Schluss:
kubectl delete gpol clone-monitoring
kubectl delete mpol pod-defaults
kubectl delete ns netpol-templates tenant-cFortschritt speichern? Kostenlos registrieren
Kontrollpunkt
Spiel den Kern noch einmal sauber durch: Policies anlegen, neuen Mandanten erzeugen, prüfen, aufräumen.
ok() { echo "✔ $1"; }; nok() { echo "✘ $1"; }
cd ~/guard-lab/tag09
kubectl apply -f pod-defaults.yaml -f tenant-netpol.yaml >/dev/null
kubectl create ns tenant-k --dry-run=client -o yaml \
| kubectl label --local -f - guard-lab=demo team=tenant-k tenant=k -o yaml \
| kubectl apply -f - >/dev/null
sleep 8
[ "$(kubectl -n tenant-k get netpol --no-headers 2>/dev/null | wc -l)" -eq 2 ] \
&& ok "tenant-k hat 2 NetworkPolicies" || nok "NetworkPolicies fehlen"
kubectl -n tenant-k delete netpol default-deny >/dev/null; sleep 8
kubectl -n tenant-k get netpol default-deny >/dev/null 2>&1 \
&& ok "default-deny wiederhergestellt" || nok "keine Synchronisation"
L=$(kubectl run t -n tenant-k -l app=t --image=nginxinc/nginx-unprivileged:1.31-alpine \
--dry-run=server -o json | jq -r '.metadata.labels["guard-lab/defaults"]')
[ "$L" = applied ] && ok "pod-defaults mutiert" || nok "keine Mutation"
kubectl delete ns tenant-k >/dev/null
kubectl delete gpol tenant-netpol >/dev/null
kubectl delete mpol pod-defaults >/dev/nullChallenge
Ergänze per MutatingPolicy in jedem Container der
Demo-Namespaces
securityContext.allowPrivilegeEscalation: false, aber nur,
wenn das Team nichts gesetzt hat. Teste mit
kubectl run … --dry-run=server.
Hinweis: In ApplyConfiguration kannst
du containers als Liste von
Object.spec.containers{name: …, …} angeben. Der
name ist der Merge-Schlüssel.
Lösung
sed -n '/expression/,$p' no-escalation.yaml
kubectl apply -f no-escalation.yaml
kubectl run esc -n tenant-a -l app=esc --image=nginxinc/nginx-unprivileged:1.31-alpine \
--dry-run=server -o json | jq -c '[.spec.containers[] | {name, securityContext}]'
kubectl delete mpol no-escalationErwartet:
expression: >-
Object{
spec: Object.spec{
containers: object.spec.containers.map(c, Object.spec.containers{
name: c.name,
securityContext: Object.spec.containers.securityContext{
allowPrivilegeEscalation: c.?securityContext
.?allowPrivilegeEscalation.orValue(false)
}
})
}
}
mutatingpolicy.policies.kyverno.io/no-escalation created
[{"name":"esc","securityContext":{"allowPrivilegeEscalation":false}}]
mutatingpolicy.policies.kyverno.io "no-escalation" deleted
Weil containers per name gemerged wird,
bleiben Image, Ports und alle anderen Felder erhalten.
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Generierte NetworkPolicies sind ein Baseline-Vertrag. Team-spezifische Freigaben liegen als eigene Policies im Team-Repo, nie als Änderung an den generierten.
- Default-Deny für Bestands-Namespaces nur mit Vorlauf aktivieren: erst Freigaben (Monitoring, Ingress-Controller, Service-Mesh) generieren, Hubble/Flow-Logs prüfen.
- Mit Argo CD: generierte Objekte tragen Kyverno-Labels und gehören nicht ins Git. Argo CD darf sie nicht als „OutOfSync” löschen (Resource-Exclusions, Tag 13).
- Mutationen verstecken Konfiguration. Was Kyverno setzt, sollte in der Doku der Plattform stehen, sonst sucht ein Team stundenlang, woher ein Label kommt.
- Der Background-Controller braucht RBAC für jede generierte
Ressourcenart. Für NetworkPolicies bringt das Chart sie mit, für eigene
CRDs musst du ClusterRoles ergänzen
(
rbac.kyverno.io/aggregate-to-background-controller).