Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 12: Kyverno im Betrieb

Ziel: Du betreibst Kyverno hochverfügbar, überlebst einen Webhook-Ausfall, misst Latenz und Ergebnisse, aktualisierst sicher und räumst mit DeletingPolicies auf. · Dauer: ca. 150 min · Voraussetzung: Tag 11

Briefing

  • Vier Controller, vier Aufgaben: admission (Webhooks, kritisch), background (Generate, Mutate-Existing), reports (PolicyReports), cleanup (DeletingPolicies).
  • Nur der Admission-Controller sitzt im Request-Pfad. Fällt er aus, entscheidet die failurePolicy: Fail blockiert, Ignore lässt alles durch.
  • kube-system und der Kyverno-Namespace gehören nicht in die Webhooks, sonst sperrt sich der Cluster beim Neustart selbst aus.
  • Alle Ausgaben mit Cluster-Bezug in diesem Kapitel sind nicht live getestet. Live geprüft sind helm template, kubeconform und die Kyverno-CLI (Chart 3.9.1, Kyverno 1.19.1).
            API-Server
   ┌────────────┼──────────────────────────┐
   │ Webhook    │ (failurePolicy, timeout) │ VAP (nativ, ohne Webhook)
   ▼            ▼                          ▼
 admission-controller ×3 ── PDB minAvailable 2
 background ×2   reports ×2   cleanup ×2   ── je PDB

Drill 1: Bestandsaufnahme

mkdir -p ~/guard-lab/tag12 && cd ~/guard-lab/tag12
cp -R ~/guard-lab/code/kyverno-ops/tag12/. .
kubectl config use-context kind-kyverno-lab
kubectl -n kyverno get deploy
kubectl get validatingwebhookconfigurations,mutatingwebhookconfigurations \
  -l webhook.kyverno.io/managed-by=kyverno -o custom-columns=NAME:.metadata.name

Erwartet (gekürzt, nicht live getestet, kann je nach Version abweichen):

NAME                            READY   UP-TO-DATE   AVAILABLE   AGE
kyverno-admission-controller    1/1     1            1           2d
kyverno-background-controller   1/1     1            1           2d
kyverno-cleanup-controller      1/1     1            1           2d
kyverno-reports-controller      1/1     1            1           2d
NAME
kyverno-policy-validating-webhook-cfg
kyverno-resource-validating-webhook-cfg
…
kyverno-resource-mutating-webhook-cfg

Die Webhook-Konfigurationen legt nicht Helm an, sondern Kyverno selbst (autoUpdateWebhooks=true). Sie passen sich an die geladenen Policies an und bleiben bestehen, wenn der Controller stirbt. Genau das macht Drill 4 spannend.

Fortschritt speichern? Kostenlos registrieren

Drill 2: HA – Replikas, Spread, PDB

grep -E '^[a-z]|replicas|minAvailable|topologyKey' values-ha.yaml

Erwartet:

admissionController:
  replicas: 3
    minAvailable: 2
    topologyKey: kubernetes.io/hostname
backgroundController:
  replicas: 2
cleanupController:
  replicas: 2
reportsController:
  replicas: 2
config:
features:
grafana:
prometheusRule:

Erst rendern, dann prüfen, dann ausrollen:

helm template kyverno kyverno/kyverno -n kyverno --version 3.9.1 \
  -f values-ha.yaml > ha.yaml
yq 'select(.kind=="Deployment") | .metadata.name + " " + (.spec.replicas|tostring)' \
  ha.yaml | grep -v -- ---
yq 'select(.kind=="PodDisruptionBudget") | .metadata.name + " minAvailable="
  + (.spec.minAvailable|tostring)' ha.yaml | grep -v -- ---
kubeconform -summary -ignore-missing-schemas ha.yaml

Erwartet:

kyverno-admission-controller 3
kyverno-background-controller 2
kyverno-cleanup-controller 2
kyverno-reports-controller 2
kyverno-admission-controller minAvailable=2
kyverno-background-controller minAvailable=1
kyverno-cleanup-controller minAvailable=1
kyverno-reports-controller minAvailable=1
Summary: 85 resources found in 1 file - Valid: 63, Invalid: 0, Errors: 0, Skipped: 22

