Zum Inhalt springen
Trainingslager IT-Trainingslager

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

  1. Automatische Erinnerung an Verantwortlichen (14 und 3 Tage vor Ablauf).
  2. Nach Ablauf: Gespräch Security-Champion und Teamleitung.
  3. Nach weiteren 7 Tagen: Produktverantwortung entscheidet über Risikoübernahme (schriftlich) oder Priorisierung.
  4. 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 pods

Erwartete 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 demo

Prüfe, welche API-Version deine Kyverno-Installation für Ausnahmen anbietet:

kubectl api-resources | grep -i policyexception

Erwartet: 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-exceptions per 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.yaml

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

Erwartet: deployment.apps/legacy-batch created ohne Fehler, denn Audit blockiert nicht. Nach einigen Sekunden erscheint der Verstoß im Policy Report:

kubectl -n demo get policyreport

Erwartete 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-batch

Erwartet: 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-warn

Erwartet: 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-labels

Erwartet: 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-07 ist 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.yaml

Teste 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"]
EOF

Erwartet: 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 diff

Erwartete 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/kap10

Prü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=60s

Erwartet: 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.0

Erwartete 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.sh

Erwartet: 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-now

Erwartet: 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/ttl auch 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ür policyexceptions. 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}" --overwrite

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

Erwartet: 2.

Merke: Setze Datumswerte im Register immer in Anführungszeichen. Manche Parser machen sonst aus 2026-11-07 einen 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.sh

Erwartete 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.
  • fromdateiso8601 wandelt 2026-11-07T00:00:00Z in Sekunden seit 1970 um. So kann jq mit Daten rechnen, ganz ohne die unterschiedlichen date-Varianten von Linux und macOS.
  • now ist 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.yaml

Erwartet:

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

Und 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_at als 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.yaml

Erwartet:

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
ls

Erwartet: 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 clusterpolicy

Erwartet: 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-gateway braucht root, weil ein Hersteller-Agent das verlangt. Das wird sich nie ändern. Bitte tragt eine unbefristete Ausnahme für den ganzen Namespace payments ein. Morgen ist Release.”

Deine Aufgabe:

  1. Formuliere eine Antwort an das Team (5–8 Sätze), die nicht einfach „Nein” sagt.
  2. Schreibe den Eintrag für exceptions.yaml, den du genehmigen würdest.
  3. Schreibe die passende Kyverno-PolicyException.
  4. Prüfe beides mit check-exceptions.sh und 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_at verweisen 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.