Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 12: Fehler durch Kyverno

Ziel: Du erkennst, wann eine Policy der Grund für einen Fehler ist, findest sie über Meldung, Event und Live-Objekt und bekommst einen Namespace frei, wenn der Webhook ausfällt. · Dauer: ca. 75 min · Voraussetzung: Tag 11

Briefing

  • Kyverno hängt sich als Admission-Webhook in den API-Server. Seine Meldungen beginnen mit admission webhook "…kyverno.svc…" – daran erkennst du den Absender.
  • Lehnt eine Policy nur Pods ab, wird das Deployment angenommen; das Event steht am ReplicaSet, wie bei PSA (Tag 11).
  • Eine Mutation ändert das Objekt beim Anlegen. Was im Cluster steht, ist nicht mehr, was in deiner Datei steht.
  • Ist der Webhook nicht erreichbar und steht failurePolicy: Fail, scheitert jede passende Änderung.
Fehlerbild Symptom Wo die Antwort steht
Validierung denied the request: Policy … Meldung beim apply
Nur Pods geprüft Deployment 0/1 Event am ReplicaSet
Mutation CreateContainerConfigError Live-Objekt, --dry-run=server
Webhook weg failed calling webhook Endpoints von kyverno-svc
Ausnahme wirkungslos Warnung beim apply Startparameter

Drill 1: Kyverno installieren

Im Labor läuft jeder Controller einmal – das spart Speicher.

# auf cp1
mkdir -p ~/debug/tag12 && cd ~/debug/tag12
helm repo add kyverno https://kyverno.github.io/kyverno/
helm repo update kyverno
cat > kyverno-values.yaml <<'EOF'
admissionController:
  replicas: 1
backgroundController:
  replicas: 1
cleanupController:
  replicas: 1
reportsController:
  replicas: 1
EOF
helm upgrade --install kyverno kyverno/kyverno -n kyverno --create-namespace \
  --version 3.10.0 -f kyverno-values.yaml --wait --timeout 5m | grep -E 'STATUS|REV'
kubectl -n kyverno get pods
kubectl api-resources --api-group=policies.kyverno.io \
  | grep -E 'NAME|^validating|^muta|exc'

Erwartet (gekürzt):

STATUS: deployed
REVISION: 1
NAME                                            READY   STATUS    RESTARTS   AGE
kyverno-admission-controller-b5f755d76-ctlx6    1/1     Running   0          39s
kyverno-background-controller-fbf6dc4b9-lz8qb   1/1     Running   0          38s
kyverno-cleanup-controller-c9cc448b4-zl4fd      1/1     Running   0          39s
kyverno-reports-controller-758c89b484-7pwpm     1/1     Running   0          39s
NAME                 SHORTNAMES   APIVERSION               NAMESPACED   KIND
mutatingpolicies     mpol         policies.kyverno.io/v1   false        MutatingPolicy
policyexceptions                  policies.kyverno.io/v1   true         PolicyException
validatingpolicies   vpol         policies.kyverno.io/v1   false        ValidatingPolicy

Kyverno 1.20 (Chart 3.10.0) arbeitet mit den CEL-basierten Typen aus policies.kyverno.io/v1. Die alten ClusterPolicy/Policy aus kyverno.io/v1 gibt es noch, Helm warnt aber bei jedem Upgrade, dass sie verschwinden.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Die Policy lehnt das Deployment ab

Einbauen:

# auf cp1
kubectl create namespace tag12
cat > team-label.yaml <<'EOF'
apiVersion: policies.kyverno.io/v1
kind: ValidatingPolicy
metadata: {name: require-team-label}
spec:
  validationActions: [Deny]
  matchConstraints:
    namespaceSelector:
      matchLabels: {kubernetes.io/metadata.name: tag12}
    resourceRules:
    - apiGroups: [apps]
      apiVersions: [v1]
      operations: [CREATE, UPDATE]
      resources: [deployments]
  validations:
  - message: Jedes Deployment braucht das Label team.
    expression: has(object.metadata.labels) && 'team' in object.metadata.labels
EOF
kubectl apply -f team-label.yaml
kubectl get vpol

Erwartet:

