Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 10: Nachvollziehbar und geprüft

Ziel: Jedes notes-api-Image trägt Version, Commit und Bauzeit, baut aus demselben Commit bitgenau gleich, bringt SBOM und Provenance mit und fällt durch ein trivy-Gate, wenn es bekannte schwere Lücken enthält. Dockerfiles und Skripte prüfen trivy config und ShellCheck. · Dauer: ca. 105 min · Voraussetzung: Tag 9

Briefing

  • Labels beantworten „was ist das, aus welchem Commit, wann gebaut?” – org.opencontainers.image.version, .revision, .created.
  • Ein Tag ist ein verschiebbarer Name, der Digest die Prüfsumme des Inhalts.
  • Reproduzierbar heißt: gleicher Commit, gleicher Digest. Dafür sorgen SOURCE_DATE_EPOCH und rewrite-timestamp=true.
  • Attestations hängen am Image-Index in der Registry: SBOM (was steckt drin) und Provenance (wie wurde gebaut). trivy prüft Image oder SBOM, --exit-code macht daraus ein Gate.
  • Vor dem Build: trivy config sucht Fehlkonfigurationen im Dockerfile (DS-…), ShellCheck Fehler in Shell-Skripten (SC…).
localhost:5001/notes-api:tag10 ──► Image-Index sha256:…
                                    ├─ linux/arm64      Image-Manifest (Config, Layer)
                                    └─ unknown/unknown  Attestation-Manifest
                                         ├─ SBOM        (SPDX, aus dem Final-Stage)
                                         └─ Provenance  (SLSA, Build-Args, Materials)

Drill 1: Ein Commit als Quelle

source ~/docker-lab/setup/env.sh
mkdir -p ~/docker-lab/tag10 && cd ~/docker-lab/tag10
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag09/notes/." .

Die zweite Kopie legt den Stand vom Ende von Tag 9 darüber – auch wenn du ihn übersprungen hast. Metadaten brauchen eine Quelle, also wird der Ordner ein Git-Repo. Ins Repository kommen nur notes-api und die hadolint-Konfiguration:

git init -q && git add notes-api .hadolint.yaml
git commit -qm "notes-api Stand Tag 10" && git tag v1.0.0
git log --oneline --decorate
git status --short

Erwartet (gekürzt, Hash weicht ab):

8d41e07 (HEAD -> main, tag: v1.0.0) notes-api Stand Tag 10
?? .dockerignore
?? .env
?? .env.example
?? README.md
?? notes-web/
?? notes-worker/

?? .env ist ein Warnsignal: Ein unbedachtes git add ., und der Key liegt im Repo. Die .gitignore dagegen baust du an Tag 12. Fehlt dir eine Git-Identität: git config user.name "Du" und git config user.email [email protected] im Repo.

Fortschritt speichern? Kostenlos registrieren

Drill 2: OCI-Labels aus Git

Ersetze im Final-Stage von notes-api/Dockerfile den LABEL-Block durch diese Zeilen (direkt nach den beiden COPY):

ARG VERSION=dev
ARG REVISION=unknown
ARG CREATED=unknown
LABEL org.opencontainers.image.title="notes-api" \
      org.opencontainers.image.description="Notiz-API aus dem Trainingslager" \
      org.opencontainers.image.source="https://example.com/docker-lab/notes" \
      org.opencontainers.image.version="${VERSION}" \
      org.opencontainers.image.revision="${REVISION}" \
      org.opencontainers.image.created="${CREATED}"
diff notes-api/Dockerfile ~/docker-lab/code/tag10/notes/notes-api/Dockerfile
git commit -qam "notes-api: OCI-Labels aus Build-Args" && git tag -f v1.0.0 >/dev/null

Erwartet: keine Ausgabe von diff, dein Dockerfile entspricht dem Begleitcode.

Warum die ARGs im Final-Stage? ARG gilt nur im Stage, in dem es steht (Tag 2). Ein neuer Commit ändert dann nur die billige Label-Zeile, nicht den Go-Build. --build-arg NAME ohne Wert übernimmt den Wert aus deiner Umgebung. Die Werte holst du aus Git: Commit-Hash, Tag, Commit-Zeit als Unix-Zeit und als RFC-3339-Datum in UTC:

export REVISION=$(git rev-parse HEAD)
export VERSION=$(git describe --tags --always --dirty)
export SOURCE_DATE_EPOCH=$(git log -1 --format=%ct)
export CREATED=$(TZ=UTC git log -1 --date=format-local:%FT%TZ --format=%cd)
env | grep -E '^(VERSION|REVISION|CREATED|SOURCE_DATE_EPOCH)=' | sort
docker build -q -t notes-api:tag10 \
  --build-arg VERSION --build-arg REVISION --build-arg CREATED \
  --label org.opencontainers.image.vendor="IT-Trainingslager" notes-api
docker image inspect -f '{{json .Config.Labels}}' notes-api:tag10 | jq .
docker image inspect -f '{{.Created}}' notes-api:tag10

Erwartet (gekürzt, Hash und Zeiten weichen ab):

CREATED=2026-10-29T17:42:10Z
REVISION=3f9c2a1b7d4e…
SOURCE_DATE_EPOCH=1793295730
VERSION=v1.0.0
sha256:…
{
  "org.opencontainers.image.created": "2026-10-29T17:42:10Z",
  "org.opencontainers.image.description": "Notiz-API aus dem Trainingslager",
  "org.opencontainers.image.revision": "3f9c2a1b7d4e…",
  "org.opencontainers.image.source": "https://example.com/docker-lab/notes",
  "org.opencontainers.image.title": "notes-api",
  "org.opencontainers.image.vendor": "IT-Trainingslager",
  "org.opencontainers.image.version": "v1.0.0"
}
2026-10-29T17:42:10Z

--label ergänzt Labels von außen, ohne das Dockerfile zu ändern. Und .Created ist die Commit-Zeit, nicht die Bauzeit: buildx reicht SOURCE_DATE_EPOCH aus deiner Umgebung automatisch als Build-Arg durch.

Tipp: Mit BUILDX_GIT_LABELS=1 setzt buildx org.opencontainers.image.revision und .source selbst aus dem Git-Repo des Build-Kontexts. Explizite Build-Args sind in CI aber leichter nachzuvollziehen.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Tag gegen Digest

Den Digest eines Tags liefert die Registry im Header Docker-Content-Digest (Tag 0):

docker tag notes-api:tag10 localhost:5001/notes-api:tag10
docker push -q localhost:5001/notes-api:tag10
curl -sI localhost:5001/v2/notes-api/manifests/tag10 | grep Digest

Erwartet (gekürzt, Digests weichen ab):

localhost:5001/notes-api:tag10
Docker-Content-Digest: sha256:eaaef8ebb3f2…

Jetzt eine neue Version unter demselben Tag:

docker build -q -t localhost:5001/notes-api:tag10 --build-arg VERSION=v1.0.1 \
  --build-arg REVISION --build-arg CREATED notes-api
docker push -q localhost:5001/notes-api:tag10
curl -sI localhost:5001/v2/notes-api/manifests/tag10 | grep Digest

Erwartet (gekürzt, Digests weichen ab):

sha256:26021cdb79aa…
localhost:5001/notes-api:tag10
Docker-Content-Digest: sha256:26021cdb79aa…

Der alte Stand ist über seinen Digest weiter abrufbar. Setz statt <erster Digest> den ersten Digest von oben ein (sha256:…):

docker pull -q localhost:5001/notes-api@<erster Digest>

Erwartet:

localhost:5001/notes-api@sha256:eaaef8ebb3f2…

Derselbe Tag zeigt jetzt auf ein anderes Image, das alte bleibt über seinen Digest erreichbar. Wer per Tag deployt, bekommt, was zuletzt gepusht wurde. Wer per Digest deployt, bekommt genau das geprüfte Image – wie bei den Base-Images an Tag 8.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Reproduzierbar? Zweimal bauen

Zwei Builds aus demselben Commit, beide ohne Cache, über den Builder docker-lab direkt in die Registry. Attestations sind hier aus, denn die Provenance enthält Startzeit und Dauer des Builds und wäre nie gleich:

docker buildx build --builder docker-lab -q --no-cache --provenance=false \
  --build-arg VERSION --build-arg REVISION --build-arg CREATED \
  -o type=image,name=localhost:5001/notes-api:repro-a,push=true,rewrite-timestamp=true \
  notes-api
docker buildx build --builder docker-lab -q --no-cache --provenance=false \
  --build-arg VERSION --build-arg REVISION --build-arg CREATED \
  -o type=image,name=localhost:5001/notes-api:repro-b,push=true,rewrite-timestamp=true \
  notes-api
docker buildx imagetools inspect localhost:5001/notes-api:repro-a | grep Digest
docker buildx imagetools inspect localhost:5001/notes-api:repro-b | grep Digest

Erwartet (gekürzt, Digests weichen ab):

sha256:71d09756b269…
sha256:71d09756b269…
Digest:    sha256:deb726c0f0b2890586933a543f6b25c68d79904a4285d3a5cd79d7a4f96e5db1
Digest:    sha256:deb726c0f0b2890586933a543f6b25c68d79904a4285d3a5cd79d7a4f96e5db1

Dieselbe Gegenprobe ohne SOURCE_DATE_EPOCH und ohne rewrite-timestamp:

unset SOURCE_DATE_EPOCH
docker buildx build --builder docker-lab -q --no-cache --provenance=false \
  --build-arg VERSION --build-arg REVISION --build-arg CREATED \
  -o type=image,name=localhost:5001/notes-api:repro-c,push=true \
  notes-api
docker buildx build --builder docker-lab -q --no-cache --provenance=false \
  --build-arg VERSION --build-arg REVISION --build-arg CREATED \
  -o type=image,name=localhost:5001/notes-api:repro-d,push=true \
  notes-api
docker buildx imagetools inspect localhost:5001/notes-api:repro-c | grep Digest
docker buildx imagetools inspect localhost:5001/notes-api:repro-d | grep Digest
export SOURCE_DATE_EPOCH=$(git log -1 --format=%ct)

Erwartet (gekürzt, Digests weichen ab):

sha256:2d37c63c11cc…
sha256:6208f5a115de…
Digest:    sha256:13a8bd2bdd592bc3bd59161fee24aa4c9512b039b4d6a78ab210df4037d6d39a
Digest:    sha256:c3071745caa6599751ea49507fd85fe441b5f1c87b24e6d26b412279d161248d

Ohne SOURCE_DATE_EPOCH stehen im Image-Config created und in der History die aktuelle Uhrzeit, und die Dateien im Layer tragen die Bauzeit als mtime. Mit SOURCE_DATE_EPOCH (ab BuildKit 0.11) setzt BuildKit beide Zeitstempel auf die Commit-Zeit, rewrite-timestamp=true (ab BuildKit 0.13) zusätzlich die Dateizeiten. Den Rest erledigen -trimpath und ein Go-Build ohne CGO.

Achtung: Zieht der zweite Build ein neueres golang:1.27-alpine, weicht der Digest ab, obwohl dein Code gleich ist. Für echte Reproduzierbarkeit pinnst du das Base-Image per Digest (Tag 8).

Fortschritt speichern? Kostenlos registrieren

Drill 5: SBOM und Provenance anhängen

docker buildx build --builder docker-lab \
  --build-arg VERSION --build-arg REVISION --build-arg CREATED \
  --sbom=true --provenance=mode=max \
  -t localhost:5001/notes-api:tag10 --push notes-api
docker buildx imagetools inspect localhost:5001/notes-api:tag10

Erwartet (gekürzt, kann je nach Version abweichen):

Name:      localhost:5001/notes-api:tag10
MediaType: application/vnd.oci.image.index.v1+json
Digest:    sha256:91c0de…

Manifests:
  Name:        localhost:5001/notes-api:tag10@sha256:2be8a1…
  MediaType:   application/vnd.oci.image.manifest.v1+json
  Platform:    linux/arm64

  Name:        localhost:5001/notes-api:tag10@sha256:c47f05…
  MediaType:   application/vnd.oci.image.manifest.v1+json
  Platform:    unknown/unknown
  Annotations:
    vnd.docker.reference.digest: sha256:2be8a1…
    vnd.docker.reference.type:   attestation-manifest