Skipped sind die CRDs von Kyverno, für die kubeconform kein Schema kennt. Admission skaliert horizontal (jede Replika beantwortet Webhooks). Background, Reports und Cleanup arbeiten mit Leader-Election: Die zweite Replika ist Standby, nicht doppelte Leistung.

helm upgrade kyverno kyverno/kyverno -n kyverno --version 3.9.1 \
  -f values-ha.yaml --wait --timeout 5m \
  --set-file global.caCertificates.data=$HOME/guard-lab/tag10/certs/registry.crt
kubectl -n kyverno get pods -o wide \
  -l app.kubernetes.io/component=admission-controller \
  --no-headers | awk '{print $1, $7}'
kubectl -n kyverno get pdb

Erwartet (gekürzt, nicht live getestet, kann je nach Version abweichen):

kyverno-admission-controller-6d9c7b8f5-4xk2p kyverno-lab-worker
kyverno-admission-controller-6d9c7b8f5-8hq7m kyverno-lab-worker2
kyverno-admission-controller-6d9c7b8f5-tz9wd kyverno-lab-control-plane
NAME                            MIN AVAILABLE   MAX UNAVAILABLE   ALLOWED DISRUPTIONS
kyverno-admission-controller    2               N/A               1
kyverno-background-controller   1               N/A               1
…

Tipp: values-ha.yaml enthält auch registryClient.allowInsecure: true für die Lab-Registry aus Tag 10 und schaltet PolicyExceptions für policy-exceptions frei (Tag 11). Ein helm upgrade ohne diese Werte würde beides stillschweigend abschalten. Die Lab-CA aus Tag 10 steht bewusst nicht in der Datei – sie kommt bei jedem Upgrade per --set-file global.caCertificates.data=… mit, sonst schlägt die Signaturprüfung mit x509 fehl.

Fortschritt speichern? Kostenlos registrieren

Drill 3: failurePolicy, Timeouts, Ausschlüsse

Die Webhooks schließen Namespaces per namespaceSelector aus. Den Kyverno-Namespace hängt das Chart selbst an:

yq 'select(.kind=="ConfigMap" and .metadata.name=="kyverno") | .data.webhooks' \
  ha.yaml | jq -r '.namespaceSelector.matchExpressions[].values | join(",")'

Erwartet:

kube-system,kube-node-lease,local-path-storage
kyverno

failurePolicy und Timeout setzt du pro Policy. Kritische Sicherheitsregeln bleiben bei Fail (Default). Komfortregeln wie Labels laufen mit Ignore und kurzem Timeout:

sed -n '/^spec:/,/validationActions/p' soft-labels.yaml
kyverno apply soft-labels.yaml -r ~/guard-lab/code/demo/ --remove-color | tail -1

Erwartet:

spec:
  failurePolicy: Ignore
  webhookConfiguration:
    timeoutSeconds: 3
  validationActions: [Audit]
pass: 0, fail: 6, warn: 0, error: 0, skip: 0

Sechs Deployments ohne Label team. Im Audit-Modus landet das nur im PolicyReport.

Einstellung Kyverno weg / Timeout Risiko Einsatz
failurePolicy: Fail Request abgelehnt Cluster-Änderungen stehen Security-Regeln
failurePolicy: Ignore Request erlaubt Lücke während Ausfall Labels, Defaults
timeoutSeconds 1–30 nach X s gilt failurePolicy lange Timeouts bremsen 3–10 s
forceFailurePolicyIgnore alles Ignore (global) keine Durchsetzung nur Notfall

Achtung: Der API-Server wartet pro Webhook bis zum Timeout. Drei Policies mit 10 s und ein hängender Kyverno machen aus einem kubectl apply eine halbe Minute.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Kyverno-Ausfall simulieren und erholen

Spiele den schlimmsten Fall: alle Admission-Pods weg, Webhooks noch registriert.

kubectl apply -f ~/guard-lab/code/kyverno/tag08/image-hygiene.yaml
kubectl -n kyverno scale deploy kyverno-admission-controller --replicas=0
kubectl -n kyverno wait --for=delete pod \
  -l app.kubernetes.io/component=admission-controller --timeout=60s
kubectl -n shop run probe --image=curlimages/curl:8.22.0 --dry-run=client -o yaml \
  -- sleep 30 | kubectl set resources --local -f - -o yaml \
  --requests=cpu=10m,memory=16Mi --limits=memory=32Mi | kubectl apply -f -