validatingpolicy.policies.kyverno.io/require-team-label created
NAME                 AGE   READY
require-team-label   3s    true

Symptom:

# auf cp1
cat > web.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: web, namespace: tag12}
spec:
  replicas: 1
  selector: {matchLabels: {app: web}}
  template:
    metadata: {labels: {app: web}}
    spec:
      containers:
      - name: web
        image: nginxinc/nginx-unprivileged:1.29
        resources: {limits: {memory: 64Mi}}
EOF
kubectl apply -f web.yaml

Erwartet (Zeile umbrochen):

Error from server: error when creating "web.yaml": admission webhook
  "vpol.validate.kyverno.svc-fail" denied the request: Policy require-team-label
  failed: Jedes Deployment braucht das Label team.

Untersuchen: Die Meldung nennt alles: Absender (vpol.validate.kyverno.svc), die Policy und ihre message. -fail im Webhook-Namen heißt failurePolicy: Fail.

Ursache: Das Deployment hat kein Label team in seinen eigenen metadata – das Label im Pod-Template zählt für diese Regel nicht.

Fix:

# auf cp1
sed -i 's/namespace: tag12}/namespace: tag12, labels: {team: shop}}/' web.yaml
kubectl apply -f web.yaml
kubectl -n tag12 rollout status deploy/web

Nachweis:

# auf cp1
kubectl -n tag12 get deploy web

Erwartet:

NAME   READY   UP-TO-DATE   AVAILABLE   AGE
web    1/1     1            1           5s

Fortschritt speichern? Kostenlos registrieren

Drill 3: Die Policy prüft nur Pods

Einbauen: Jeder Container braucht ein Memory-Limit. Ein Label soll den Ausstieg erlauben:

# auf cp1
cat > memory-limit.yaml <<'EOF'
apiVersion: policies.kyverno.io/v1
kind: ValidatingPolicy
metadata: {name: require-memory-limit}
spec:
  validationActions: [Deny]
  matchConstraints:
    namespaceSelector:
      matchLabels: {kubernetes.io/metadata.name: tag12}
    objectSelector:
      matchExpressions:
      - {key: policy.labor.test/skip, operator: DoesNotExist}
    resourceRules:
    - apiGroups: [""]
      apiVersions: [v1]
      operations: [CREATE, UPDATE]
      resources: [pods]
  validations:
  - message: Jeder Container braucht ein Memory-Limit.
    expression: >-
      object.spec.containers.all(c,
        c.?resources.?limits.?memory.orValue('') != '')
EOF
kubectl apply -f memory-limit.yaml
cat > api.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: api, namespace: tag12, labels: {team: shop}}
spec:
  replicas: 1
  selector: {matchLabels: {app: api}}
  template:
    metadata: {labels: {app: api}}
    spec:
      containers:
      - name: api
        image: traefik/whoami:v1.11
EOF
kubectl apply -f api.yaml

Erwartet:

validatingpolicy.policies.kyverno.io/require-memory-limit created
deployment.apps/api created

Symptom:

# auf cp1
kubectl -n tag12 get deploy api

Erwartet:

NAME   READY   UP-TO-DATE   AVAILABLE   AGE
api    0/1     0            0           5s

Untersuchen:

# auf cp1
kubectl -n tag12 events --types=Warning | grep ReplicaSet/api | tail -1
kubectl get vpol require-memory-limit -o jsonpath='{.status.autogen}{"\n"}'

Erwartet (Zeile umbrochen):

0s (x11 over 5s)   Warning   FailedCreate   ReplicaSet/api-594fdbd485   Error creating:
  admission webhook "vpol.validate.kyverno.svc-fail-a5928e6d" denied the request:
  Policy require-memory-limit failed: Jeder Container braucht ein Memory-Limit.
{}

Ursache: Kyverno erzeugt aus Pod-Regeln normalerweise automatisch passende Regeln für Deployments, StatefulSets, Jobs und CronJobs (Autogen). Dann wäre schon das apply gescheitert. Ein objectSelector schaltet Autogen ab – status.autogen ist leer. Ohne objectSelector stünden dort die erzeugten Regeln ("configs": {"cronjobs": …}), und der Fehler käme sofort beim apply.

Fix:

