Kapitel 10: Zusammenarbeit mit Entwicklungsteams, Ausnahmen und Übergangsfristen
In diesem Kapitel lernst du:
- warum Security als Enabler funktioniert: mit „Paved Road”, Golden Path und fertigen Pipeline-Bausteinen
- wie du neue Regeln in drei Phasen einführst (Beobachten, Warnen, Erzwingen) und das sauber ankündigst
- wie ein Ausnahmeprozess aussieht, der nicht zur Dauerlösung verkommt: begründet, kompensiert, befristet
- wie du ein Ausnahmeregister als Code führst und abgelaufene Ausnahmen automatisch findest
- wie du mit Widerstand umgehst und Befunde so formulierst, dass Teams sie gern beheben
Worum geht es?
Stell dir eine Stadt vor, die Radfahrer sicherer machen will. Variante A: Die Stadt stellt über Nacht überall Schilder „Radfahren verboten” auf und verteilt Strafzettel. Variante B: Die Stadt baut einen gut beleuchteten, glatten Radweg, kündigt an, dass die alte Straße in drei Monaten für Räder gesperrt wird, hängt in der Übergangszeit freundliche Hinweisschilder auf und erlaubt dem Lieferdienst mit Sondergenehmigung, noch bis Jahresende die alte Straße zu nutzen.
Variante A erzeugt Wut und Umgehungen. Variante B erzeugt Akzeptanz. Genau so ist es mit Sicherheitsregeln in der Lieferkette. In den Kapiteln 1 bis 9 hast du viele Werkzeuge gebaut: Spiegel, Signaturen, Scans, Policies. Ob sie in einer echten Organisation wirken, entscheidet sich aber an der Schnittstelle zu den Menschen, die täglich Software bauen.
Security-Team Entwicklungsteams
+----------------+ +------------------+
| Regel / Policy | | Team A Team B |
+-------+--------+ +--------+---------+
| |
v v
+----------------------------------------------------------------+
| Paved Road: Templates, CI-Komponenten, Basis-Images, Doku |
+----------------------------------------------------------------+
|
v
Phase 1: Beobachten --> Phase 2: Warnen --> Phase 3: Erzwingen
(Audit, Reports) (Warnung im CI (Enforce, Block)
und kubectl)
| ^
| +-------------------------------+ |
+------> | Ausnahme (befristet, begründet) |---+
| Register als Code, Ablauf-Check |
+-------------------------------+
Die Kernidee: Der sichere Weg muss der bequemste Weg sein. Regeln kommen mit Vorlauf. Und wo eine Regel (noch) nicht passt, gibt es eine geordnete, befristete Ausnahme statt eines stillen Workarounds.
Die Konzepte in einfach
Security als Enabler: Paved Road und Golden Path
Paved Road („gepflasterte Straße”) heißt: Die Plattform stellt einen fertigen, sicheren Standardweg bereit. Wer ihn nutzt, bekommt Sicherheit „geschenkt”. Der Golden Path ist die konkrete, dokumentierte Abfolge auf diesem Weg, zum Beispiel „neuer Python-Service in 15 Minuten”.
Typische Bausteine:
| Baustein | Was das Team bekommt | Bezug |
|---|---|---|
| Gehärtete Basis-Images | Aktuell, non-root, aus dem Spiegel | Kapitel 2, 3 |
| Pipeline-Template | Build, Scan, SBOM ohne eigenen Aufwand | Kapitel 1, 7, 8 |
| Vault-Anbindung | Secrets per id_token, keine Variablen | Kapitel 6 |
| Helm-/Kustomize-Basis | Manifeste, die Policies schon erfüllen | Kapitel 9 |
Wichtig ist der Unterschied zwischen Leitplanke und Schlagbaum. Eine Leitplanke hält dich auf der Straße, lässt dich aber fahren. Ein Schlagbaum stoppt dich. Gute Plattformen haben viele Leitplanken (Templates, Defaults) und wenige Schlagbäume (harte Policies für die wirklich kritischen Punkte).
Pipeline-Templates und CI-Komponenten
In GitLab gibt es zwei verbreitete Wege, gemeinsame Pipeline-Bausteine zu verteilen:
include: project:bindet eine YAML-Datei aus einem anderen Repository ein, idealerweise auf einen festen Tag gepinnt.- CI/CD-Komponenten
(
include: component:) sind versionierte, parametrisierbare Bausteine aus einem Komponenten-Projekt. Sie sind seit GitLab 17 allgemein verfügbar.
include:
# Variante 1: klassisches Template, auf Tag gepinnt
- project: "platform/pipeline-templates"
ref: "v2.3.0"
file: "/templates/python-secure.yml"
# Variante 2: CI/CD-Komponente mit Eingaben
- component: "$CI_SERVER_FQDN/platform/security-components/[email protected]"
inputs:
severity: "HIGH,CRITICAL"Merke: Pinne Templates immer auf eine Version. Sonst ändert das Plattform-Team mit einem Commit die Pipelines aller Teams gleichzeitig, und niemand weiß, warum der Build plötzlich rot ist.
Kommunikation: Ankündigung, Changelog, Sprechstunde, Champions
Technik ohne Kommunikation scheitert. Vier Werkzeuge haben sich bewährt:
- Ankündigung mit Vorlauf: Was ändert sich, warum, ab wann, was muss das Team tun, wo gibt es Hilfe.
- Changelog für Policies und Templates, genau wie für Software. Jede neue Regel und jede Verschärfung steht dort mit Datum.
- Sprechstunde (Office Hours): fester wöchentlicher Termin, in dem Teams Fragen stellen und Befunde gemeinsam ansehen.
- Champions-Programm: In jedem Team gibt es eine Person mit Security-Interesse. Sie bekommt früher Informationen, kleine Schulungen und ist Ansprechpartner im Team. Das skaliert viel besser als ein zentrales Security-Team, das alles selbst erklärt.
Rollout in drei Phasen
Eine neue Regel wird nie von heute auf morgen scharf geschaltet. Stattdessen:
| Phase | Technik (Kyverno/CI) | Wirkung | Dauer (Beispiel) |
|---|---|---|---|
| Beobachten | failureAction: Audit |
Nur Policy Reports | 4 Wochen |
| Warnen | Audit + emitWarning: true |
Warnung bei Deploy und im CI | 3 Wochen |
| Erzwingen | failureAction: Enforce |
Verstoß wird blockiert | dauerhaft |
In der Beobachten-Phase misst du, wie viele Ressourcen die Regel heute schon verletzen. Ist die Zahl hoch, ist die Regel zu streng formuliert oder der Golden Path fehlt noch. In der Warnen-Phase sieht jedes Team seine Verstöße direkt beim Deployment. Erst am angekündigten Stichtag wird erzwungen.
Ein Zeitplan-Beispiel für die Regel „Pods müssen als non-root laufen”:
| Datum | Schritt | Kommunikation |
|---|---|---|
| T-6 Wochen | Ankündigung, Doku, Template-Update | Mail, Changelog, Sprechstunde |
| T-6 Wochen | Policy im Audit-Modus | Report pro Team |
| T-3 Wochen | Audit + Warnung | Erinnerung, Liste offener Verstöße |
| T-1 Woche | Ausnahmeanträge bis hier | letzte Erinnerung |
| T (Stichtag) | Enforce per GitOps-MR | Bestätigungsmail |
| T+2 Wochen | Review: Ausnahmen, Probleme | Lessons Learned |
Der Ausnahmeprozess
Eine Ausnahme (Exception, Waiver) ist eine bewusste,
dokumentierte Entscheidung, eine Regel für ein bestimmtes Ziel für eine
bestimmte Zeit nicht anzuwenden. Ohne geordneten Prozess passieren
stattdessen stille Workarounds: Policies werden heimlich abgeschwächt,
Scans auf allow_failure gesetzt, Images an der Pipeline
vorbei gebaut.
Ein guter Ausnahmeantrag beantwortet acht Fragen:
| Feld | Frage |
|---|---|
| Begründung | Warum kann die Regel jetzt nicht erfüllt werden? |
| Risikoeinschätzung | Was kann passieren, wie wahrscheinlich, wie schlimm? |
| Kompensation | Welche Ersatzmaßnahme senkt das Risiko? |
| Befristung | Bis wann gilt die Ausnahme (Datum, kein „bis auf Weiteres”)? |
| Verantwortlicher | Wer im Team behebt das Problem? |
| Genehmiger | Wer trägt das Restrisiko (Security, Produktverantwortung)? |
| Ticket | Wo wird die Behebung verfolgt? |
| Geltungsbereich | Für genau welches Ziel (Image, Namespace, Deployment, CVE)? |
Kompensation (kompensierende Maßnahme) ist eine Ersatzmaßnahme. Beispiel: Ein Container muss vorübergehend als root laufen. Kompensation: eigener Namespace, NetworkPolicy ohne Egress, read-only Dateisystem, kein Service-Account-Token.
Ablauf und Wiedervorlage: Jede Ausnahme hat ein Ablaufdatum. Vor Ablauf (zum Beispiel 14 Tage vorher) gibt es eine Erinnerung. Nach Ablauf wirkt die Regel wieder automatisch. Eine Verlängerung ist ein neuer Antrag mit neuer Begründung, kein stilles Weiterlaufen.
Merke: Eine Ausnahme ohne Ablaufdatum ist keine Ausnahme, sondern eine neue Regel. Unbefristete Ausnahmen lehnst du grundsätzlich ab.
Ausnahmeregister als Code
Statt Ausnahmen in E-Mails, Wikis oder Tabellen zu verstecken, führst du sie als YAML-Datei im Git:
- Merge Request = Antrag. Das Team schlägt die
Ausnahme als Änderung an
exceptions.yamlvor. Die MR-Beschreibung enthält die Diskussion. - CODEOWNERS = Genehmiger. Die Datei gehört dem Security-Team. Ohne dessen Freigabe kein Merge.
- Pipeline = Prüfer. Ein Skript validiert Pflichtfelder, Datumsformat, Höchstlaufzeit und Ablauf. Abgelaufene Einträge machen die Pipeline rot.
- Git-Historie = Audit-Trail. Wer hat wann was beantragt und genehmigt? Steht im Log.
Achtung: Die Einstellung „Code-Owner-Freigabe erforderlich” für geschützte Branches ist in GitLab ein Premium-Feature. In GitLab CE zeigt CODEOWNERS die Verantwortlichen nur an. Workaround in CE: Lege das Register in ein eigenes Repository, in dem nur die Security-Gruppe die Rolle Maintainer hat und damit mergen darf.
Metriken
Was du nicht misst, kannst du nicht verbessern. Drei Kennzahlen reichen für den Anfang:
| Metrik | Bedeutung | Quelle |
|---|---|---|
| Anteil konformer Deployments | pass / (pass + fail) in Prozent | Kyverno Policy Reports |
| Offene Ausnahmen | Anzahl, Alter, bald ablaufend | exceptions.yaml |
| MTTR kritische Befunde | Zeit von Fund bis Behebung | Dependency-Track, Tickets |
MTTR (Mean Time to Remediate) ist die mittlere Zeit bis zur Behebung. Typische Zielwerte in Organisationen: kritisch 7 Tage, hoch 30 Tage, mittel 90 Tage. Wichtig: Die Metrik soll Fortschritt zeigen, nicht Teams an den Pranger stellen. Zeige Trends über Zeit, nicht Ranglisten.
Eskalation
Manchmal läuft eine Frist ab und nichts passiert. Dann brauchst du einen vorher vereinbarten Eskalationsweg, zum Beispiel:
- Automatische Erinnerung an Verantwortlichen (14 und 3 Tage vor Ablauf).
- Nach Ablauf: Gespräch Security-Champion und Teamleitung.
- Nach weiteren 7 Tagen: Produktverantwortung entscheidet über Risikoübernahme (schriftlich) oder Priorisierung.
- Bei kritischen Befunden: Informationssicherheitsbeauftragter (ISB/CISO).
Der Eskalationsweg ist kein Drohinstrument. Er sorgt dafür, dass Risiken bei der Person landen, die sie tragen darf.
Umgang mit Widerstand und Sprache in Befunden
Widerstand hat fast immer einen sachlichen Kern: Zeitdruck, unklare Anforderungen, schlechte Erfahrungen mit Fehlalarmen, fehlende Werkzeuge. Hör zu, frag nach dem Kern und biete einen konkreten Weg an.
Formuliere Befunde wie ein guter Code-Review, nicht wie ein Strafzettel:
| Statt | Besser |
|---|---|
| „Euer Image ist unsicher.” | „Das Image enthält requests 2.25.0 mit CVE-2023-32681 (mittel).” |
| „Policy-Verstoß, sofort beheben.” | „Bitte runAsNonRoot: true setzen, Beispiel im Template
v2.3.” |
| „Das hättet ihr wissen müssen.” | „Die Regel gilt ab 01.12., bis dahin nur Warnung.” |
| „Abgelehnt.” | „So nicht genehmigungsfähig, mit Frist 30 Tage und NetworkPolicy ja.” |
Gute Befunde enthalten immer: was, wo, warum es wichtig ist, wie man es behebt und bis wann.
Hands-on-Lab: Ausnahmen, Fristen und Rollout als Code
In diesem Lab baust du die komplette Mechanik: eine Policy, die in drei Phasen scharf geschaltet wird, eine befristete Kyverno-Ausnahme, einen Ablauf-Check, ein Ausnahmeregister mit Validierung und die Verbindung zu Trivy-Ignores aus Kapitel 8.
Schritt 1: Arbeitsverzeichnis und Cluster prüfen
mkdir -p ~/seclab/kap10 && cd ~/seclab/kap10
kubectl config use-context kind-seclab
kubectl get nodes
kubectl -n kyverno get podsErwartete Ausgabe (gekürzt): Der Node
seclab-control-plane ist Ready, die
Kyverno-Pods laufen (Running). Falls Kyverno fehlt,
installiere es wie in Kapitel 9.
Seit Kyverno 1.13 sind Ausnahmen aus Sicherheitsgründen nur noch in
explizit erlaubten Namespaces wirksam. Wir erlauben genau einen
Namespace, policy-exceptions:
helm upgrade kyverno kyverno/kyverno -n kyverno --reuse-values \
--set features.policyExceptions.enabled=true \
--set features.policyExceptions.namespace=policy-exceptions
kubectl create namespace policy-exceptions
kubectl get namespace demo || kubectl create namespace demoPrüfe, welche API-Version deine Kyverno-Installation für Ausnahmen anbietet:
kubectl api-resources | grep -i policyexceptionErwartet: eine Zeile mit kyverno.io/v2 (ältere
Versionen: v2beta1, dann die apiVersion in den
folgenden Dateien anpassen).
Sicherheit: Wer PolicyExceptions anlegen darf, kann jede Policy aushebeln. Gib Schreibrechte im Namespace
policy-exceptionsper RBAC nur dem Security-Team bzw. dem GitOps-Werkzeug (Argo CD).
Schritt 2: Phase 1 „Beobachten” – Policy im Audit-Modus
Lege die Policy an. Wir nutzen das Feld failureAction
auf Regelebene (ab Kyverno 1.13; bei älteren Versionen
spec.validationFailureAction):
mkdir -p policies
cat > policies/require-run-as-non-root.yaml <<'EOF'
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
name: require-run-as-non-root
annotations:
policies.kyverno.io/description: >-
Pods muessen runAsNonRoot=true setzen. Stichtag Enforce: siehe Changelog.
spec:
background: true
emitWarning: false
rules:
- name: check-run-as-non-root
match:
any:
- resources:
kinds:
- Pod
namespaces:
- demo
validate:
failureAction: Audit
message: >-
Bitte spec.securityContext.runAsNonRoot=true setzen.
Beispiel: Template v2.3, Sprechstunde donnerstags 10 Uhr.
pattern:
spec:
securityContext:
runAsNonRoot: true
EOF
kubectl apply -f policies/require-run-as-non-root.yamlJetzt simulierst du ein Altsystem, das die Regel nicht erfüllt. Es
nutzt das demo-app-Image, setzt aber kein runAsNonRoot:
cat > legacy-batch.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
name: legacy-batch
namespace: demo
spec:
replicas: 1
selector:
matchLabels:
app: legacy-batch
template:
metadata:
labels:
app: legacy-batch
spec:
containers:
- name: app
image: reg-build:5000/demo-app:1.0.0
EOF
kubectl apply -f legacy-batch.yamlErwartet: deployment.apps/legacy-batch created ohne
Fehler, denn Audit blockiert nicht. Nach einigen Sekunden erscheint der
Verstoß im Policy Report:
kubectl -n demo get policyreportErwartete Ausgabe (Spalten je nach Version leicht anders):
NAME KIND NAME PASS FAIL ...
3f1c... Deployment legacy-batch 0 1 ...
9a7e... Pod legacy-batch-7d... 0 1 ...
Kyverno hat für Deployments automatisch eine Regel
autogen-check-run-as-non-root erzeugt (Auto-Gen). Deshalb
taucht auch das Deployment selbst im Report auf.
Schritt 3: Phase 2 „Warnen” – sichtbare Warnungen
Jetzt sollen Teams den Verstoß direkt sehen. Setze
emitWarning: true:
yq -i '.spec.emitWarning = true' policies/require-run-as-non-root.yaml
kubectl apply -f policies/require-run-as-non-root.yaml
kubectl -n demo rollout restart deployment legacy-batchErwartet: kubectl gibt eine Zeile aus, die mit
Warning: beginnt und den Policy-Namen sowie deine Meldung
„Bitte spec.securityContext.runAsNonRoot=true setzen…” enthält. Das
Deployment wird trotzdem ausgeführt.
Dasselbe gehört in die Pipeline: Mit der Kyverno-CLI prüft ein CI-Job die Manifeste und meldet Audit-Verstöße als Warnung statt als Fehler:
kyverno apply policies/require-run-as-non-root.yaml \
--resource legacy-batch.yaml --audit-warnErwartet: Eine Zusammenfassung mit warn: 1 (bzw. einem
Warnhinweis zur Regel) und Exit-Code 0. Ohne --audit-warn
zählt der Verstoß als fail.
Schritt 4: Befristete Kyverno-Ausnahme anlegen
Das Team von legacy-batch braucht 30 Tage, um das Image
umzubauen. Es bekommt eine befristete Ausnahme. Das Ablaufdatum steht im
Label seclab.example/expires, Verantwortlicher und Ticket
stehen in Annotationen.
Berechne zuerst ein Datum in 30 Tagen:
# Linux (GNU date):
EXPIRES=$(date -u -d '+30 days' +%F)
# macOS (BSD date):
EXPIRES=$(date -u -v+30d +%F)
echo "$EXPIRES"Erwartet: ein Datum im Format JJJJ-MM-TT, zum Beispiel
2026-11-07.
cat > exception-legacy-batch.yaml <<EOF
apiVersion: kyverno.io/v2
kind: PolicyException
metadata:
name: exc-2026-002-legacy-batch
namespace: policy-exceptions
labels:
seclab.example/expires: "${EXPIRES}"
annotations:
seclab.example/owner: "[email protected]"
seclab.example/approver: "[email protected]"
seclab.example/ticket: "SEC-130"
seclab.example/register-id: "EXC-2026-002"
spec:
exceptions:
- policyName: require-run-as-non-root
ruleNames:
- check-run-as-non-root
- autogen-check-run-as-non-root
match:
any:
- resources:
kinds:
- Pod
- Deployment
- ReplicaSet
namespaces:
- demo
names:
- legacy-batch*
EOF
kubectl apply -f exception-legacy-batch.yaml
kubectl -n policy-exceptions get policyexceptions --show-labelsErwartet: Die Ausnahme ist angelegt, die Spalte LABELS
zeigt seclab.example/expires=<Datum>.
Merke: Kubernetes-Labels dürfen keine Doppelpunkte enthalten. Ein reines Datum
2026-11-07ist erlaubt, ein Zeitstempel mit Uhrzeit nicht. Deshalb steht hier nur das Datum.
Damit niemand eine Ausnahme ohne Frist anlegt, prüft eine Meta-Policy jede PolicyException:
cat > policies/require-exception-metadata.yaml <<'EOF'
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
name: require-exception-metadata
spec:
background: false
rules:
- name: require-expiry-and-owner
match:
any:
- resources:
kinds:
- PolicyException
validate:
failureAction: Enforce
message: >-
Jede PolicyException braucht das Label seclab.example/expires
(JJJJ-MM-TT) und die Annotationen owner und ticket.
pattern:
metadata:
labels:
seclab.example/expires: "????-??-??"
annotations:
seclab.example/owner: "?*"
seclab.example/ticket: "?*"
EOF
kubectl apply -f policies/require-exception-metadata.yamlTeste die Meta-Policy mit einer Ausnahme ohne Label:
kubectl -n policy-exceptions create -f - <<'EOF'
apiVersion: kyverno.io/v2
kind: PolicyException
metadata:
name: ohne-frist
spec:
exceptions:
- policyName: require-run-as-non-root
ruleNames: ["check-run-as-non-root"]
match:
any:
- resources:
kinds: ["Pod"]
namespaces: ["demo"]
EOFErwartet:
admission webhook "validate.kyverno.svc-fail" denied the request
mit dem Hinweis auf require-exception-metadata. Im
Wildcard-Muster steht ? für genau ein Zeichen und
* für beliebig viele.
Schritt 5: Phase 3 „Erzwingen” – Stichtag per GitOps-MR
In der echten Umgebung liegen Policies in einem Git-Repository, das Argo CD in den Cluster synchronisiert (siehe Kapitel 9). Der Wechsel auf Enforce ist dann ein vorbereiteter Merge Request, der am Stichtag gemergt wird. Wir bauen das lokal nach:
cd ~/seclab/kap10/policies
git init -q -b main
git add . && git commit -qm "policies: require-run-as-non-root im Audit-Modus"
git switch -c enforce-run-as-non-root
yq -i '.spec.rules[0].validate.failureAction = "Enforce"' \
require-run-as-non-root.yaml
git diffErwartete Ausgabe (gekürzt):
- failureAction: Audit
+ failureAction: Enforce
git commit -qam "policies: require-run-as-non-root Enforce (Stichtag, CHG-0815)"
git switch main && git merge -q --no-ff enforce-run-as-non-root \
-m "Merge: Enforce require-run-as-non-root"
kubectl apply -f require-run-as-non-root.yaml # im Lab statt Argo CD
cd ~/seclab/kap10Prüfe beide Fälle. Erstens: Das Altsystem läuft dank Ausnahme weiter.
kubectl -n demo rollout restart deployment legacy-batch
kubectl -n demo rollout status deployment legacy-batch --timeout=60sErwartet:
deployment "legacy-batch" successfully rolled out.
Zweitens: Ein neues Deployment ohne runAsNonRoot wird
blockiert.
kubectl -n demo create deployment new-app \
--image=reg-build:5000/demo-app:1.0.0Erwartete Ausgabe (gekürzt):
error: failed to create deployment: admission webhook "validate.kyverno.svc-fail"
denied the request: ... require-run-as-non-root:
autogen-check-run-as-non-root: 'validation error: Bitte
spec.securityContext.runAsNonRoot=true setzen. ...'
Tipp: Enforce wirkt nur bei der Zulassung (Admission). Bereits laufende Pods werden nicht beendet. Erst beim nächsten Rollout oder Neustart greift die Regel. Plane den Stichtag deshalb nicht auf einen Freitagnachmittag.
GitLab CE kennt kein zeitgesteuertes Mergen. Bewährt hat sich: MR frühzeitig anlegen, Stichtag im Titel, Review vorab erledigen, am Stichtag im Change-Fenster mergen. Der MR verlinkt Ankündigung und Changelog-Eintrag.
Schritt 6: Abgelaufene Kyverno-Ausnahmen finden
Kyverno selbst ignoriert das Label
seclab.example/expires. Wir brauchen also einen Prüfer. Das
Skript sucht Ausnahmen, die abgelaufen sind oder gar kein Ablaufdatum
haben:
cat > find-expired-exceptions.sh <<'EOF'
#!/usr/bin/env bash
# Findet abgelaufene oder unbefristete Kyverno-PolicyExceptions.
# Exit-Code 1, wenn etwas gefunden wurde (z. B. fuer CronJob-Alarm).
set -euo pipefail
NS="${NS:-policy-exceptions}"
TODAY=$(date -u +%F)
RESULT=$(kubectl get policyexceptions.kyverno.io -n "$NS" -o json \
| jq -r --arg today "$TODAY" '
.items[]
| (.metadata.labels["seclab.example/expires"] // "") as $exp
| "\(.metadata.namespace)/\(.metadata.name)" as $n
| if $exp == "" then "OHNE-FRIST \($n)"
elif $exp <= $today then "ABGELAUFEN \($n) (seit \($exp))"
else empty end')
if [ -n "$RESULT" ]; then
echo "$RESULT"
exit 1
fi
echo "OK: keine abgelaufenen Ausnahmen in $NS (Stand $TODAY)"
EOF
chmod +x find-expired-exceptions.sh
./find-expired-exceptions.shErwartet:
OK: keine abgelaufenen Ausnahmen in policy-exceptions (Stand …).
Warum funktioniert $exp <= $today? Datumswerte im
Format JJJJ-MM-TT lassen sich als Text vergleichen, weil
die größte Einheit vorne steht. Ab dem Tag in expires gilt
die Ausnahme als abgelaufen. Das ist dieselbe Logik wie bei Trivys
expired_at.
Simuliere jetzt eine abgelaufene Ausnahme:
kubectl -n policy-exceptions label policyexception exc-2026-002-legacy-batch \
seclab.example/expires=2020-01-01 --overwrite
./find-expired-exceptions.sh; echo "Exit-Code: $?"Erwartet:
ABGELAUFEN policy-exceptions/exc-2026-002-legacy-batch (seit 2020-01-01)
Exit-Code: 1
Im Betrieb läuft der Check täglich als CronJob. Das Image
alpine/k8s enthält bash, kubectl und jq. Beziehe es wie
alle Images über deinen Spiegel (siehe Kapitel 3) und wähle einen Tag
passend zu deiner Clusterversion:
cat > cronjob-expired-exceptions.yaml <<'EOF'
apiVersion: v1
kind: ServiceAccount
metadata:
name: exception-checker
namespace: policy-exceptions
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: read-policyexceptions
namespace: policy-exceptions
rules:
- apiGroups: ["kyverno.io"]
resources: ["policyexceptions"]
verbs: ["get", "list"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: exception-checker
namespace: policy-exceptions
subjects:
- kind: ServiceAccount
name: exception-checker
namespace: policy-exceptions
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: Role
name: read-policyexceptions
---
apiVersion: batch/v1
kind: CronJob
metadata:
name: find-expired-exceptions
namespace: policy-exceptions
spec:
schedule: "0 7 * * *"
concurrencyPolicy: Forbid
jobTemplate:
spec:
backoffLimit: 0
template:
spec:
serviceAccountName: exception-checker
restartPolicy: Never
securityContext:
runAsNonRoot: true
runAsUser: 10001
containers:
- name: check
image: alpine/k8s:1.31.13 # ueber Nexus-Spiegel beziehen
command: ["/bin/bash", "/scripts/find-expired-exceptions.sh"]
env:
- name: HOME # kubectl-Cache in beschreibbares Verzeichnis
value: /tmp
volumeMounts:
- name: scripts
mountPath: /scripts
volumes:
- name: scripts
configMap:
name: find-expired-exceptions
EOF
kubectl -n policy-exceptions create configmap find-expired-exceptions \
--from-file=find-expired-exceptions.sh
kubectl apply -f cronjob-expired-exceptions.yaml
kubectl -n policy-exceptions create job --from=cronjob/find-expired-exceptions \
check-now
kubectl -n policy-exceptions wait --for=condition=failed job/check-now \
--timeout=120s
kubectl -n policy-exceptions logs job/check-nowErwartet: Der Job schlägt fehl (condition met), das Log
zeigt die Zeile ABGELAUFEN …. Ein fehlgeschlagener Job ist
gewollt: Über die Metrik kube_job_status_failed von
kube-state-metrics löst dein Monitoring einen Alarm aus.
Tipp: Kyverno kann Ressourcen über das Label
cleanup.kyverno.io/ttlauch automatisch löschen. Für Ausnahmen ist das „harte” Variante: Die Regel greift sofort nach Ablauf. Der Cleanup-Controller braucht dafür zusätzliche RBAC-Rechte fürpolicyexceptions. Viele Organisationen bevorzugen erst Alarm und Gespräch, dann Löschen per MR.
Setze das Label für die weiteren Schritte zurück:
kubectl -n policy-exceptions label policyexception exc-2026-002-legacy-batch \
seclab.example/expires="${EXPIRES}" --overwriteSchritt 7: Ausnahmeregister exceptions.yaml
anlegen
Das Register ist die zentrale Wahrheit. Kyverno-Ausnahmen und
Trivy-Ignores verweisen auf eine Register-ID. Lege das Register an (die
Variablen EXPIRES und CREATED setzen gültige
Daten relativ zu heute):
CREATED=$(date -u +%F)
cat > exceptions.yaml <<EOF
# Ausnahmeregister - Aenderungen nur per Merge Request.
# Genehmigung: CODEOWNERS (Security). Ab "expires" ist die Ausnahme ungueltig.
exceptions:
- id: EXC-2026-001
type: vulnerability
target: demo-app
reference: "pkg:pypi/[email protected]"
findings:
- CVE-2023-32681
- CVE-2024-35195
reason: "Upgrade auf requests 2.32 bricht Legacy-Client, Migration in 1.2.0"
risk: medium
compensation: "Kein verify=False (Semgrep-Regel), Egress nur intern"
owner: [email protected]
approver: [email protected]
ticket: SEC-123
created: "${CREATED}"
expires: "${EXPIRES}"
- id: EXC-2026-002
type: policy
target: demo/legacy-batch
reference: require-run-as-non-root
reason: "Altes Image schreibt nach /root, Umbau laeuft"
risk: high
compensation: "Eigener Namespace, NetworkPolicy deny-egress, readOnlyRootFS"
owner: [email protected]
approver: [email protected]
ticket: SEC-130
created: "${CREATED}"
expires: "${EXPIRES}"
EOF
yq '.exceptions | length' exceptions.yamlErwartet: 2.
Merke: Setze Datumswerte im Register immer in Anführungszeichen. Manche Parser machen sonst aus
2026-11-07einen Zeitstempel-Typ, und der Textvergleich im Skript schlägt fehl.
Schritt 8: Validierungsskript für das Register
Das Skript prüft jeden Eintrag: Pflichtfelder vorhanden, Datumsformat korrekt, nicht abgelaufen, Laufzeit höchstens 90 Tage, doppelte IDs. Ausnahmen, die in weniger als 14 Tagen ablaufen, ergeben eine Warnung.
cat > check-exceptions.sh <<'EOF'
#!/usr/bin/env bash
# check-exceptions.sh - prueft das Ausnahmeregister.
# Exit-Code 0 = gueltig, 1 = mindestens ein Fehler.
set -euo pipefail
FILE="${1:-exceptions.yaml}"
MAX_DAYS="${MAX_DAYS:-90}" # laengste erlaubte Laufzeit
WARN_DAYS="${WARN_DAYS:-14}" # Vorwarnzeit vor Ablauf
[ -f "$FILE" ] || { echo "FEHLER: $FILE nicht gefunden" >&2; exit 1; }
REQUIRED='["id","type","target","reference","reason","risk",
"compensation","owner","approver","ticket","created","expires"]'
REPORT=$(yq -o=json '.' "$FILE" | jq -r \
--argjson req "$REQUIRED" \
--argjson max "$MAX_DAYS" \
--argjson warn "$WARN_DAYS" '
def isdate: type == "string" and test("^[0-9]{4}-[0-9]{2}-[0-9]{2}$");
def ts: . + "T00:00:00Z" | fromdateiso8601;
now as $now
| (.exceptions // []) as $all
| ($all | map(.id) | group_by(.) | map(select(length > 1) | .[0])) as $dups
| ($dups[] | "FEHLER \(.): ID mehrfach vergeben"),
($all[] |
($req - [to_entries[] | select(.value != null and .value != "") | .key])
as $missing
| (.id // "ohne-id") as $id
| if ($missing | length) > 0 then
"FEHLER \($id): fehlende Felder: \($missing | join(", "))"
elif ((.created | isdate) and (.expires | isdate) | not) then
"FEHLER \($id): created/expires nicht im Format JJJJ-MM-TT"
elif (.expires | ts) <= $now then
"FEHLER \($id): abgelaufen seit \(.expires)"
elif ((.expires | ts) - (.created | ts)) > ($max * 86400) then
"FEHLER \($id): Laufzeit laenger als \($max) Tage"
elif ((.expires | ts) - $now) < ($warn * 86400) then
"WARNUNG \($id): laeuft am \(.expires) ab"
else
"OK \($id): gueltig bis \(.expires)"
end)
')
echo "$REPORT"
if grep -q '^FEHLER' <<<"$REPORT"; then
echo "Ergebnis: Ausnahmeregister ungueltig" >&2
exit 1
fi
echo "Ergebnis: Ausnahmeregister gueltig"
EOF
chmod +x check-exceptions.sh
./check-exceptions.shErwartete Ausgabe:
OK EXC-2026-001: gueltig bis 2026-11-07
OK EXC-2026-002: gueltig bis 2026-11-07
Ergebnis: Ausnahmeregister gueltig
Ein paar Erklärungen zum jq-Teil:
$req - [...]ist eine Mengendifferenz: Pflichtfelder minus vorhandene, nicht leere Felder ergibt die fehlenden.fromdateiso8601wandelt2026-11-07T00:00:00Zin Sekunden seit 1970 um. So kann jq mit Daten rechnen, ganz ohne die unterschiedlichendate-Varianten von Linux und macOS.nowist die aktuelle Zeit in Sekunden.
Jetzt provozierst du Fehler:
cp exceptions.yaml exceptions.bak
yq -i 'del(.exceptions[1].compensation)' exceptions.yaml
yq -i '.exceptions[0].expires = "2020-01-01"' exceptions.yaml
./check-exceptions.sh; echo "Exit-Code: $?"
mv exceptions.bak exceptions.yamlErwartet:
FEHLER EXC-2026-001: abgelaufen seit 2020-01-01
FEHLER EXC-2026-002: fehlende Felder: compensation
Ergebnis: Ausnahmeregister ungueltig
Exit-Code: 1
In der Pipeline sieht das so aus. Der Job läuft bei jedem MR, der das Register ändert, und zusätzlich täglich per Pipeline-Zeitplan (Schedule). So wird eine Ausnahme rot, sobald sie abläuft, auch wenn niemand die Datei anfasst:
exceptions:validate:
stage: verify
image: nexus:8082/alpine/k8s:1.31.13 # enthaelt bash, jq, yq
script:
- ./check-exceptions.sh exceptions.yaml
rules:
- if: $CI_PIPELINE_SOURCE == "schedule"
- changes:
- exceptions.yaml
- .trivyignore.yamlUnd die CODEOWNERS-Datei im Repository-Root (oder unter
.gitlab/CODEOWNERS):
# Ausnahmen genehmigt nur das Security-Team
/exceptions.yaml @seclab/security
/.trivyignore.yaml @seclab/security
/policies/ @seclab/security
Schritt 9: Trivy-Ignore mit Ablaufdatum anbinden
In Kapitel 8 hast du Befunde mit .trivyignore.yaml und
expired_at unterdrückt. Jetzt verbindest du beides: Jeder
Ignore-Eintrag muss im Feld statement auf eine Register-ID
verweisen, und expired_at muss genau dem
expires im Register entsprechen.
mkdir -p ~/seclab/kap10/app && cp ~/seclab/demo-app/requirements.txt app/
cat > app/.trivyignore.yaml <<EOF
vulnerabilities:
- id: CVE-2023-32681
purls:
- "pkg:pypi/[email protected]"
statement: "EXC-2026-001: Migration requests in 1.2.0"
expired_at: ${EXPIRES}
- id: CVE-2024-35195
purls:
- "pkg:pypi/[email protected]"
statement: "EXC-2026-001: Migration requests in 1.2.0"
expired_at: ${EXPIRES}
EOF
trivy fs --scanners vuln --severity MEDIUM,HIGH,CRITICAL \
--ignorefile app/.trivyignore.yaml --show-suppressed app/Erwartet: Die beiden CVEs stehen in der Tabelle „Suppressed
Vulnerabilities” mit dem Statement EXC-2026-001 …. Weitere
requests-Befunde (zum Beispiel CVE-2024-47081) bleiben sichtbar, denn
sie sind nicht genehmigt. Die genaue Liste hängt vom Stand der
Trivy-Datenbank ab. --show-suppressed gibt es in neueren
Trivy-Versionen; fehlt es bei dir, lass es weg.
Achtung: Hier gilt die umgekehrte Regel wie im Register: Trivy erwartet
expired_atals ungequotetes YAML-Datum (expired_at: 2026-11-07). Mit Anführungszeichen bricht Trivy mit einem Parse-Fehler ab.
Nach Ablauf von expired_at wirkt der Ignore-Eintrag
automatisch nicht mehr, und der Scan-Job (siehe Kapitel 8) wird wieder
rot. Damit Register und Ignore-Datei nicht auseinanderlaufen, prüft ein
zweites Skript die Konsistenz:
cat > check-trivyignore.sh <<'EOF'
#!/usr/bin/env bash
# Jeder Trivy-Ignore braucht eine passende Ausnahme im Register.
set -euo pipefail
IGNORE="${1:-.trivyignore.yaml}"
REGISTER="${2:-exceptions.yaml}"
REPORT=$(jq -n -r \
--argjson t "$(yq -o=json '.vulnerabilities // []' "$IGNORE")" \
--argjson e "$(yq -o=json '.exceptions // []' "$REGISTER")" '
($e | map({key: .id, value: .}) | from_entries) as $byid
| $t[]
| . as $v
| ($v.statement // "" | capture("(?<id>EXC-[0-9]{4}-[0-9]{3})").id // "")
as $exc
| $byid[$exc] as $x
| if $x == null then
"FEHLER \($v.id): keine passende Ausnahme im Register"
elif ([$x.reference] + ($x.findings // []) | index($v.id)) == null then
"FEHLER \($v.id): nicht in \($exc) aufgefuehrt"
elif ($v.expired_at | tostring) != $x.expires then
"FEHLER \($v.id): expired_at \($v.expired_at) passt nicht zu \($x.expires)"
else
"OK \($v.id) -> \($exc)"
end
')
echo "$REPORT"
if grep -q '^FEHLER' <<<"$REPORT"; then exit 1; fi
EOF
chmod +x check-trivyignore.sh
./check-trivyignore.sh app/.trivyignore.yaml exceptions.yamlErwartet:
OK CVE-2023-32681 -> EXC-2026-001
OK CVE-2024-35195 -> EXC-2026-001
Teste den Fehlerfall, indem du einen Ignore ohne Register-Eintrag ergänzt:
yq -i '.vulnerabilities += [{"id": "CVE-2024-47081",
"statement": "brauchen wir nicht"}]' app/.trivyignore.yaml
./check-trivyignore.sh app/.trivyignore.yaml exceptions.yaml; echo "Exit: $?"Erwartet:
FEHLER CVE-2024-47081: keine passende Ausnahme im Register
und Exit: 1. Genau so fällt in einem Review auf, wenn
jemand Befunde „wegignoriert”.
Schritt 10: Vorlagen für Rollout-Plan und Ankündigung
Technik ist nur die halbe Miete. Lege zwei Vorlagen ins Repository, damit jede neue Regel gleich kommuniziert wird:
cat > ROLLOUT-PLAN-TEMPLATE.md <<'EOF'
Rollout-Plan: <Regelname> (Changelog-ID: POL-<nr>)
1. Ziel und Risiko: Welches Risiko senkt die Regel? Quelle (Audit, Vorfall)?
2. Betroffene: Anzahl Verstoesse laut Audit-Report am <Datum>, Teams: <Liste>
3. Golden Path: Template/Basis-Image/Doku-Link, das die Regel erfuellt
4. Zeitplan:
- T-6 Wochen <Datum>: Ankuendigung, Audit-Modus
- T-3 Wochen <Datum>: Warnung (emitWarning, CI --audit-warn)
- T-1 Woche <Datum>: Frist fuer Ausnahmeantraege
- T <Datum>: Enforce per MR <Link>, Change <Nr>
- T+2 Wochen <Datum>: Review
5. Ausnahmen: per MR auf exceptions.yaml, max. 90 Tage
6. Rueckfallplan: Revert-MR auf Audit, wer darf ihn mergen?
7. Erfolgskriterium: Anteil konformer Deployments > 95 % nach T+2 Wochen
EOF
cat > MAIL-TEMPLATE.txt <<'EOF'
Betreff: [Plattform] Neue Regel "<Regelname>" - Warnung ab <Datum>,
Pflicht ab <Stichtag>
Hallo zusammen,
was aendert sich? Ab <Stichtag> lehnt der Cluster Pods ohne <Bedingung> ab.
Warum? <ein Satz zum Risiko, ohne Fachjargon>.
Was muesst ihr tun? <konkreter Schritt, z. B. Template auf v2.3 heben>.
Wie pruefe ich das? <Befehl oder Link zum Policy-Report eures Namespaces>.
Was, wenn es nicht geht? Ausnahme per Merge Request auf exceptions.yaml
bis <Datum>, mit Begruendung, Kompensation und Frist (max. 90 Tage).
Hilfe: Sprechstunde donnerstags 10-11 Uhr, Kanal #plattform-security,
euer Security-Champion.
Zeitplan: Beobachten ab <Datum>, Warnen ab <Datum>, Erzwingen ab <Stichtag>.
Danke fuers Mitziehen!
Euer Plattform-Team
EOF
lsErwartet: Die beiden Vorlagen liegen neben deinen Policies und Skripten.
Schritt 11: Metrik „Anteil konformer Ressourcen” berechnen
Die Policy Reports enthalten eine Zusammenfassung pro Ressource. Mit jq summierst du sie:
kubectl get policyreports -A -o json | jq '
[.items[].summary] as $s
| ($s | map(.pass // 0) | add // 0) as $pass
| ($s | map(.fail // 0) | add // 0) as $fail
| {pass: $pass, fail: $fail,
konform_prozent: (if ($pass + $fail) > 0
then ($pass * 100 / ($pass + $fail) | floor) else 100 end)}'Erwartet: ein JSON-Objekt, zum Beispiel
{"pass": 4, "fail": 2, "konform_prozent": 66}. Die Werte
hängen davon ab, welche Policies und Workloads aus Kapitel 9 noch
laufen. Ausnahmen zählen in Kyverno als skip, nicht als
pass. Für die Zahl offener Ausnahmen nimmst du das
Register: yq '.exceptions | length' exceptions.yaml.
Schritt 12: Aufräumen
kubectl -n demo delete deployment legacy-batch --ignore-not-found
kubectl delete -f cronjob-expired-exceptions.yaml --ignore-not-found
kubectl -n policy-exceptions delete configmap find-expired-exceptions \
--ignore-not-found
kubectl -n policy-exceptions delete policyexception --all
kubectl delete clusterpolicy require-run-as-non-root require-exception-metadata
kubectl get clusterpolicyErwartet: Die beiden Policies aus diesem Kapitel sind verschwunden,
die Policies aus Kapitel 9 bleiben. Die Dateien in
~/seclab/kap10 brauchst du in Kapitel 11 wieder, lösche sie
nicht.
Fortschritt speichern? Kostenlos registrieren
Typische Stolperfallen
| Symptom | Ursache | Lösung |
|---|---|---|
| PolicyException wirkt nicht | Namespace nicht freigegeben (ab 1.13) | features.policyExceptions.namespace setzen |
| Deployment trotz Ausnahme blockiert | Auto-Gen-Regel fehlt in ruleNames |
autogen-<regel> ergänzen |
| Label wird abgelehnt | Doppelpunkt (Uhrzeit) im Labelwert | nur JJJJ-MM-TT verwenden |
| Skript meldet Formatfehler | Datum im Register ohne Anführungszeichen | Datumswerte quoten |
Trivy: yaml decode error |
expired_at in Anführungszeichen |
Datum ungequotet schreiben |
Keine Warnung bei kubectl apply |
emitWarning fehlt oder Policy ist Enforce |
spec.emitWarning: true im Audit |
| Ausnahme läuft ab, niemand merkt es | Prüfung nur bei Änderung der Datei | zusätzlich täglicher Schedule |
| CODEOWNERS wird ignoriert | Freigabepflicht ist Premium | eigenes Repo mit Merge-Rechten |
| Enforce legt Altsysteme lahm | keine Audit-Phase, keine Bestandsaufnahme | erst Reports, dann Stichtag |
Übung: Rollenspiel – „Wir brauchen eine unbefristete Ausnahme”
Das Team „Zahlungsverkehr” schreibt dir:
„Unser Image
payment-gatewaybraucht root, weil ein Hersteller-Agent das verlangt. Das wird sich nie ändern. Bitte tragt eine unbefristete Ausnahme für den ganzen Namespacepaymentsein. Morgen ist Release.”
Deine Aufgabe:
- Formuliere eine Antwort an das Team (5–8 Sätze), die nicht einfach „Nein” sagt.
- Schreibe den Eintrag für
exceptions.yaml, den du genehmigen würdest. - Schreibe die passende Kyverno-PolicyException.
- Prüfe beides mit
check-exceptions.shund der Meta-Policy aus Schritt 4.
Hinweis 1
Trenne drei Dinge: den berechtigten Kern (Hersteller-Agent, Release morgen), die nicht genehmigungsfähigen Teile (unbefristet, ganzer Namespace) und das, was du anbieten kannst (Frist, enger Geltungsbereich, Kompensation, Hilfe). Frag auch nach: Hat der Hersteller eine non-root-Variante oder eine Roadmap?
Hinweis 2
Der Geltungsbereich sollte nur das eine Deployment treffen
(names: ["payment-gateway*"]). Eine typische Frist ist 90
Tage, mit Wiedervorlage. Kompensationen für root-Container:
NetworkPolicy, read-only Root-Dateisystem,
allowPrivilegeEscalation: false, Capabilities droppen, kein
automatisch gemountetes Service-Account-Token. Und: „nie ändern” ist ein
Fall für eine Risikoübernahme durch die Produktverantwortung, nicht für
eine technische Dauerausnahme.
Lösung
Beispielantwort an das Team:
„Danke für die frühe Info, das Release morgen gefährden wir nicht. Eine unbefristete Ausnahme für den ganzen Namespace kann ich nicht genehmigen, weil sie auch für künftige Dienste gelten würde, die root gar nicht brauchen. Ich schlage vor: eine Ausnahme nur für
payment-gateway, 90 Tage gültig, ab heute. Als Ausgleich setzen wir eine NetworkPolicy, ein read-only Dateisystem und droppen alle Capabilities außer den nötigen, dabei helfe ich gern in der Sprechstunde. Bitte fragt parallel beim Hersteller nach einer non-root-Variante. Wenn es dauerhaft keine gibt, bereiten wir zusammen eine Risikoübernahme durch eure Produktverantwortung vor. Den MR auf exceptions.yaml lege ich euch als Entwurf an.”
Registereintrag:
- id: EXC-2026-003
type: policy
target: payments/payment-gateway
reference: require-run-as-non-root
reason: "Hersteller-Agent v4 benoetigt root; Anfrage HER-77 beim Hersteller"
risk: high
compensation: >-
NetworkPolicy nur zu payment-db, readOnlyRootFilesystem,
drop ALL capabilities, automountServiceAccountToken=false
owner: [email protected]
approver: [email protected]
ticket: SEC-145
created: "2026-10-08"
expires: "2027-01-06"PolicyException:
apiVersion: kyverno.io/v2
kind: PolicyException
metadata:
name: exc-2026-003-payment-gateway
namespace: policy-exceptions
labels:
seclab.example/expires: "2027-01-06"
annotations:
seclab.example/owner: "[email protected]"
seclab.example/ticket: "SEC-145"
seclab.example/register-id: "EXC-2026-003"
spec:
exceptions:
- policyName: require-run-as-non-root
ruleNames:
- check-run-as-non-root
- autogen-check-run-as-non-root
match:
any:
- resources:
kinds: ["Pod", "Deployment", "ReplicaSet"]
namespaces: ["payments"]
names: ["payment-gateway*"]Wenn du die Daten an „heute” anpasst, liefert
check-exceptions.sh für EXC-2026-003 OK
(Laufzeit genau 90 Tage). Bei 91 Tagen meldet es
Laufzeit laenger als 90 Tage. Die Meta-Policy akzeptiert
die PolicyException, weil Label und Annotationen vorhanden sind. Der
eigentliche Lerneffekt: Du hast das Problem des Teams gelöst, ohne die
Regel aufzugeben.
Fortschritt speichern? Kostenlos registrieren
Aus der Praxis
In Behörden und KRITIS-Unternehmen ist der Ausnahmeprozess oft Teil des Informationssicherheits-Managements (ISMS nach ISO 27001 oder IT-Grundschutz). Dort heißt die Ausnahme häufig „Risikoakzeptanz” oder „Abweichung”. Der Gedanke ist derselbe: Ein benannter Risikoeigentümer unterschreibt, dass er ein Restrisiko für eine bestimmte Zeit trägt. Dein Register als Code ist dafür ein hervorragender Nachweis, weil jede Änderung mit Autor, Zeitpunkt und Freigabe in Git steht. Für Audits exportierst du das Register samt Git-Log als Anhang.
Einige Erfahrungen aus Projekten:
- Erst messen, dann regeln. Bevor du eine Regel ankündigst, lass sie zwei Wochen im Audit-Modus laufen. Wenn 60 % der Workloads sie verletzen, fehlt ein Golden Path, nicht Disziplin.
- Ausnahmen haben eine Obergrenze. Viele Organisationen erlauben höchstens 90 Tage und höchstens eine Verlängerung. Danach entscheidet ein Gremium (zum Beispiel das Change Advisory Board).
- Ausnahmen sichtbar machen. Ein wöchentlicher Bericht „offene Ausnahmen, bald ablaufend” an Teamleitungen wirkt besser als jede Eskalation.
- In air-gapped Umgebungen laufen Ablauf-Checks lokal: CronJob im Cluster, Pipeline-Schedule in der internen GitLab-Instanz. Benachrichtigungen gehen über den internen Mailserver oder das interne Ticketsystem.
- Auditierbarkeit: Kyverno schreibt Policy Reports als Kubernetes-Ressourcen. Exportiere sie regelmäßig (zum Beispiel per Policy Reporter in ein Monitoring), denn Reports sind Momentaufnahmen und verschwinden mit der Ressource.
- Champions belohnen. Ein Champion-Programm lebt von Anerkennung: Zeitbudget (zum Beispiel 10 %), Weiterbildung, Sichtbarkeit in der Organisation.
- Notfallweg definieren. Für echte Notfälle (Produktionsausfall) braucht es einen dokumentierten Break-Glass-Weg: Ausnahme sofort, Genehmigung nachträglich innerhalb von 24 Stunden, automatisch nach 7 Tagen abgelaufen.
Interviewfragen
F: Ein Team sagt: „Eure Policies blockieren unser Release heute Abend.” Wie reagierst du? A: Ruhig bleiben und den konkreten Befund ansehen. Ist es ein echter Verstoß, biete ich die schnellste saubere Lösung an (Fix im Manifest, Template). Geht das nicht rechtzeitig, gibt es eine kurz befristete Ausnahme per MR mit Kompensation. Danach kläre ich in einer Nachbesprechung, warum das Team den Verstoß nicht früher gesehen hat, zum Beispiel weil die Warnphase fehlte.
F: Wie führst du eine neue, strenge Regel ein, ohne die Organisation zu blockieren? A: In drei Phasen: Audit zur Bestandsaufnahme, Warnung im CI und beim Deployment, dann Enforce an einem angekündigten Stichtag per GitOps-MR. Vorher stelle ich einen Golden Path bereit, der die Regel erfüllt. Kommunikation über Ankündigung, Changelog, Sprechstunde und Champions.
F: Ein Entwickler setzt den Scan-Job heimlich auf
allow_failure: true. Was tust du? A: Erst
verstehen, warum: Fehlalarme, Zeitdruck, unklare Befunde? Dann den
legitimen Weg zeigen, also eine befristete Ausnahme für den konkreten
Befund. Technisch verhindere ich das künftig, indem Sicherheitsjobs aus
einem zentral gepflegten, gepinnten Template kommen und Änderungen an
.gitlab-ci.yml per CODEOWNERS reviewt werden. Kein
öffentliches Bloßstellen.
F: Was gehört in einen Ausnahmeantrag? A: Begründung, Risikoeinschätzung, Kompensation, Ablaufdatum, Verantwortlicher, Genehmiger, Ticket und ein enger Geltungsbereich. Ohne Ablaufdatum keine Genehmigung.
F: Das Management will eine unbefristete Ausnahme für ein Altsystem. Wie gehst du vor? A: Ich mache das Risiko transparent und schlage eine formale Risikoübernahme durch den Risikoeigentümer vor, mit jährlicher Wiedervorlage und Kompensationen. Technisch bleibt es eine befristete Ausnahme, die regelmäßig bewusst erneuert wird. So geht das Risiko nicht in Vergessenheit.
F: Wie misst du, ob dein Security-Programm wirkt? A: Mit dem Anteil konformer Deployments aus den Policy Reports, der Zahl und dem Alter offener Ausnahmen und der MTTR für kritische Befunde. Ich schaue auf Trends über Zeit und vermeide Ranglisten zwischen Teams, weil die eher zu Verschleierung führen.
F: Zwei Teams streiten, ob ein CVE überhaupt relevant ist. Wie entscheidest du? A: Mit einer dokumentierten Triage (siehe Kapitel 8): Ist die verwundbare Funktion erreichbar, gibt es einen Exploit, wie ist die Exposition? Das Ergebnis halte ich fest, zum Beispiel als VEX-Aussage oder als Ausnahme mit Begründung. Die Entscheidung trifft der Risikoeigentümer, nicht der Lauteste.
Zusammenfassung
Das hast du gelernt:
- Sicherheit setzt sich durch, wenn der sichere Weg der bequemste ist: Paved Road, Golden Path, gepinnte Templates und CI-Komponenten.
- Neue Regeln führst du in drei Phasen ein: Beobachten (Audit), Warnen
(
emitWarning,--audit-warn), Erzwingen (Enforce per GitOps-MR am Stichtag). - Eine gute Ausnahme ist begründet, risikobewertet, kompensiert, eng gefasst, befristet und hat einen Verantwortlichen und einen Genehmiger.
- Das Ausnahmeregister als Code macht den Prozess prüfbar: MR als Antrag, CODEOWNERS als Genehmiger, Pipeline als Prüfer, Git-Log als Audit-Trail.
- Abgelaufene Kyverno-Ausnahmen findest du mit Label, kubectl und jq, im Betrieb als CronJob mit Alarm.
- Trivy-Ignores mit
expired_atverweisen auf Register-IDs, ein Konsistenzcheck verhindert stilles Wegignorieren. - Metriken (Konformität, offene Ausnahmen, MTTR) zeigen Trends, keine Schuldigen.
- Befunde formulierst du konkret und lösungsorientiert: was, wo, warum, wie beheben, bis wann.