kubectl -n kube-system run probe --image=curlimages/curl:8.22.0 -- sleep 30

Erwartet (gekürzt, nicht live getestet, kann je nach Version abweichen):

deployment.apps/kyverno-admission-controller scaled
Error from server (InternalError): Internal error occurred: failed calling webhook
"…validate.kyverno.svc-fail": failed to call webhook: Post "https://kyverno-svc.kyverno
.svc:443/…": no endpoints available for service "kyverno-svc"
pod/probe created

shop ist blockiert (Fail), kube-system läuft weiter, weil es ausgeschlossen ist. Ohne diesen Ausschluss könnten CoreDNS oder kube-proxy nach einem Node-Neustart nicht starten.

Erholung, in dieser Reihenfolge:

kubectl -n kyverno scale deploy kyverno-admission-controller --replicas=3
kubectl -n kyverno rollout status deploy kyverno-admission-controller --timeout=180s
kubectl -n shop run probe --image=curlimages/curl:8.22.0 -- sleep 30
kubectl -n shop delete pod probe; kubectl -n kube-system delete pod probe

Erwartet (gekürzt, nicht live getestet, kann je nach Version abweichen):

deployment "kyverno-admission-controller" successfully rolled out
pod/probe created

Startet Kyverno gar nicht mehr (etwa Image-Pull-Fehler), ist der Notausgang das Löschen der Webhooks. Kyverno legt sie beim nächsten Start neu an:

kubectl delete validatingwebhookconfiguration,mutatingwebhookconfiguration \
  -l webhook.kyverno.io/managed-by=kyverno

Für Regeln, die auch während dieses Fensters gelten müssen, lässt Kyverno eine native ValidatingAdmissionPolicy erzeugen. Sie läuft im API-Server, ganz ohne Webhook:

sed -n '/^spec:/,/validationActions/p' no-privileged-vap.yaml
kyverno apply no-privileged-vap.yaml -r priv-pod.yaml \
  --values-file ~/guard-lab/code/kyverno/tag08/values.yaml --remove-color | tail -3

Erwartet:

spec:
  autogen:
    validatingAdmissionPolicy:
      enabled: true
  validationActions: [Deny]
1 -  Privilegierte Container sind verboten.

pass: 0, fail: 1, warn: 0, error: 0, skip: 0
kubectl apply -f no-privileged-vap.yaml
kubectl get validatingadmissionpolicy,validatingadmissionpolicybinding | grep priv

Erwartet (gekürzt, nicht live getestet, kann je nach Version abweichen):

validatingadmissionpolicy.admissionregistration.k8s.io/no-privileged   …
validatingadmissionpolicybinding.admissionregistration.k8s.io/no-privileged-binding …

Grenzen: Das geht nur mit reinem Kubernetes-CEL (keine Kyverno-Bibliotheken wie resource.List oder image()), und Autogen für Deployments entfällt dann.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Metriken und Grafana-Dashboard

Jeder Controller hat einen Metrics-Service auf Port 8000. Für einen schnellen Blick reicht ein Port-Forward:

kubectl -n kyverno port-forward svc/kyverno-svc-metrics 8000:8000 >/dev/null 2>&1 &
sleep 2
curl -s localhost:8000/metrics | grep -oE '^kyverno_[a-z_]+' | sort -u \
  | grep -E 'admission|validating_policy'
kill %1

Erwartet (gekürzt, nicht live getestet, kann je nach Version abweichen):

kyverno_admission_requests_total
kyverno_admission_review_duration_seconds_bucket
kyverno_admission_review_duration_seconds_count
kyverno_admission_review_duration_seconds_sum
kyverno_validating_policy_execution_duration_seconds_bucket
kyverno_validating_policy_results_total

Das Chart bringt ein fertiges Dashboard als ConfigMap mit (Label grafana_dashboard: "1" für den Grafana-Sidecar):

yq 'select(.metadata.name=="kyverno-grafana-grafana")
  | .data["kyverno-dashboard.json"]' ha.yaml > dashboard.json
jq -r '.title, (.panels | length)' dashboard.json
jq -r '[.panels[].targets[]?.expr] | .[]' dashboard.json \
  | grep -oE 'kyverno_(admission|validating_policy)_[a-z_]+' | sort -u

