Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 9: Mutate und Generate

Ziel: Mit MutatingPolicy sichere Defaults setzen und mit GeneratingPolicy jedem 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) oder JSONPatch.
  • GeneratingPolicy erzeugt neue Objekte, ausgelöst durch einen „Trigger” (hier: ein Namespace). Das erledigt der Background-Controller, nicht der Webhook.
  • synchronize hält erzeugte Objekte im Sollzustand: gelöscht wird neu angelegt, geändert wird zurückgedreht.
  • generateExisting behandelt 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.yaml

Erwartet:

  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: JSONPatch

Object{…} 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.yaml

Erwartet:

  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-by

Erwartet:

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.shop

Erwartet:

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/metrics

Erwartet:

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.yaml

Erwartet:

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 -l

Erwartet:

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 -A

Erwartet (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-c

Fortschritt 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/null

Challenge

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-escalation

Erwartet:

        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).