Zum Inhalt springen
Trainingslager IT-Trainingslager

Anhang A: Spickzettel

Dieser Anhang ist zum Nachschlagen gedacht, nicht zum Durchlesen. Pro Werkzeug findest du die Befehle und YAML-Schnipsel, die du in den Labs am häufigsten brauchst. Jeder Schnipsel hat eine Zeile Erklärung. Die Werte passen zu den Lab-Konventionen aus Kapitel 0: Registries localhost:5001 (Build) und localhost:5002 (Ziel), Vault unter localhost:8200, Nexus unter localhost:8081.

Achtung: Passwörter und Tokens in diesem Anhang sind Lab-Werte. In echten Umgebungen gehören sie in einen Secret-Speicher, nie in die Shell-History oder ein Repository.

Tipp: Flags ändern sich zwischen Versionen. Wenn ein Befehl nicht klappt, prüfe zuerst <werkzeug> --version und <werkzeug> <befehl> --help.

GitLab CI (siehe Kapitel 1)

Grundgerüst einer Pipeline mit Stufen (Stages) und Abhängigkeiten:

stages: [build, scan, sign, deploy]

build:
  stage: build
  image: docker:27
  services: [docker:27-dind]
  script:
    - docker build -t "$CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA" .
    - docker push "$CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA"

Job nur auf dem Hauptzweig oder bei Tags laufen lassen:

deploy:
  stage: deploy
  rules:
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
    - if: $CI_COMMIT_TAG
  script: ["./deploy.sh"]

Ergebnisse eines Jobs als Artefakt weitergeben und gezielt abhängen:

sbom:
  stage: scan
  script: ["syft dir:. -o cyclonedx-json=sbom.cdx.json"]
  artifacts:
    paths: [sbom.cdx.json]
    expire_in: 30 days

grype:
  stage: scan
  needs: ["sbom"]
  script: ["grype sbom:./sbom.cdx.json --fail-on high"]

Gemeinsame Vorlagen aus einem zentralen Repo einbinden:

include:
  - project: platform/ci-templates
    ref: v1.4.0
    file: /templates/security-scans.yml

Runner nicht-interaktiv registrieren (neuer Token-Ablauf ab GitLab 16):

gitlab-runner register --non-interactive \
  --url http://localhost:8929 \
  --token glrt-LAB-TOKEN \
  --executor docker \
  --docker-image alpine:3.20

Pipeline-Datei vor dem Commit prüfen: im GitLab-UI unter Build > Pipeline editor > Validate (CI Lint).

Jenkins (siehe Kapitel 1)

Deklarative Pipeline (Jenkinsfile) mit Credentials aus dem Jenkins-Speicher:

pipeline {
  agent any
  options { timeout(time: 30, unit: 'MINUTES') }
  stages {
    stage('Build') {
      steps { sh 'docker build -t localhost:5001/demo-app:1.0.0 .' }
    }
    stage('Push') {
      steps {
        withCredentials([usernamePassword(credentialsId: 'reg-build',
            usernameVariable: 'REG_USER', passwordVariable: 'REG_PASS')]) {
          sh '''
            echo "$REG_PASS" | docker login localhost:5001 \\
              -u "$REG_USER" --password-stdin
            docker push localhost:5001/demo-app:1.0.0
          '''
        }
      }
    }
  }
  post { always { archiveArtifacts artifacts: '*.json', allowEmptyArchive: true } }
}

Initiales Admin-Passwort aus dem Container lesen:

docker exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword

Job über die Jenkins-CLI starten und auf das Ende warten:

curl -sO http://localhost:8090/jnlpJars/jenkins-cli.jar
java -jar jenkins-cli.jar -s http://localhost:8090/ \
  -auth admin:API-TOKEN build demo-pipeline -s -v

Installierte Plugins auflisten (für Inventar und Update-Planung):

java -jar jenkins-cli.jar -s http://localhost:8090/ \
  -auth admin:API-TOKEN list-plugins