Erwartet:

Kyverno Metrics
50
kyverno_admission_requests_total
kyverno_admission_review_duration_seconds_count
kyverno_admission_review_duration_seconds_sum
kyverno_validating_policy_execution_duration_seconds_count
kyverno_validating_policy_execution_duration_seconds_sum
kyverno_validating_policy_results_total

Drei Abfragen, die in jedes Alerting gehören:

# p95-Latenz der Admission (Alarm ab 1 s, Timeout liegt bei 10 s)
histogram_quantile(0.95, sum(rate(
  kyverno_admission_review_duration_seconds_bucket[5m])) by (le))
# Abgelehnte Requests pro Minute
sum(rate(kyverno_admission_requests_total{request_allowed="false"}[5m])) * 60
# Kyverno nicht erreichbar (Prometheus-Target fehlt)
absent(up{job=~".*kyverno.*"} == 1)

Mit kube-prometheus-stack schaltest du admissionController.serviceMonitor.enabled (und analog für die anderen Controller) sowie prometheusRule.enabled ein. Der Stack selbst ist für den Lab-Laptop zu schwer, deshalb hier nur die Werte.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Reports – Policy Reporter und Background-Scans

Policy Reporter macht PolicyReports als Web-UI sichtbar:

cat values-policy-reporter.yaml
helm template policy-reporter policy-reporter \
  --repo https://kyverno.github.io/policy-reporter --version 3.11.0 \
  -n policy-reporter -f values-policy-reporter.yaml > pr.yaml
yq 'select(.kind=="Deployment") | .spec.template.spec.containers[0].image' pr.yaml \
  | grep -v -- ---
kubeconform -summary pr.yaml

Erwartet:

# Tag 12: Policy Reporter mit UI und Kyverno-Plugin, Metriken für Prometheus
ui:
  enabled: true
plugin:
  kyverno:
    enabled: true
metrics:
  enabled: true
ghcr.io/kyverno/policy-reporter:3.11.0
ghcr.io/kyverno/policy-reporter/kyverno-plugin:0.7.2
ghcr.io/kyverno/policy-reporter-ui:2.9.0
Summary: 23 resources found in 1 file - Valid: 23, Invalid: 0, Errors: 0, Skipped: 0
helm upgrade --install policy-reporter policy-reporter \
  --repo https://kyverno.github.io/policy-reporter --version 3.11.0 \
  -n policy-reporter --create-namespace -f values-policy-reporter.yaml --wait
kubectl -n policy-reporter port-forward svc/policy-reporter-ui 8082:8080

Im Browser http://localhost:8082: Dashboard pro Namespace, Filter nach Policy und Ergebnis (nicht live getestet).

PolicyReports entstehen bei Admission und beim Background-Scan. Der Scan prüft alle Bestandsobjekte periodisch (Default 1 h, in values-ha.yaml 2 h). Stellschrauben:

kubectl get policyreports -A --no-headers | wc -l
kubectl get ephemeralreports -A --no-headers 2>/dev/null | wc -l
kubectl -n kyverno top pod -l app.kubernetes.io/component=reports-controller

Erwartet (gekürzt, nicht live getestet, kann je nach Version abweichen):

14
0
NAME                                          CPU(cores)   MEMORY(bytes)
kyverno-reports-controller-7c9d8b5c4f-2kq9x   3m           61Mi
Hebel Wo Wirkung
backgroundScanInterval features.backgroundScan seltener scannen
evaluation.background.enabled: false pro Policy nur Admission
features.admissionReports.enabled Chart keine Admission-Reports
metricsConfig.namespaces.exclude Chart weniger Metrik-Serien

Wachsen die ephemeralreports dauerhaft, kommt der Reports-Controller nicht hinterher: mehr Speicher geben oder Scans seltener machen.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Upgrade mit Ansage

Die CRDs liegen im Chart als Templates (Subcharts crds und kyverno-api, Schalter crds.install). helm upgrade aktualisiert sie also mit. Vor jedem Upgrade vergleichst du, was sich ändert:

for v in 3.9.0 3.9.1; do
  helm template kyverno kyverno/kyverno -n kyverno --version $v > k-$v.yaml