Die Attestations hängen als zweites Manifest im Index, unknown/unknown, damit kein Container sie je startet. Auch ohne --provenance hängt BuildKit standardmäßig eine Provenance mit mode=min an; deshalb stand in Drill 4 --provenance=false.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Attestations lesen

imagetools inspect --format liest die Attestations aus der Registry, ohne das Image zu ziehen:

img=localhost:5001/notes-api:tag10
docker buildx imagetools inspect "$img" --format '{{ json .SBOM.SPDX }}' \
  > sbom.spdx.json
jq -r '.packages[].name' sbom.spdx.json
docker buildx imagetools inspect "$img" \
  --format '{{ json .Provenance.SLSA.materials }}' | jq -r '.[].uri'
docker buildx imagetools inspect "$img" \
  --format '{{ json .Provenance.SLSA.invocation.parameters.args }}' | jq .

Erwartet (gekürzt, kann je nach Version abweichen):

example.com/notes-api (devel)
github.com/google/uuid v1.6.0
stdlib go1.27.3
pkg:docker/docker/dockerfile@1
pkg:docker/[email protected]?platform=linux%2Farm64
{
  "build-arg:CREATED": "2026-10-29T17:42:10Z",
  "build-arg:REVISION": "3f9c2a1b7d4e…",
  "build-arg:SOURCE_DATE_EPOCH": "1793295730",
  "build-arg:VERSION": "v1.0.0",
  …
}

Die SBOM findet die Go-Module im Binary, obwohl das Image nur aus einer Datei besteht. Die Provenance nennt die Base-Images samt Digest (unter .digest) und alle Build-Args.

Sicherheit: mode=max schreibt jeden --build-arg-Wert lesbar in die Provenance. Ein API-Key als Build-Arg landet so neben dem Image in der Registry (Tag 11). Secret-Mounts erscheinen dort nie (Tag 13).

Fortschritt speichern? Kostenlos registrieren

Drill 7: trivy auf Image und SBOM

trivy image -q --image-src remote localhost:5001/notes-api:tag10 | head -9
trivy sbom -q -f json -o sbom-scan.json sbom.spdx.json
f='.Results[].Vulnerabilities[]?
   | "\(.VulnerabilityID) \(.Severity) \(.PkgName) \(.InstalledVersion)'
f+=' -> \(.FixedVersion)"'
jq -r "$f" sbom-scan.json

Erwartet (gekürzt, hängt vom Go-Patchstand und vom Stand der trivy-Datenbank ab):

Report Summary

┌───────────┬──────────┬─────────────────┐
│  Target   │   Type   │ Vulnerabilities │
├───────────┼──────────┼─────────────────┤
│ notes-api │ gobinary │        0        │
└───────────┴──────────┴─────────────────┘
…

Kein Betriebssystem, keine OS-Pakete: trivy findet nur das Go-Binary und dessen Standardbibliothek. Mit dem aktuellen Go 1.27 gibt es dort nichts zu melden, die jq-Zeile bleibt leer. Das ist eine Momentaufnahme: Wird morgen eine Lücke in der Standardbibliothek bekannt, steht hier eine Zeile wie CVE-… HIGH stdlib v1.27.3 -> 1.27.4. Image-Scan und SBOM-Scan sollten dasselbe zeigen; der SBOM-Scan braucht dafür weder Registry-Zugriff noch das Image.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Schwellwerte als Gate

--severity filtert, --exit-code 1 macht aus jedem verbleibenden Fund einen Fehlercode. Zuerst an einer SBOM mit bekannter Altlast (golang.org/x/text v0.3.5):

altlast=~/docker-lab/code/tag10/alt.cdx.json
trivy sbom -q --exit-code 1 --severity HIGH,CRITICAL -f json -o alt.json "$altlast"
echo "Exit-Code: $?"
jq -r "$f" alt.json
trivy sbom -q --exit-code 1 --severity CRITICAL "$altlast" >/dev/null
echo "Exit-Code nur CRITICAL: $?"