# auf cp1
kubectl -n tag12 set resources deploy/api --limits=memory=64Mi
kubectl -n tag12 rollout status deploy/api

Nachweis:

# auf cp1
kubectl -n tag12 get deploy api

Erwartet:

NAME   READY   UP-TO-DATE   AVAILABLE   AGE
api    1/1     1            1           5s

Fortschritt speichern? Kostenlos registrieren

Drill 4: Die Mutation, die keiner bestellt hat

Einbauen: Die Plattform setzt „sicherheitshalber“ runAsNonRoot in jeden Pod:

# auf cp1
cat > non-root.yaml <<'EOF'
apiVersion: policies.kyverno.io/v1
kind: MutatingPolicy
metadata: {name: add-run-as-non-root}
spec:
  matchConstraints:
    namespaceSelector:
      matchLabels: {kubernetes.io/metadata.name: tag12}
    resourceRules:
    - apiGroups: [""]
      apiVersions: [v1]
      operations: [CREATE]
      resources: [pods]
  mutations:
  - patchType: ApplyConfiguration
    applyConfiguration:
      expression: >-
        Object{
          spec: Object.spec{
            securityContext: Object.spec.securityContext{
              runAsNonRoot: true
            }
          }
        }
EOF
kubectl apply -f non-root.yaml
cat > batch.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: batch, namespace: tag12, labels: {team: shop}}
spec:
  replicas: 1
  selector: {matchLabels: {app: batch}}
  template:
    metadata: {labels: {app: batch}}
    spec:
      containers:
      - name: batch
        image: busybox:1.37
        command: [sleep, infinity]
        resources: {limits: {memory: 32Mi}}
EOF
kubectl apply -f batch.yaml

Symptom (nach etwa 10 Sekunden):

# auf cp1
kubectl -n tag12 get pods -l app=batch
kubectl -n tag12 get pod -l app=batch \
  -o jsonpath='{.items[0].status.containerStatuses[0].state.waiting.message}{"\n"}'

Erwartet (Zeile umbrochen):

NAME                     READY   STATUS                       RESTARTS   AGE
batch-5dfb4ccd44-bfh8q   0/1     CreateContainerConfigError   0          10s
container has runAsNonRoot and image will run as root (pod:
  "batch-5dfb4ccd44-bfh8q_tag12(f8705a24-106a-4553-a10a-9e9b2e663891)", container:
  batch)

Untersuchen: In batch.yaml steht kein securityContext. Im Cluster schon:

# auf cp1
grep -c securityContext batch.yaml
kubectl -n tag12 get deploy batch \
  -o jsonpath='{.spec.template.spec.securityContext}{"\n"}'
kubectl diff -f batch.yaml; echo "diff: $?"
kubectl apply -f batch.yaml --dry-run=server \
  -o jsonpath='{.spec.template.spec.securityContext}{"\n"}'

Erwartet:

0
{"runAsNonRoot":true}
diff: 0
{"runAsNonRoot":true}

Ursache: Die MutatingPolicy hat per Autogen schon das Deployment verändert, nicht erst den Pod. kubectl diff zeigt keinen Unterschied, weil es selbst durch die Admission läuft und dieselbe Mutation bekommt – eine Falle. Der Server-Dry-Run verrät die Mutation, und kubectl get mpol zeigt, wer sie macht. Das Image busybox läuft als root, also verweigert das kubelet den Start.

Fix: Der Pod läuft als normaler Benutzer – damit ist runAsNonRoot erfüllt:

# auf cp1
sed -i 's/^    spec:$/    spec:\n      securityContext: {runAsUser: 65534}/' batch.yaml
kubectl apply -f batch.yaml
kubectl -n tag12 rollout status deploy/batch

Nachweis:

# auf cp1
kubectl -n tag12 get pods -l app=batch
kubectl -n tag12 get deploy batch \
  -o jsonpath='{.spec.template.spec.securityContext}{"\n"}'

Erwartet:

NAME                     READY   STATUS    RESTARTS   AGE
batch-68657847b4-q8dhm   1/1     Running   0          2s
{"runAsNonRoot":true,"runAsUser":65534}

Fortschritt speichern? Kostenlos registrieren