done
diff <(grep -h 'image:' k-3.9.0.yaml | sort -u) \
     <(grep -h 'image:' k-3.9.1.yaml | sort -u) | grep '^>'
diff <(yq 'select(.kind=="CustomResourceDefinition").metadata.name' k-3.9.0.yaml) \
     <(yq 'select(.kind=="CustomResourceDefinition").metadata.name' k-3.9.1.yaml) \
  && echo "✔ gleiche CRD-Liste"

Erwartet:

>           image: "ghcr.io/kyverno/readiness-checker:v1.19.1"
>           image: "reg.kyverno.io/kyverno/background-controller:v1.19.1"
>           image: "reg.kyverno.io/kyverno/cleanup-controller:v1.19.1"
>           image: "reg.kyverno.io/kyverno/kyverno-cli:v1.19.1"
>           image: "reg.kyverno.io/kyverno/kyverno:v1.19.1"
>           image: "reg.kyverno.io/kyverno/kyvernopre:v1.19.1"
>           image: "reg.kyverno.io/kyverno/reports-controller:v1.19.1"
✔ gleiche CRD-Liste

Die CEL-Typen haben mehrere API-Versionen. Gespeichert wird nur eine, ausgeliefert alle:

yq 'select(.metadata.name=="validatingpolicies.policies.kyverno.io")
  | .spec.versions[] | .name + " served=" + (.served|tostring)
  + " storage=" + (.storage|tostring)' k-3.9.1.yaml
kubectl get crd validatingpolicies.policies.kyverno.io \
  -o jsonpath='{.status.storedVersions}{"\n"}'

Erwartet (erster Teil live, kubectl gekürzt, nicht live getestet):

v1 served=true storage=false
v1alpha1 served=true storage=false
v1beta1 served=true storage=true
["v1beta1"]

Deine Manifeste nutzen v1, die API speichert v1beta1. Entfernt ein späteres Release eine Version aus storedVersions, musst du Objekte vorher migrieren (neu schreiben). Die Release Notes sagen, wann. Der Ablauf in Staging:

  1. kyverno test . aus Tag 11 mit der neuen CLI-Version laufen lassen.
  2. helm upgrade … --version <neu> -f values-ha.yaml --set-file global.caCertificates.data=… --wait, dank PDB ohne Lücke.
  3. kubectl get validatingpolicies – Spalte READY überall true.

Fortschritt speichern? Kostenlos registrieren

Drill 8: DeletingPolicy – Aufräumen nach Plan

DeletingPolicies laufen im Cleanup-Controller nach Cron-Plan. Sie löschen, was die conditions erfüllt. Zwei Klassiker: fertige Pods in Mandanten und abgelaufene Ausnahmen aus Tag 11.

sed -n '/conditions:/,$p' delete-finished-pods.yaml
kyverno test cleanup-test --remove-color | grep -E '│ [0-9]|Summary'

Erwartet (gekürzt):

  conditions:
  - name: fertig
    expression: >-
      object.status.?phase.orValue('') in ['Succeeded', 'Failed']
  - name: aelter-als-1h
    expression: >-
      time.now() - timestamp(object.metadata.creationTimestamp) > duration('1h')
│ 1  │ delete-finished-pods │ delete-finished-pods │ v1/Pod/tenant-a/job-done    │ Pass
│ 2  │ delete-finished-pods │ delete-finished-pods │ v1/Pod/tenant-a/api-running │ Pass
Test Summary: 2 tests passed and 0 tests failed

Die Policy läuft alle 15 Minuten und nur in Namespaces mit Label tenant. Im Test heißt result: pass „würde gelöscht“, fail „bleibt“. Der Schlüssel dafür ist isDeletingPolicy: true. Die zweite Policy entfernt abgelaufene Ausnahmen:

sed -n '/conditions:/,$p' delete-expired-exceptions.yaml
kubectl apply -f cleanup-rbac.yaml
kubectl apply -f delete-finished-pods.yaml -f delete-expired-exceptions.yaml
kubectl get deletingpolicies

Erwartet (erster Teil live, Rest gekürzt, nicht live getestet):

  conditions:
  - name: abgelaufen
    expression: >-
      has(object.spec.expiresAt) &&
      timestamp(object.spec.expiresAt) < time.now()