Sicherheit: In Jenkins nie Secrets mit echo ausgeben. withCredentials maskiert sie im Log, aber nur, wenn sie unverändert ausgegeben werden.

Argo CD (siehe Kapitel 1)

Initiales Admin-Passwort holen und anmelden:

argocd admin initial-password -n argocd
argocd login localhost:8443 --insecure --username admin \
  --password 'LAB-PASSWORT'

Anwendung per CLI anlegen:

argocd app create demo \
  --repo http://gitlab.local/demo/demo-app.git --path k8s \
  --dest-server https://kubernetes.default.svc --dest-namespace demo

Status, Unterschiede und Synchronisation:

argocd app get demo          # Sync- und Health-Status
argocd app diff demo         # Abweichung Git vs. Cluster
argocd app sync demo         # manuell synchronisieren
argocd app history demo      # bisherige Deployments
argocd app rollback demo 3   # auf History-ID 3 zurück

Deklarative Application mit automatischem Abgleich:

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: demo
  namespace: argocd
spec:
  project: default
  source:
    repoURL: http://gitlab.local/demo/demo-app.git
    targetRevision: main
    path: k8s
  destination:
    server: https://kubernetes.default.svc
    namespace: demo
  syncPolicy:
    automated: { prune: true, selfHeal: true }
    syncOptions: ["CreateNamespace=true"]

Flux (siehe Kapitel 1)

Flux ist nicht Teil des Standard-Labs. Die flux-CLI installierst du bei Bedarf separat.

flux check --pre                       # Cluster-Voraussetzungen prüfen
flux install                           # Controller ohne Git-Bootstrap installieren

Git-Quelle und Kustomization anlegen:

flux create source git demo \
  --url=http://gitlab.local/demo/demo-app.git \
  --branch=main --interval=1m
flux create kustomization demo \
  --source=GitRepository/demo --path="./k8s" \
  --prune=true --interval=5m --target-namespace=demo

Status prüfen, sofort abgleichen, pausieren:

flux get sources git
flux get kustomizations
flux reconcile kustomization demo --with-source
flux suspend kustomization demo
flux resume kustomization demo
flux logs --level=error

Nexus Repository REST-API (siehe Kapitel 3)

Erreichbarkeit und Schreibbereitschaft prüfen:

curl -s -o /dev/null -w '%{http_code}\n' \
  http://localhost:8081/service/rest/v1/status            # 200 = läuft
curl -s -o /dev/null -w '%{http_code}\n' \
  http://localhost:8081/service/rest/v1/status/writable   # 200 = beschreibbar

Initiales Admin-Passwort aus dem Container:

docker exec nexus cat /nexus-data/admin.password

Repositories auflisten:

curl -s -u admin:LAB-PASSWORT \
  http://localhost:8081/service/rest/v1/repositories | jq '.[].name'

Docker-Proxy-Repository für Docker Hub per API anlegen:

curl -s -u admin:LAB-PASSWORT -H 'Content-Type: application/json' \
  -X POST http://localhost:8081/service/rest/v1/repositories/docker/proxy \
  -d @docker-proxy.json
{
  "name": "dockerhub-proxy",
  "online": true,
  "storage": { "blobStoreName": "default", "strictContentTypeValidation": true },
  "proxy": { "remoteUrl": "https://registry-1.docker.io",
             "contentMaxAge": 1440, "metadataMaxAge": 1440 },
  "negativeCache": { "enabled": true, "timeToLive": 1440 },
  "httpClient": { "blocked": false, "autoBlock": true },
  "docker": { "v1Enabled": false, "forceBasicAuth": true, "httpPort": 8082 },
  "dockerProxy": { "indexType": "HUB" }
}

Komponenten in einem Repository suchen:

curl -s -u admin:LAB-PASSWORT \
  'http://localhost:8081/service/rest/v1/search?repository=pypi-proxy&name=flask' \
  | jq '.items[] | {name, version}'