Drill 5: Der Webhook ist nicht erreichbar

Einbauen: Der Service des Admission-Controllers verliert seine Endpoints – so, wie es ein falscher Selektor, eine NetworkPolicy oder ein ausgefallener Knoten tut:

Achtung: Danach scheitert jede Pod-Erzeugung in tag12. Nur im Labor.

# auf cp1
kubectl -n kyverno patch svc kyverno-svc --type=merge \
  -p '{"spec":{"selector":{"app.kubernetes.io/component":"admission"}}}'
kubectl -n tag12 scale deploy web --replicas=2

Symptom:

# auf cp1
kubectl -n tag12 get deploy web
kubectl -n tag12 run t --image=busybox:1.37 -- sleep 5

Erwartet (Zeile umbrochen):

NAME   READY   UP-TO-DATE   AVAILABLE   AGE
web    1/2     1            1           3m10s
Error from server (InternalError): Internal error occurred: failed calling webhook
  "mpol.validate.kyverno.svc-fail": failed to call webhook: Post
  "https://kyverno-svc.kyverno.svc:443/mpol/add-run-as-non-root?timeout=10s": no
  endpoints available for service "kyverno-svc"

Untersuchen: Das ist Tag 7 – ein Service ohne Endpoints:

# auf cp1
kubectl -n kyverno get endpointslice -l kubernetes.io/service-name=kyverno-svc
kubectl -n kyverno get svc kyverno-svc -o jsonpath='{.spec.selector}{"\n"}'
kubectl -n kyverno get pods -l app.kubernetes.io/component=admission-controller
kubectl get validatingwebhookconfiguration kyverno-resource-validating-webhook-cfg \
  -o jsonpath='{range .webhooks[*]}{.name} {.failurePolicy}{"\n"}{end}'

Erwartet (gekürzt):

NAME                ADDRESSTYPE   PORTS     ENDPOINTS   AGE
kyverno-svc-fm4qc   IPv4          <unset>   <unset>     4m3s
{"app.kubernetes.io/component":"admission","app.kubernetes.io/instance":"kyverno",...}
NAME                                           READY   STATUS    RESTARTS   AGE
kyverno-admission-controller-b5f755d76-hhv9r   1/1     Running   0          2m
protect-generation-labels.kyverno.svc Fail
vpol.validate.kyverno.svc-fail-7e0c34a0 Fail
vpol.validate.kyverno.svc-fail-a5928e6d Fail

Ursache: Der Pod läuft, aber der Selektor des Service sucht component=admission statt admission-controller. Der API-Server erreicht den Webhook nicht, und wegen failurePolicy: Fail lehnt er die Anfrage ab, statt sie durchzulassen. Löschen geht weiter – die Webhooks hören nur auf CREATE und UPDATE.

Fix:

# auf cp1
kubectl -n kyverno patch svc kyverno-svc --type=merge \
  -p '{"spec":{"selector":{"app.kubernetes.io/component":"admission-controller"}}}'

Nachweis (nach etwa einer halben Minute; der ReplicaSet-Controller wartet mit Backoff):

# auf cp1
kubectl -n kyverno get endpointslice -l kubernetes.io/service-name=kyverno-svc
kubectl -n tag12 rollout status deploy/web

Erwartet:

NAME                ADDRESSTYPE   PORTS   ENDPOINTS    AGE
kyverno-svc-fm4qc   IPv4          9443    10.42.2.79   4m29s
deployment "web" successfully rolled out

Warum nicht kubectl -n kyverno scale deploy kyverno-admission-controller --replicas=0 für den Drill? Im Labor räumt Kyverno 1.20 beim geordneten Herunterfahren seine Ressourcen-Webhooks selbst ab – danach waren nur noch die Webhooks cleanup und ttl da. Dann scheitert nichts, aber keine Policy wirkt mehr: Fail-open statt Fail-closed. Beides ist ein Fehlerbild; welches du siehst, hängt davon ab, wie Kyverno ausfällt.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Die Ausnahme, die nicht greift

Einbauen: Eine Altanwendung legacy-batch hat kein Memory-Limit und bekommt eine Ausnahme von require-memory-limit:

# auf cp1
cat > legacy.yaml <<'EOF'
apiVersion: policies.kyverno.io/v1
kind: PolicyException
metadata: {name: legacy-batch, namespace: tag12}
spec:
  policyRefs:
  - {name: require-memory-limit, kind: ValidatingPolicy}
  matchConditions:
  - name: nur-legacy-batch
    expression: object.metadata.?labels.app.orValue('') == 'legacy-batch'
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: legacy-batch, namespace: tag12, labels: {team: shop}}
spec:
  replicas: 1
  selector: {matchLabels: {app: legacy-batch}}
  template:
    metadata: {labels: {app: legacy-batch}}
    spec:
      securityContext: {runAsUser: 65534}
      containers:
      - name: batch
        image: busybox:1.37
        command: [sleep, infinity]
EOF
kubectl apply -f legacy.yaml

Erwartet:

Warning: PolicyException resources would not be processed until it is enabled.
policyexception.policies.kyverno.io/legacy-batch created
deployment.apps/legacy-batch created

Symptom:

# auf cp1
kubectl -n tag12 get deploy legacy-batch
kubectl -n tag12 events --types=Warning | grep ReplicaSet/legacy | tail -1

Erwartet (Zeile umbrochen):

NAME           READY   UP-TO-DATE   AVAILABLE   AGE
legacy-batch   0/1     0            0           6s
2s (x11 over 7s)   Warning   FailedCreate   ReplicaSet/legacy-batch-777cb5bd56   Error
  creating: admission webhook "vpol.validate.kyverno.svc-fail-a5928e6d" denied the
  request: Policy require-memory-limit failed: Jeder Container braucht ein Memory-Limit.

Untersuchen: Die Warnung beim apply war der Hinweis. Die Startparameter des Admission-Controllers bestätigen ihn:

# auf cp1
kubectl -n kyverno get deploy kyverno-admission-controller \
  -o jsonpath='{.spec.template.spec.containers[0].args}' | tr ',' '\n' | grep -i except

Erwartet:

"--enablePolicyException=false"

Ursache: PolicyExceptions sind im Chart standardmäßig aus. Eine Ausnahme ist bewusst eine Hintertür; das Plattform-Team muss sie einschalten und festlegen, aus welchem Namespace sie angenommen werden.

Fix:

# auf cp1
cat >> kyverno-values.yaml <<'EOF'
features:
  policyExceptions:
    enabled: true
    namespace: tag12
EOF
helm upgrade kyverno kyverno/kyverno -n kyverno --version 3.10.0 \
  -f kyverno-values.yaml --wait --timeout 5m 2>/dev/null | grep STATUS
kubectl -n kyverno get deploy kyverno-admission-controller \
  -o jsonpath='{.spec.template.spec.containers[0].args}' | tr ',' '\n' | grep -i except

Erwartet:

STATUS: deployed
"--enablePolicyException=true"
"--exceptionNamespace=tag12"

Nachweis: Der ReplicaSet-Controller steckt nach vielen Fehlversuchen im Backoff, ein Neustart des Rollouts erzeugt sofort neue Pods:

# auf cp1
kubectl -n tag12 rollout restart deploy/legacy-batch
kubectl -n tag12 rollout status deploy/legacy-batch
kubectl -n tag12 get deploy legacy-batch

Erwartet:

deployment.apps/legacy-batch restarted
deployment "legacy-batch" successfully rolled out
NAME           READY   UP-TO-DATE   AVAILABLE   AGE
legacy-batch   1/1     1            1           2m54s

Warum 2>/dev/null beim Upgrade? Helm meldet bei jedem Upgrade die Deprecation der alten Kyverno-Typen (kyverno.io/v1 ClusterPolicy is deprecated …) – lesenswert, aber nicht für diesen Drill.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Policies vor dem Cluster testen

Die meisten Kyverno-Überraschungen lassen sich offline finden. kyverno test wendet Policies auf Beispiel-Ressourcen an und vergleicht mit dem erwarteten Ergebnis:

# auf cp1
mkdir -p ~/debug/tag12/test && cd ~/debug/tag12/test
cp ../team-label.yaml .
cat > deployments.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: mit-team, namespace: tag12, labels: {team: shop}}
spec:
  selector: {matchLabels: {app: a}}
  template:
    metadata: {labels: {app: a}}
    spec: {containers: [{name: a, image: busybox:1.37}]}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: ohne-team, namespace: tag12}
spec:
  selector: {matchLabels: {app: b}}
  template:
    metadata: {labels: {app: b}}
    spec: {containers: [{name: b, image: busybox:1.37}]}
EOF
cat > kyverno-test.yaml <<'EOF'
apiVersion: cli.kyverno.io/v1alpha1
kind: Test
metadata: {name: team-label}
policies: [team-label.yaml]
resources: [deployments.yaml]
results:
- policy: require-team-label
  isValidatingPolicy: true
  kind: Deployment
  resources: [mit-team]
  result: pass
- policy: require-team-label
  isValidatingPolicy: true
  kind: Deployment
  resources: [ohne-team]
  result: pass
EOF
kyverno test . | grep -E 'Deployment|Summary' | sed 's/│/ /g' | tr -s ' '

Erwartet (Zeile umbrochen):

 1 require-team-label validation apps/v1/Deployment/tag12/mit-team Pass Ok
 2 require-team-label validation apps/v1/Deployment/tag12/ohne-team Fail Want pass, got
   fail
Test Summary: 1 tests passed and 1 tests failed

Der Test fällt durch – zu Recht: Die Erwartung für ohne-team war falsch. Genau diese Rückmeldung willst du vor dem Ausrollen bekommen, nicht danach im Cluster.

# auf cp1
sed -i '$d' kyverno-test.yaml
echo "  result: fail" >> kyverno-test.yaml
kyverno test . | grep -E 'Deployment|Summary' | sed 's/│/ /g' | tr -s ' '
cd ~/debug/tag12

Erwartet:

 1 require-team-label validation apps/v1/Deployment/tag12/mit-team Pass Ok
 2 require-team-label validation apps/v1/Deployment/tag12/ohne-team Pass Ok
Test Summary: 2 tests passed and 0 tests failed

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig alle Kyverno-Policies im Cluster. Zeitziel: 15 s
  2. Zeig alle Ausnahmen der neuen API im Cluster. Zeitziel: 20 s
  3. Zeig, ob der Webhook-Service von Kyverno Endpoints hat. Zeitziel: 15 s

Lösung

# auf cp1
kubectl get vpol,mpol
kubectl get policyexceptions.policies.kyverno.io -A
kubectl -n kyverno get endpointslice -l kubernetes.io/service-name=kyverno-svc

Erwartet:

NAME                                                        AGE     READY
validatingpolicy.policies.kyverno.io/require-memory-limit   7m52s   true
validatingpolicy.policies.kyverno.io/require-team-label     8m56s   true

NAME                                                     AGE     READY
mutatingpolicy.policies.kyverno.io/add-run-as-non-root   6m33s   true
NAMESPACE   NAME           AGE
tag12       legacy-batch   3m
NAME                ADDRESSTYPE   PORTS   ENDPOINTS    AGE
kyverno-svc-fm4qc   IPv4          9443    10.42.0.95   23m

Warum nicht polex? Die Kurzform gehört zur alten API kyverno.io/v2; sie findet die neuen Ausnahmen nicht und warnt nur, dass sie veraltet ist.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

# auf cp1
kubectl -n tag12 get deploy

Erwartet:

NAME           READY   UP-TO-DATE   AVAILABLE   AGE
api            1/1     1            1           9m
batch          1/1     1            1           7m
legacy-batch   1/1     1            1           3m
web            2/2     2            2           11m

Challenge

Ein Kollege hat eine Policy gegen das Image-Tag latest angelegt. Trotzdem läuft ein Pod mit busybox:latest. Finde heraus, warum, wo Kyverno den Verstoß trotzdem festhält, und sorg dafür, dass der nächste solche Pod abgelehnt wird.