Erwartet (kann je nach Stand der trivy-Datenbank abweichen):

Exit-Code: 1
CVE-2021-38561 HIGH golang.org/x/text v0.3.5 -> 0.3.7
CVE-2022-32149 HIGH golang.org/x/text v0.3.5 -> 0.3.8
CVE-2026-56851 HIGH golang.org/x/text v0.3.5 -> 0.41.0
CVE-2026-56852 HIGH golang.org/x/text v0.3.5 -> 0.39.0
Exit-Code nur CRITICAL: 0

Jetzt das eigene Image: einmal wie gebaut mit Go 1.27, einmal mit dem alten Go 1.25, das keine Sicherheitskorrekturen mehr bekommt. Das ARG GO_VERSION aus Tag 2 macht den Wechsel zu einem Build-Arg:

trivy image -q --image-src remote --exit-code 1 --severity HIGH,CRITICAL \
  localhost:5001/notes-api:tag10 >/dev/null
echo "Go 1.27 – Exit-Code: $?"
docker buildx build --builder docker-lab -q --build-arg GO_VERSION=1.25 \
  --build-arg VERSION --build-arg REVISION --build-arg CREATED \
  --sbom=true --provenance=mode=max \
  -t localhost:5001/notes-api:tag10-go125 --push notes-api >/dev/null
trivy image -q --image-src remote --exit-code 1 --severity HIGH,CRITICAL \
  localhost:5001/notes-api:tag10-go125 >/dev/null
echo "Go 1.25 – Exit-Code: $?"
trivy image -q --image-src remote --severity HIGH,CRITICAL -f json \
  localhost:5001/notes-api:tag10-go125 | jq -r "$f"

Erwartet (kann je nach Stand der trivy-Datenbank abweichen):

Go 1.27 – Exit-Code: 0
Go 1.25 – Exit-Code: 1
CVE-2026-111943 HIGH stdlib v1.25.14 -> 1.26.10, 1.27.3
CVE-2026-78667 HIGH stdlib v1.25.14 -> 1.26.9, 1.27.2
CVE-2026-78669 HIGH stdlib v1.25.14 -> 1.26.9, 1.27.2
CVE-2026-97031 HIGH stdlib v1.25.14 -> 1.26.9, 1.27.2

Dein Code ist derselbe, nur die Toolchain ist älter. Die Korrekturen gibt es laut Datenbank nur in Go 1.26 und 1.27, ein neuer Patch für 1.25 kommt nicht mehr. Dass Go 1.25 überhaupt baut, liegt an go.mod: Die Zeile go 1.25 ist eine Mindestversion, die Toolchain wählt das Dockerfile. Genau so einen vergessenen Pin soll ein Gate auffangen. --ignore-unfixed lässt Funde ohne verfügbaren Fix außen vor; bewusst akzeptierte CVEs gehören mit Begründung in eine .trivyignore.

Fortschritt speichern? Kostenlos registrieren

Drill 9: trivy config – Fehlkonfiguration im Dockerfile

trivy prüft nicht nur Images. trivy config liest Dockerfiles (und Kubernetes-YAML, Terraform, Helm) gegen eingebaute Regeln, ganz ohne Build:

cd ~/docker-lab/tag10
trivy config -q notes-api/Dockerfile | sed -n '/Report Summary/,/└/p'
trivy config -q -f json . | jq -r '.Results[] | select(.Misconfigurations)
  | .Target as $t | .Misconfigurations[] | "\($t) \(.ID) \(.Severity) \(.Title)"'

Erwartet (gekürzt, kann je nach Version abweichen):

Report Summary

┌────────────┬────────────┬───────────────────┐
│   Target   │    Type    │ Misconfigurations │
├────────────┼────────────┼───────────────────┤
│ Dockerfile │ dockerfile │         0         │
└────────────┴────────────┴───────────────────┘
notes-api/Dockerfile.naiv DS-0002 HIGH Image user should not be 'root'
notes-api/Dockerfile.naiv DS-0026 LOW No HEALTHCHECK defined
notes-api/Dockerfile.naiv DS-0031 CRITICAL Secrets passed via `build-args` or envs or
copied secret files
notes-web/Dockerfile DS-0026 LOW No HEALTHCHECK defined
notes-worker/Dockerfile DS-0026 LOW No HEALTHCHECK defined