Harbor REST-API (siehe Kapitel 3)

Harbor ist im Lab optional. Die API liegt unter /api/v2.0. Ersetze harbor.local durch deinen Host.

# Projekte auflisten
curl -s -u admin:LAB-PASSWORT https://harbor.local/api/v2.0/projects \
  | jq '.[].name'

# Privates Projekt anlegen
curl -s -u admin:LAB-PASSWORT -H 'Content-Type: application/json' \
  -X POST https://harbor.local/api/v2.0/projects \
  -d '{"project_name":"demo","metadata":{"public":"false"}}'

Artefakte inklusive Scan-Zusammenfassung abfragen:

H=https://harbor.local/api/v2.0/projects/demo/repositories/demo-app
curl -s -u admin:LAB-PASSWORT \
  "$H/artifacts?with_scan_overview=true" \
  | jq '.[] | {digest, tags: [.tags[]?.name]}'

Scan für ein Artefakt anstoßen:

curl -s -u admin:LAB-PASSWORT -X POST "$H/artifacts/1.0.0/scan"

Merke: Enthält der Repository-Name einen Schrägstrich (team/demo-app), musst du ihn in der URL doppelt kodieren: team%252Fdemo-app.

skopeo, crane, oras (siehe Kapitel 3 und 4)

skopeo

# Metadaten lesen, ohne das Image zu laden
skopeo inspect --tls-verify=false docker://localhost:5001/demo-app:1.0.0

# Tags auflisten
skopeo list-tags --tls-verify=false docker://localhost:5001/demo-app

# Von Registry zu Registry kopieren, Digest unverändert lassen
skopeo copy --all --preserve-digests \
  --src-tls-verify=false --dest-tls-verify=false \
  docker://localhost:5001/demo-app:1.0.0 \
  docker://localhost:5002/demo-app:1.0.0

# In ein OCI-Archiv für den Datenträger-Transport schreiben
skopeo copy --src-tls-verify=false \
  docker://localhost:5001/demo-app:1.0.0 oci-archive:demo-app-1.0.0.tar

crane

crane digest localhost:5001/demo-app:1.0.0     # Digest ermitteln
crane ls localhost:5001/demo-app               # Tags auflisten
crane manifest localhost:5001/demo-app:1.0.0 | jq .
crane config localhost:5001/demo-app:1.0.0 | jq .config.User
crane copy localhost:5001/demo-app:1.0.0 localhost:5002/demo-app:1.0.0
crane pull --format=oci localhost:5001/demo-app:1.0.0 ./oci-layout

Für Registries ohne TLS, die nicht localhost heißen, ergänzt du --insecure.

oras

# SBOM als Referrer an ein Image hängen
oras attach --plain-http --artifact-type application/vnd.cyclonedx+json \
  localhost:5001/demo-app@sha256:DIGEST sbom.cdx.json

# Angehängte Artefakte anzeigen
oras discover --plain-http localhost:5001/demo-app@sha256:DIGEST

# Image samt Referrern (Signaturen, SBOM) kopieren
oras copy -r --from-plain-http --to-plain-http \
  localhost:5001/demo-app@sha256:DIGEST localhost:5002/demo-app:1.0.0

# Beliebige Datei als Artefakt ablegen und wieder holen
oras push --plain-http localhost:5001/bundles/policy:1.0 policy.tar.gz
oras pull --plain-http -o ./out localhost:5001/bundles/policy:1.0

openssl: eigene PKI (siehe Kapitel 5)

Die Befehle setzen OpenSSL 3 voraus. Das vorinstallierte LibreSSL auf macOS verhält sich teils anders; nutze dort openssl aus Homebrew.

Root-CA-Schlüssel und selbstsigniertes Root-Zertifikat:

cd ~/seclab/pki/root
openssl genpkey -algorithm EC -pkeyopt ec_paramgen_curve:P-384 \
  -out root.key