# auf cp1
cat > latest.yaml <<'EOF'
apiVersion: policies.kyverno.io/v1
kind: ValidatingPolicy
metadata: {name: disallow-latest}
spec:
  validationActions: [Audit]
  matchConstraints:
    namespaceSelector:
      matchLabels: {kubernetes.io/metadata.name: tag12}
    resourceRules:
    - apiGroups: [""]
      apiVersions: [v1]
      operations: [CREATE, UPDATE]
      resources: [pods]
  validations:
  - message: Kein Tag latest.
    expression: object.spec.containers.all(c, !c.image.endsWith(':latest'))
EOF
kubectl apply -f latest.yaml
cat > neu.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata: {name: neu, namespace: tag12}
spec:
  securityContext: {runAsUser: 65534}
  containers:
  - name: neu
    image: busybox:latest
    command: [sleep, infinity]
    resources: {limits: {memory: 32Mi}}
EOF
kubectl apply -f neu.yaml

Hinweis: Lies validationActions und such einen PolicyReport zum Pod.

Lösung

Nach etwa einer Minute (der Reports-Controller sammelt erst):

# auf cp1
kubectl get vpol disallow-latest -o jsonpath='{.spec.validationActions}{"\n"}'
J='{range .items[*]}{.scope.name}{range .results[?(@.policy=="disallow-latest")]}'
kubectl -n tag12 get policyreport -o jsonpath="$J {.result}{end}{\"\n\"}{end}" \
  | grep neu

Erwartet:

["Audit"]
neu fail

Audit meldet nur in den PolicyReport, Deny lehnt ab. Umstellen und prüfen:

# auf cp1
sed -i 's/validationActions: \[Audit\]/validationActions: [Deny]/' latest.yaml
kubectl apply -f latest.yaml
sed 's/name: neu, /name: neu2, /' neu.yaml | kubectl apply -f -

Erwartet (Zeile umbrochen):

validatingpolicy.policies.kyverno.io/disallow-latest configured
Error from server: error when creating "STDIN": admission webhook
  "vpol.validate.kyverno.svc-fail-7e0c34a0" denied the request: Policy disallow-latest
  failed: Kein Tag latest.

Der laufende Pod neu bleibt übrigens stehen: Admission prüft nur neue Anfragen.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

Kyverno bleibt installiert (Wettkampf), aber ohne Policies und mit abgeschalteten Ausnahmen:

# auf cp1
kubectl delete vpol,mpol --all
kubectl delete namespace tag12
sed -i '/^features:/,$d' kyverno-values.yaml
helm upgrade kyverno kyverno/kyverno -n kyverno --version 3.10.0 \
  -f kyverno-values.yaml --wait --timeout 5m 2>/dev/null | grep STATUS
kubectl get vpol,mpol,policyexceptions.policies.kyverno.io -A

Erwartet:

validatingpolicy.policies.kyverno.io "disallow-latest" deleted
validatingpolicy.policies.kyverno.io "require-memory-limit" deleted
validatingpolicy.policies.kyverno.io "require-team-label" deleted
mutatingpolicy.policies.kyverno.io "add-run-as-non-root" deleted
namespace "tag12" deleted
STATUS: deployed
No resources found

Interview-Notiz

  • Woran erkennst du einen Policy-Fehler? admission webhook "…" denied the request beim apply oder als FailedCreate am ReplicaSet; der Webhook-Name nennt die Engine.
  • Webhook down – was jetzt? Endpoints des Webhook-Service prüfen, failurePolicy kennen; im Notfall die WebhookConfiguration entfernen – aber nur, wenn der Controller sie nicht sofort neu anlegt und man das Sicherheitsloch bewusst in Kauf nimmt.
  • Warum sieht kubectl diff keine Mutation? Es läuft selbst durch die Admission; --dry-run=server -o yaml zeigt das Ergebnis.

Enterprise-Notiz

  • Admission-Controller mit mindestens drei Replikas, PodDisruptionBudget und priorityClassName betreiben; der Webhook steht vor jedem Deployment.
  • kube-system, kyverno und andere Plattform-Namespaces von Resource-Webhooks ausnehmen (Chart-Standard), sonst blockiert ein Kyverno-Ausfall die eigene Reparatur.
  • Neue Policies erst mit Audit ausrollen, PolicyReports auswerten, dann Deny.
  • Policies in CI mit kyverno test prüfen; Policies schreiben lernst du in „Kyverno und NetworkPolicies zum Anfassen“.