Das notes-api-Dockerfile ist sauber. Das naive fällt mit root (DS-0002), dem Key in ENV (DS-0031) und ohne HEALTHCHECK (DS-0026) durch. Viele Regeln überschneiden sich mit hadolint (DL3002) und den Build Checks (SecretsUsedInArgOrEnv), aber nicht alle: Den fehlenden HEALTHCHECK von Worker und Web meldet nur trivy, mit Stufe LOW.

Als Gate wieder mit --exit-code und --severity. Das naive Dockerfile ist ein Übungsobjekt, also nimmst du es aus:

trivy config -q --exit-code 1 --severity HIGH,CRITICAL . >/dev/null
echo "mit Dockerfile.naiv – Exit-Code: $?"
trivy config -q --exit-code 1 --severity HIGH,CRITICAL \
  --skip-files '**/Dockerfile.naiv' . >/dev/null
echo "ohne Dockerfile.naiv – Exit-Code: $?"

Erwartet:

mit Dockerfile.naiv – Exit-Code: 1
ohne Dockerfile.naiv – Exit-Code: 0

Fortschritt speichern? Kostenlos registrieren

Drill 10: ShellCheck für die Skripte

Ein Build besteht nicht nur aus Dockerfiles: Entrypoints und Hilfsskripte sind Bash. ShellCheck findet dort die typischen Fehler, bevor sie in der Pipeline zuschlagen.

ShellCheck
Aufgabe Shell-Skripte (bash, sh, dash, ksh) statisch prüfen
Besonderheit jede Meldung hat eine Nummer SC… mit Erklärung im Wiki; steckt auch in hadolint
Projekt github.com/koalaman/shellcheck (GPL-3.0)
Version im Buch 0.11.0

Ein kleines Skript mit drei typischen Fehlern:

cat > push-tag.sh <<'EOF'
#!/usr/bin/env bash
# push-tag.sh – setzt einen Tag in der lokalen Registry (absichtlich fehlerhaft)
source ~/docker-lab/setup/env.sh
img=$1
cd $LAB/tag10
for t in $(docker images --format "{{.Tag}}" $img); do
  docker tag $img:$t $REGISTRY/$img:$t
done
echo "fertig: $img"
EOF
shellcheck -f gcc push-tag.sh

Erwartet:

push-tag.sh:3:8: warning: ShellCheck can't follow non-constant source. Use a directive
to specify location. [SC1090]
push-tag.sh:5:1: warning: Use 'cd ... || exit' or 'cd ... || return' in case cd fails.
[SC2164]
push-tag.sh:5:4: note: Double quote to prevent globbing and word splitting. [SC2086]
push-tag.sh:6:46: note: Double quote to prevent globbing and word splitting. [SC2086]
push-tag.sh:7:14: note: Double quote to prevent globbing and word splitting. [SC2086]
push-tag.sh:7:19: note: Double quote to prevent globbing and word splitting. [SC2086]
push-tag.sh:7:22: note: Double quote to prevent globbing and word splitting. [SC2086]
push-tag.sh:7:32: note: Double quote to prevent globbing and word splitting. [SC2086]
push-tag.sh:7:37: note: Double quote to prevent globbing and word splitting. [SC2086]

-f gcc gibt eine Zeile je Fund aus, gut für Editoren und CI; ohne -f zeigt ShellCheck jede Stelle mit Pfeil und Vorschlag. Die drei Klassiker: SC2086, eine Variable ohne Anführungszeichen zerfällt an Leerzeichen und wird zum Glob; SC2164, schlägt cd fehl, laufen die nächsten Befehle im falschen Ordner; SC1090, ShellCheck kann eine Datei nicht mitlesen, deren Pfad erst zur Laufzeit feststeht. Die korrigierte Fassung:

cat > push-tag.sh <<'EOF'
#!/usr/bin/env bash
# push-tag.sh <image> – kopiert alle lokalen Tags eines Images in die Lab-Registry
set -euo pipefail
# shellcheck source=/dev/null
source "${LAB:-$HOME/docker-lab}/setup/env.sh"
img="${1:?Aufruf: push-tag.sh <image>}"
cd "$LAB/tag10" || exit 1
for t in $(docker images --format "{{.Tag}}" "$img"); do
  docker tag "$img:$t" "$REGISTRY/$img:$t"
done
echo "fertig: $img"
EOF
shellcheck push-tag.sh && echo "shellcheck: sauber"

Erwartet:

shellcheck: sauber

# shellcheck source=/dev/null ist eine Direktive: Sie sagt ShellCheck, die Datei nicht zu suchen. Eine Direktive gilt für den nächsten Befehl; direkt unter der Shebang-Zeile gilt sie für die ganze Datei. Mit # shellcheck disable=SC2086 schaltest du eine Regel gezielt ab, wenn ein Skript die Wortaufteilung absichtlich nutzt.

Eine Ausnahme ohne Begründung ist eine Falle für den nächsten Leser. In der Pipeline lässt -S warning die Hinweise der Stufe info und style durch und schlägt erst ab warning fehl. Und hadolint ruft ShellCheck für jedes RUN selbst auf:

printf 'FROM alpine:3.22\nRUN cd /tmp && echo $HOME > x\n' > Dockerfile.sc
hadolint --no-color Dockerfile.sc; rm Dockerfile.sc push-tag.sh

Erwartet:

Dockerfile.sc:2 DL3003 warning: Use WORKDIR to switch to a directory
Dockerfile.sc:2 SC2086 info: Double quote to prevent globbing and word splitting.

Fünf Werkzeuge, fünf Blickwinkel:

Werkzeug prüft typische Funde Tag
hadolint Dockerfile als Text, RUN mit ShellCheck DL3002 USER root, DL3026 Registry 9
BuildKit Build Checks Dockerfile beim Build SecretsUsedInArgOrEnv, JSONArgsRecommended 9
dockle fertiges Image CIS-DI-0001 root, CIS-DI-0010 Key in ENV 9
trivy Dockerfile, Ordner, Image, SBOM DS-0002, Secrets, CVEs 10, 11
ShellCheck Shell-Skripte SC2086 Quoting, SC2164 cd ohne Prüfung 10

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Das Label revision ist der aktuelle Commit:

cd ~/docker-lab/tag10
git rev-parse HEAD
docker image inspect notes-api:tag10 \
  --format '{{index .Config.Labels "org.opencontainers.image.revision"}}'

Erwartet: zweimal derselbe Hash.

e3c3a7b4b39e23f56fd3a38a4ef887f937f4927b
e3c3a7b4b39e23f56fd3a38a4ef887f937f4927b

Zwei Builds, ein Digest (Drill 4):

docker buildx imagetools inspect localhost:5001/notes-api:repro-a | grep Digest
docker buildx imagetools inspect localhost:5001/notes-api:repro-b | grep Digest

Erwartet:

Digest:    sha256:deb726c0f0b2890586933a543f6b25c68d79904a4285d3a5cd79d7a4f96e5db1
Digest:    sha256:deb726c0f0b2890586933a543f6b25c68d79904a4285d3a5cd79d7a4f96e5db1

Am Index hängen Attestations:

docker buildx imagetools inspect localhost:5001/notes-api:tag10 | grep reference.type

Erwartet:

    vnd.docker.reference.type:   attestation-manifest

Die SBOM kennt google/uuid:

jq -r '.packages[].name' sbom.spdx.json | grep uuid

Erwartet:

github.com/google/uuid

Das Gate stoppt die Altlast:

trivy sbom -q --exit-code 1 --severity HIGH,CRITICAL \
  ~/docker-lab/code/tag10/alt.cdx.json >/dev/null; echo "Exit: $?"

Erwartet:

Exit: 1

Keine schwere Fehlkonfiguration in den echten Dockerfiles:

trivy config -q --exit-code 1 --severity HIGH,CRITICAL \
  --skip-files '**/Dockerfile.naiv' . >/dev/null; echo "Exit: $?"

