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:Failblockiert,Ignorelässt alles durch. kube-systemund 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,kubeconformund 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.nameErwartet (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.yamlErwartet:
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.yamlErwartet:
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 pdbErwartet (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.yamlenthält auchregistryClient.allowInsecure: truefür die Lab-Registry aus Tag 10 und schaltet PolicyExceptions fürpolicy-exceptionsfrei (Tag 11). Einhelm upgradeohne 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 -1Erwartet:
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 applyeine 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 30Erwartet (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 probeErwartet (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=kyvernoFü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 -3Erwartet:
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 privErwartet (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 %1Erwartet (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 -uErwartet:
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.yamlErwartet:
# 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:8080Im 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-controllerErwartet (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:
kyverno test .aus Tag 11 mit der neuen CLI-Version laufen lassen.helm upgrade … --version <neu> -f values-ha.yaml --set-file global.caCertificates.data=… --wait, dank PDB ohne Lücke.kubectl get validatingpolicies– SpalteREADYüberalltrue.
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 deletingpoliciesErwartet (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 applymitdelete-expired-exceptions.yamlscheitert 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-controllerErwartet: 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 =Ignoremit 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 testmit der neuen CLI. - Bei sehr vielen Reports den Reports-Server (eigene DB statt etcd)
prüfen (
reportsServer.enabled).