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> --versionund<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.ymlRunner 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.20Pipeline-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/initialAdminPasswordJob ü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 -vInstallierte Plugins auflisten (für Inventar und Update-Planung):
java -jar jenkins-cli.jar -s http://localhost:8090/ \
-auth admin:API-TOKEN list-pluginsSicherheit: In Jenkins nie Secrets mit
echoausgeben.withCredentialsmaskiert 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 demoStatus, 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ückDeklarative 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 installierenGit-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=demoStatus 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=errorNexus 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 = beschreibbarInitiales Admin-Passwort aus dem Container:
docker exec nexus cat /nexus-data/admin.passwordRepositories 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.tarcrane
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-layoutFü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.0openssl: 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.crtIntermediate-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.csrErweiterungen in int.ext und Signatur durch die
Root:
basicConstraints = critical, CA:TRUE, pathlen:0
keyUsage = critical, keyCertSign, cRLSignopenssl x509 -req -in int.csr -CA ../root/root.crt \
-CAkey ../root/root.key -CAcreateserial -days 1825 -sha384 \
-extfile int.ext -out int.crtPrü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 KetteSicherheit: 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.pubOffline 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 OKSignaturen 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-appAchtung: Bei cosign v3 kann zusätzlich
--use-signing-config=falsenötig sein. Prüfe mitcosign 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 statusKV-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 wiederherstellenRichtlinie (Policy) mit Leserecht:
path "secret/data/demo/*" {
capabilities = ["read"]
}
vault policy write demo-read demo-read.hclKubernetes-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=1hDynamische 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 rotierenExternal 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: demoExternalSecret, 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) --overwritegitleaks (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.jsonAb 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.jsongrype (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 aktualisierenAusnahmen in .grype.yaml:
ignore:
- vulnerability: CVE-2023-32681
package:
name: requestsOffline-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.0Offline-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 DBAusnahmen 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 DateiAusnahme direkt im Kubernetes-Manifest mit Begründung:
metadata:
name: demo
annotations:
checkov.io/skip1: CKV_K8S_43=Digest wird per Kyverno erzwungensemgrep (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.jsonEigene 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/pythonlä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 ClusterEinfache 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: trueNur 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-Testsopa 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üfenTipp:
import rego.v1funktioniert ab OPA 0.59 und bleibt in OPA 1.x gültig. So läuft dieselbe Policy auf alten und neuen Versionen.