openssl req -x509 -new -key root.key -sha384 -days 3650 \
  -subj "/CN=Seclab Root CA" \
  -addext "basicConstraints=critical,CA:TRUE" \
  -addext "keyUsage=critical,keyCertSign,cRLSign" \
  -out root.crt

Intermediate-CA: Schlüssel und Zertifikatsanfrage (CSR):

cd ~/seclab/pki/intermediate
openssl genpkey -algorithm EC -pkeyopt ec_paramgen_curve:P-256 -out int.key
openssl req -new -key int.key -subj "/CN=Seclab Signing CA" -out int.csr

Erweiterungen in int.ext und Signatur durch die Root:

basicConstraints = critical, CA:TRUE, pathlen:0
keyUsage = critical, keyCertSign, cRLSign
openssl x509 -req -in int.csr -CA ../root/root.crt \
  -CAkey ../root/root.key -CAcreateserial -days 1825 -sha384 \
  -extfile int.ext -out int.crt

Prüfen und anzeigen:

openssl verify -CAfile ../root/root.crt int.crt     # erwartet: int.crt: OK
openssl x509 -in int.crt -noout -subject -issuer -dates
openssl x509 -in int.crt -noout -text | grep -A1 'Basic Constraints'
openssl verify -CAfile root.crt -untrusted int.crt leaf.crt   # ganze Kette

Sicherheit: Der Root-Schlüssel gehört offline (verschlüsselter Datenträger, HSM, Tresor). Im Lab liegt er unverschlüsselt im Dateisystem; das ist nur zum Üben akzeptabel.

cosign (siehe Kapitel 5)

Schlüsselpaar erzeugen (fragt nach Passwort, alternativ COSIGN_PASSWORD setzen):

cd ~/seclab/kap05
cosign generate-key-pair      # erzeugt cosign.key und cosign.pub

Offline signieren und prüfen, ohne öffentliches Transparenzlog:

DIGEST=$(crane digest localhost:5001/demo-app:1.0.0)
cosign sign --key cosign.key --tlog-upload=false \
  localhost:5001/demo-app@$DIGEST
cosign verify --key cosign.pub --insecure-ignore-tlog=true \
  localhost:5001/demo-app@$DIGEST | jq .

SBOM als signierte Bescheinigung (Attestation) anhängen und prüfen:

cosign attest --key cosign.key --tlog-upload=false \
  --type cyclonedx --predicate sbom.cdx.json \
  localhost:5001/demo-app@$DIGEST
cosign verify-attestation --key cosign.pub --insecure-ignore-tlog=true \
  --type cyclonedx localhost:5001/demo-app@$DIGEST > /dev/null && echo OK

Signaturen und Anhänge anzeigen, Image samt Signaturen offline transportieren:

cosign tree localhost:5001/demo-app@$DIGEST
cosign save --dir ./transfer localhost:5001/demo-app@$DIGEST
cosign load --dir ./transfer localhost:5002/demo-app

Achtung: Bei cosign v3 kann zusätzlich --use-signing-config=false nötig sein. Prüfe mit cosign sign --help.

Vault und OpenBao (siehe Kapitel 6)

Alle vault-Befehle funktionieren gleich mit der OpenBao-CLI bao.

export VAULT_ADDR=http://localhost:8200 VAULT_TOKEN=root   # nur Lab!
vault status

KV-Secrets (Version 2) schreiben, lesen, versionieren:

vault kv put secret/demo/db username=app password=LAB-ONLY-123
vault kv get -field=password secret/demo/db
vault kv metadata get secret/demo/db          # Versionen ansehen
vault kv rollback -version=1 secret/demo/db   # alte Version wiederherstellen

Richtlinie (Policy) mit Leserecht:

path "secret/data/demo/*" {
  capabilities = ["read"]
}
vault policy write demo-read demo-read.hcl

Kubernetes-Anmeldung für Pods einrichten:

vault auth enable kubernetes
vault write auth/kubernetes/config \
  kubernetes_host=https://kubernetes.default.svc