Erwartet:

Exit: 0

Challenge

Gib notes-api als v1.0.0 frei, aber nur, wenn die SBOM das Gate besteht: Bau einen Kandidaten localhost:5001/notes-api:v1.0.0-rc mit SBOM und Provenance, prüf die SBOM aus der Registry mit trivy (HIGH, CRITICAL) und setz den Release-Tag auf genau den geprüften Digest.

Hinweis: docker buildx imagetools create -t <neu> <repo>@<digest> setzt einen Tag in der Registry, ohne neu zu bauen.

Lösung

Der Kandidat und sein Digest:

cd ~/docker-lab/tag10
docker buildx build --builder docker-lab -q --sbom=true --provenance=mode=max \
  --build-arg VERSION --build-arg REVISION --build-arg CREATED \
  -t localhost:5001/notes-api:v1.0.0-rc --push notes-api
curl -sI localhost:5001/v2/notes-api/manifests/v1.0.0-rc | grep Digest

Erwartet (gekürzt, Digests weichen ab):

sha256:a6885c513474…
Docker-Content-Digest: sha256:a6885c513474…

Die SBOM aus der Registry holen und durchs Gate schicken:

docker buildx imagetools inspect localhost:5001/notes-api:v1.0.0-rc \
  --format '{{json .SBOM.SPDX}}' > rc.spdx.json
trivy sbom -q --exit-code 1 --severity HIGH,CRITICAL rc.spdx.json; echo "Exit: $?"

Erwartet (kann je nach Stand der trivy-Datenbank abweichen):

Report Summary
…
Legend:
- '-': Not scanned
- '0': Clean (no security findings detected)
Exit: 0

Exit 0: Das Gate besteht. Erst jetzt der Release-Tag, auf den Digest von oben:

docker buildx imagetools create -t localhost:5001/notes-api:v1.0.0 \
  localhost:5001/notes-api@<Digest des Kandidaten>
curl -sI localhost:5001/v2/notes-api/manifests/v1.0.0 | grep Digest

Erwartet (gekürzt):

Docker-Content-Digest: sha256:a6885c513474…

Derselbe Digest wie beim Kandidaten: Der Release-Tag zeigt auf genau das Image, das trivy gesehen hat. Mit --build-arg GO_VERSION=1.25 (veraltetes Go) fiele das Gate durch, Exit 1, und es gäbe keinen Release-Tag. Zum Schluss aufräumen:

rm -f rc.spdx.json
docker ps -a --filter name=^notes- --format '{{.Names}}' | xargs -r docker rm -f
docker image ls --format '{{.Repository}}:{{.Tag}}' \
  | grep -E '^(notes-|localhost:5001/)' | xargs -r docker rmi
docker buildx prune --builder docker-lab --all --force

Tipp: Das Aufräumen lässt die Registry stehen. Die Tags repro-*, tag10* und v1.0.0* bleiben also abrufbar, bis du ihr Volume löschst (Tag 0, Drill 9).

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • In CI kommen VERSION, REVISION und SOURCE_DATE_EPOCH aus den Pipeline-Variablen (z. B. CI_COMMIT_SHA bei GitLab, github.sha bei GitHub), nie aus Handeingaben.
  • Attestations sind nur so gut wie ihre Prüfung: Image und Attestations signieren (z. B. cosign oder Notation) und vor dem Deployment per Policy-Engine (Kyverno, OPA Gatekeeper) Signatur, Provenance und Digest erzwingen.
  • SBOMs zentral ablegen (z. B. Dependency-Track), damit eine neue CVE sofort zeigt, welche laufenden Images betroffen sind. Laufende Images regelmäßig neu scannen.
  • Gate-Regel schriftlich festlegen: etwa HIGH/CRITICAL mit verfügbarem Fix blockieren, Ausnahmen in .trivyignore nur mit Ticket und Ablaufdatum.
  • In abgeschotteten Netzen spiegelt man die trivy-Datenbank in die eigene Registry (--db-repository) und baut mit mode=max nur, wenn kein Build-Arg ein Geheimnis enthält.