clusterrole.rbac.authorization.k8s.io/kyverno:cleanup-controller:guard-lab created
deletingpolicy.policies.kyverno.io/delete-finished-pods created
deletingpolicy.policies.kyverno.io/delete-expired-exceptions created
NAME                        AGE   READY
delete-expired-exceptions   5s    true
delete-finished-pods        5s    true

Warum cleanup-rbac.yaml? Der Cleanup-Controller darf ab Werk weder Pods noch PolicyExceptions löschen (helm template zeigt nur get,list,patch,update,watch). Die Rolle mit dem Label rbac.kyverno.io/aggregate-to-cleanup-controller erweitert ihn per Aggregation. Ohne sie läuft die Policy, löscht aber nichts.

Achtung: kyverno apply mit delete-expired-exceptions.yaml scheitert offline (1.19.1: no matches for kind "PolicyException"). Diese Policy testest du im Cluster.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

#!/usr/bin/env bash
ok() { echo "✔ $1"; }; nok() { echo "✘ $1"; }
r=$(kubectl -n kyverno get deploy kyverno-admission-controller \
  -o jsonpath='{.status.readyReplicas}')
[ "${r:-0}" -ge 3 ] && ok "Admission 3 Replikas" || nok "Admission 3 Replikas"
kubectl -n kyverno get pdb kyverno-admission-controller >/dev/null 2>&1 \
  && ok "PDB vorhanden" || nok "PDB vorhanden"
kubectl -n kube-system run kc --image=curlimages/curl:8.22.0 --dry-run=server \
  -- true >/dev/null 2>&1 && ok "kube-system frei" || nok "kube-system frei"
kubectl get validatingadmissionpolicy no-privileged >/dev/null 2>&1 \
  && ok "VAP no-privileged" || nok "VAP no-privileged"
kubectl get deletingpolicy delete-finished-pods >/dev/null 2>&1 \
  && ok "DeletingPolicy aktiv" || nok "DeletingPolicy aktiv"
kyverno test ~/guard-lab/tag12/cleanup-test >/dev/null 2>&1 \
  && ok "Cleanup-Test grün" || nok "Cleanup-Test grün"

Challenge

Simuliere einen Node-Drain: kubectl drain auf einem Worker mit Admission-Pod darf das PDB nicht verletzen, und Pod-Anlage in shop muss währenddessen funktionieren.

Hinweis: --ignore-daemonsets --delete-emptydir-data, parallel in einer zweiten Shell im Sekundentakt einen gültigen Pod mit --dry-run=server anlegen.

Lösung

N=$(kubectl -n kyverno get pod -l app.kubernetes.io/component=admission-controller \
  -o jsonpath='{.items[0].spec.nodeName}')
POD=~/guard-lab/tag11/policy-repo/e2e/image-hygiene/pod-good.yaml
( for i in $(seq 30); do
    kubectl -n shop create -f "$POD" --dry-run=server -o name 2>&1 | tail -1
    sleep 1
  done ) &
kubectl drain "$N" --ignore-daemonsets --delete-emptydir-data --timeout=120s
wait; kubectl uncordon "$N"
kubectl -n kyverno get pdb kyverno-admission-controller

Erwartet: 30-mal pod/good (keine Webhook-Fehler), ALLOWED DISRUPTIONS nach dem Uncordon wieder 1 (nicht live getestet). Der Pod aus Tag 11 erfüllt image-hygiene, jeder Fehler kommt also vom Webhook.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Admission mindestens 3 Replikas über Zonen verteilt, PDB minAvailable: 2, eigene PriorityClass, Requests/Limits nach Lastprofil (Webhook-Latenz p95 < 500 ms).
  • Pro Policy entscheiden: Security = Fail (+ VAP-Autogen, wo möglich), Komfort = Ignore mit kurzem Timeout. Notfall-Runbook für „Webhooks löschen“ griffbereit.
  • Alarme auf p95-Latenz, abgelehnte Requests, fehlende Targets und wachsende EphemeralReports. Metriken pro Namespace begrenzen (metricsConfig), sonst explodiert die Kardinalität.
  • Upgrades nur Minor für Minor, Chart und Images pinnen, Release Notes auf CRD- und Storage-Version-Änderungen lesen, vorher kyverno test mit der neuen CLI.
  • Bei sehr vielen Reports den Reports-Server (eigene DB statt etcd) prüfen (reportsServer.enabled).