vault write auth/kubernetes/role/demo \
  bound_service_account_names=demo \
  bound_service_account_namespaces=demo \
  policies=demo-read ttl=1h

Dynamische Zugangsdaten und Leases:

vault read database/creds/demo-role             # kurzlebiges DB-Konto
vault lease revoke -prefix database/creds/demo-role
vault write -f database/rotate-root/demo-db     # Root-Passwort der DB rotieren

External Secrets Operator (siehe Kapitel 6)

SecretStore mit Vault und Kubernetes-Anmeldung. Ab ESO 0.17 ist v1 verfügbar; ältere Versionen nutzen v1beta1.

apiVersion: external-secrets.io/v1
kind: SecretStore
metadata:
  name: vault
  namespace: demo
spec:
  provider:
    vault:
      server: http://vault.vault.svc:8200
      path: secret
      version: v2
      auth:
        kubernetes:
          mountPath: kubernetes
          role: demo
          serviceAccountRef:
            name: demo

ExternalSecret, das alle 15 Minuten nachlädt:

apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: db
  namespace: demo
spec:
  refreshInterval: 15m
  secretStoreRef: { name: vault, kind: SecretStore }
  target: { name: db-credentials }
  data:
    - secretKey: password
      remoteRef: { key: demo/db, property: password }

Status prüfen und Abgleich erzwingen:

kubectl get externalsecret -n demo          # STATUS SecretSynced erwartet
kubectl describe externalsecret db -n demo
kubectl annotate externalsecret db -n demo \
  force-sync=$(date +%s) --overwrite

gitleaks (siehe Kapitel 6)

# Ganze Git-Historie prüfen
gitleaks detect --source . -v

# Bericht als JSON, Secrets im Bericht schwärzen
gitleaks detect --source . --redact \
  --report-format json --report-path gitleaks.json

# Nur gestagte Änderungen (für einen pre-commit-Hook)
gitleaks protect --staged -v

# Nur neue Funde gegenüber einem Altbestand melden
gitleaks detect --source . --baseline-path gitleaks-baseline.json

Ab gitleaks 8.19 gibt es zusätzlich gitleaks git und gitleaks dir; detect und protect funktionieren weiter. Bekannte Fehlalarme trägst du per Fingerprint in .gitleaksignore ein. Eigene Regeln in .gitleaks.toml:

[extend]
useDefault = true

[allowlist]
description = "Testdaten"
paths = ['''tests/fixtures/.*''']

syft (siehe Kapitel 7)

# SBOM aus dem Quellverzeichnis (CycloneDX)
syft dir:. -o cyclonedx-json=sbom.cdx.json

# SBOM aus dem Image, direkt aus der Registry, ohne Docker-Daemon
syft registry:localhost:5001/demo-app:1.0.0 -o spdx-json=sbom.spdx.json

# Mehrere Formate in einem Lauf
syft localhost:5001/demo-app:1.0.0 \
  -o cyclonedx-json=sbom.cdx.json -o spdx-json=sbom.spdx.json

# Kurzübersicht im Terminal
syft localhost:5001/demo-app:1.0.0 -o table

# Format umwandeln
syft convert sbom.cdx.json -o spdx-json=sbom.spdx.json

grype (siehe Kapitel 7 und 8)

grype sbom:./sbom.cdx.json                         # SBOM prüfen
grype localhost:5001/demo-app:1.0.0 --fail-on high # Exit-Code 1 ab HIGH
grype dir:. --only-fixed                           # nur behebbare Funde
grype sbom:./sbom.cdx.json -o json > grype.json
grype db status                                    # Alter der Datenbank
grype db update                                    # Datenbank aktualisieren

Ausnahmen in .grype.yaml:

ignore:
  - vulnerability: CVE-2023-32681
    package:
      name: requests

Offline-Betrieb: Datenbank außen mit grype db update holen, übertragen, innen mit grype db import <datei> einspielen und GRYPE_DB_AUTO_UPDATE=false setzen.

Dependency-Track API (siehe Kapitel 7)

Alle Aufrufe brauchen einen API-Schlüssel im Header X-Api-Key (Team-Schlüssel aus Administration > Access Management > Teams).

SBOM hochladen und Projekt bei Bedarf anlegen:

export DT_KEY=odt_LAB_SCHLUESSEL
curl -s -X POST http://localhost:8080/api/v1/bom \
  -H "X-Api-Key: $DT_KEY" \
  -F autoCreate=true -F projectName=demo-app -F projectVersion=1.0.0 \
  -F [email protected]
# Antwort: {"token":"<uuid>"}

Verarbeitung abwarten:

curl -s -H "X-Api-Key: $DT_KEY" \
  http://localhost:8080/api/v1/bom/token/TOKEN-UUID     # {"processing":false}

In neueren Versionen gibt es dafür auch /api/v1/event/token/<uuid>.

Projekt suchen, Funde und Kennzahlen abrufen:

P=$(curl -s -H "X-Api-Key: $DT_KEY" \
  'http://localhost:8080/api/v1/project/lookup?name=demo-app&version=1.0.0' \
  | jq -r .uuid)
curl -s -H "X-Api-Key: $DT_KEY" \
  http://localhost:8080/api/v1/finding/project/$P \
  | jq '.[] | {c: .component.name, v: .vulnerability.vulnId,
                s: .vulnerability.severity}'
curl -s -H "X-Api-Key: $DT_KEY" \
  http://localhost:8080/api/v1/metrics/project/$P/current | jq .

Triage-Entscheidung festhalten:

curl -s -X PUT http://localhost:8080/api/v1/analysis \
  -H "X-Api-Key: $DT_KEY" -H 'Content-Type: application/json' \
  -d '{"project":"P-UUID","component":"C-UUID","vulnerability":"V-UUID",
       "analysisState":"NOT_AFFECTED",
       "analysisJustification":"CODE_NOT_REACHABLE",
       "analysisDetails":"Funktion wird nicht aufgerufen",
       "isSuppressed":true}'

trivy (siehe Kapitel 8)

# Image prüfen, Pipeline bricht ab HIGH ab
trivy image --severity HIGH,CRITICAL --exit-code 1 --ignore-unfixed \
  localhost:5001/demo-app:1.0.0

# Quellverzeichnis: Abhängigkeiten und Secrets
trivy fs --scanners vuln,secret .

# IaC-Fehlkonfigurationen (Kubernetes, Dockerfile, Terraform)
trivy config k8s/

# SBOM erzeugen und SBOM prüfen
trivy image --format cyclonedx --output sbom.cdx.json \
  localhost:5001/demo-app:1.0.0
trivy sbom sbom.cdx.json

# Ergebnis als SARIF für GitLab/IDE
trivy image --format sarif --output trivy.sarif localhost:5001/demo-app:1.0.0

Offline-Betrieb:

trivy image --download-db-only                       # außen: DB holen
trivy image --skip-db-update --offline-scan IMAGE    # innen: ohne Netz
trivy image --db-repository reg-build:5000/trivy-db IMAGE   # gespiegelte DB

Ausnahmen in .trivyignore, eine CVE-ID pro Zeile, mit Kommentar und Ablaufdatum:

# requests: nicht erreichbar, Ticket SEC-42, gilt bis 2026-12-31
CVE-2023-32681

checkov (siehe Kapitel 8)

checkov -d k8s/ --framework kubernetes --compact      # Verzeichnis prüfen
checkov -f Dockerfile --framework dockerfile           # einzelne Datei
checkov -d k8s/ --check CKV_K8S_8,CKV_K8S_9            # nur bestimmte Regeln
checkov -d k8s/ --skip-check CKV_K8S_43                # Regel ausnehmen
checkov -d k8s/ --soft-fail                            # melden, nicht brechen
checkov -d k8s/ -o sarif --output-file-path reports/   # SARIF-Bericht
checkov -d . --create-baseline                         # Altbestand festhalten
checkov -d . --baseline .checkov.baseline              # nur neue Funde
checkov -d k8s/ --config-file .checkov.yaml           # Einstellungen aus Datei

Ausnahme direkt im Kubernetes-Manifest mit Begründung:

metadata:
  name: demo
  annotations:
    checkov.io/skip1: CKV_K8S_43=Digest wird per Kyverno erzwungen

semgrep (siehe Kapitel 8)

semgrep scan --config p/python --metrics=off --error   # Regelpaket, Exit 1 bei Fund
semgrep scan --config .semgrep/ --metrics=off          # eigene Regeln, offline
semgrep scan --config .semgrep/ --sarif -o semgrep.sarif
semgrep scan --config .semgrep/ --severity ERROR --json -o semgrep.json

Eigene Regel (.semgrep/no-debug.yaml):

rules:
  - id: flask-debug-enabled
    languages: [python]
    severity: ERROR
    message: Flask läuft mit debug=True
    pattern: $APP.run(..., debug=True, ...)

Einzelnen Fund im Code begründet unterdrücken: # nosemgrep: flask-debug-enabled.

Merke: Registry-Pakete wie p/python lädt semgrep aus dem Internet. In air-gapped Umgebungen legst du die Regeln als Dateien ab.

kyverno CLI (siehe Kapitel 9)

kyverno apply policy.yaml --resource k8s/deployment.yaml   # Policy gegen Datei
kyverno apply policies/ --resource k8s/deployment.yaml --resource k8s/service.yaml
kyverno test tests/                                        # Testfälle ausführen
kubectl get policyreport -A                                # Ergebnisse im Cluster

Einfache Validierungsregel (ab Kyverno 1.13 alternativ failureAction innerhalb von validate):

apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: require-non-root
spec:
  validationFailureAction: Enforce
  rules:
    - name: run-as-non-root
      match:
        any:
          - resources: { kinds: [Pod] }
      validate:
        message: "Container müssen als Nicht-root laufen."
        pattern:
          spec:
            securityContext:
              runAsNonRoot: true

Nur signierte Images aus der eigenen Registry zulassen:

    - name: verify-signature
      match:
        any:
          - resources: { kinds: [Pod] }
      verifyImages:
        - imageReferences: ["reg-build:5000/*"]
          mutateDigest: true
          attestors:
            - entries:
                - keys:
                    publicKeys: |-
                      -----BEGIN PUBLIC KEY-----
                      ...Inhalt von cosign.pub...
                      -----END PUBLIC KEY-----
                    rekor: { ignoreTlog: true }
                    ctlog: { ignoreSCT: true }

conftest und opa (siehe Kapitel 9)

Policy in policy/deployment.rego (conftest sucht standardmäßig im Paket main):

package main

import rego.v1

deny contains msg if {
    input.kind == "Deployment"
    some c in input.spec.template.spec.containers
    not contains(c.image, "@sha256:")
    msg := sprintf("Container %s nutzt keinen Digest", [c.name])
}
conftest test k8s/deployment.yaml -p policy/           # Manifeste prüfen
conftest test Dockerfile -p policy/ --parser dockerfile
conftest test k8s/ -p policy/ -o json                  # maschinenlesbar
conftest verify -p policy/                             # Rego-Unit-Tests
opa eval -d policy/ -i input.json 'data.main.deny'     # einzelne Auswertung
opa test policy/ -v                                    # Tests ausführen
opa fmt -w policy/                                     # formatieren
opa fmt --list --fail policy/                          # CI: Exit 1, wenn unformatiert
opa check policy/                                      # Syntax prüfen

Tipp: import rego.v1 funktioniert ab OPA 0.59 und bleibt in OPA 1.x gültig. So läuft dieselbe Policy auf alten und neuen Versionen.