Zum Inhalt springen
Trainingslager IT-Trainingslager

Anhang B: Abschlussprüfung

Ziel: Alle vier Teile des Buchs ohne Anleitung anwenden: acht praktische Übungen und ein kurzer Wissensteil. · Dauer: ca. 150 min · Voraussetzung: Tag 15

Spielregeln

  • Jede Übung nennt Anforderungen und eine Prüfung aus einzelnen Befehlen. Bestanden ist sie, wenn jeder Befehl das Erwartete zeigt. Die Lösung liest du erst danach.
  • Die Übungen bauen aufeinander auf und laufen alle in ~/docker-lab/anhb.
  • Erlaubt sind Anhang A, docker … --help und die offizielle Doku, nicht die Tage 1–15.
  • Bestanden hast du mit acht bestandenen Prüfungen und mindestens 8 von 10 Punkten im Wissensteil.
source ~/docker-lab/setup/env.sh
mkdir -p ~/docker-lab/anhb && cd ~/docker-lab/anhb
cp -R "$LAB/code/notes/." .

Größen, Digests und Zeiten in den Ausgaben weichen bei dir ab.

Übung 1: notes-api klein und korrekt

Teil A und B (Tag 1–5). Schreib notes-api/Dockerfile und notes-api/.dockerignore:

  • Multi-Stage, Final-Image scratch, unter 20 MB, /upstream funktioniert.
  • Läuft als 65532:65532, ENTRYPOINT in Exec-Form, docker stop unter 2 s.
  • Healthcheck ohne Shell und ohne curl, „healthy” nach höchstens 3 s.
  • Version per --build-arg VERSION=…, sichtbar unter /version.

Prüfung: Erst bauen und starten:

docker build -q --build-arg VERSION=1.0.0 -t notes-api:anhb notes-api
docker run -d --name notes-api -e NOTES_API_KEY=lab-api-key-123 \
  -p 127.0.0.1:8080:8080 notes-api:anhb
sleep 3

Erwartet: eine Image-ID und eine Container-ID.

Unter 20 MB:

docker image ls notes-api:anhb

Erwartet (gekürzt, Größe weicht ab):

IMAGE            ID             DISK USAGE   CONTENT SIZE   EXTRA
notes-api:anhb   e531785b5e1d       10.7MB         3.23MB   U

Läuft als 65532:65532:

docker image inspect --format '{{.Config.User}}' notes-api:anhb

Erwartet:

65532:65532

Healthy:

docker ps --filter name=notes-api --format '{{.Status}}'

Erwartet (Zeit weicht ab):

Up 3 seconds (healthy)

Version und /upstream:

curl -s localhost:8080/version; echo
curl -s localhost:8080/upstream; echo

Erwartet (gekürzt):

1.0.0
{"status":200,"url":"https://example.com"}

docker stop unter 2 s:

time docker stop notes-api
docker rm notes-api

Erwartet (Zeiten weichen ab):

notes-api

real    0m0.436s
…
notes-api

Lösung

cat > notes-api/Dockerfile <<'EOF'
# syntax=docker/dockerfile:1
ARG GO_VERSION=1.27
FROM golang:${GO_VERSION}-alpine AS build
WORKDIR /src
COPY go.mod go.sum ./
RUN --mount=type=cache,target=/go/pkg/mod go mod download
COPY . .
ARG VERSION=dev
RUN --mount=type=cache,target=/go/pkg/mod \
    --mount=type=cache,target=/root/.cache/go-build \
    CGO_ENABLED=0 go build -trimpath -ldflags="-s -w -X main.version=${VERSION}" \
    -o /out/notes-api .

FROM scratch
COPY --from=build /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
COPY --from=build /out/notes-api /notes-api
USER 65532:65532
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=2s --start-period=5s --start-interval=1s \
    CMD ["/notes-api", "healthcheck"]
ENTRYPOINT ["/notes-api"]
EOF
cat > notes-api/.dockerignore <<'EOF'
Dockerfile*
.dockerignore
*.md
.git
.env*
**/*.test
EOF

Jede Anforderung hat eine Zeile: CA-Bündel für /upstream (Tag 5), Exec-Form für Signale (Tag 2), notes-api healthcheck statt curl, -X main.version für die Version.

Fortschritt speichern? Kostenlos registrieren

Übung 2: Kontext und Cache

Teil A (Tag 3, 4). Weise drei Dinge nach, ohne das Dockerfile aus Übung 1 zu ändern:

  • Der Kontext von notes-api enthält weder .env noch ein Dockerfile.
  • Nach einer Änderung an main.go kommt go mod download aus dem Cache.
  • Ein Cache-Export in die lokale Registry überlebt einen geleerten Builder-Cache.

Prüfung:

cat > spy.Dockerfile <<'EOF2'
# syntax=docker/dockerfile:1
FROM golang:1.27-alpine
COPY . /ctx
RUN find /ctx
EOF2
docker build --no-cache --progress=plain -f spy.Dockerfile notes-api 2>&1 | grep /ctx

Erwartet: main.go ist im Kontext, kein Dockerfile und keine .env.

#8 [2/3] COPY . /ctx
#9 [3/3] RUN find /ctx
#9 0.529 /ctx
#9 0.529 /ctx/go.sum
#9 0.529 /ctx/main.go
#9 0.529 /ctx/go.mod

Nach einer Änderung an main.go kommt go mod download aus dem Cache:

echo '// Prüfung' >> notes-api/main.go
docker build --progress=plain -t notes-api:anhb notes-api 2>&1 \
  | grep -A1 'go mod download'

Erwartet (gekürzt):

#10 [base 4/5] RUN --mount=type=cache,target=/go/pkg/mod go mod download
#10 CACHED

Den dritten Punkt prüfst du in der Lösung selbst mit grep -c CACHED.

Lösung

Die ersten beiden Punkte erfüllt Übung 1 bereits: die .dockerignore und die Reihenfolge go.mod/go.sum vor COPY . .. Für den dritten exportierst du den Cache mit dem Builder docker-lab, leerst ihn und baust erneut nur aus der Registry:

cache=type=registry,ref=localhost:5001/notes-api:anhb-cache
docker buildx build -q --builder docker-lab --cache-to "$cache,mode=max" \
  -t localhost:5001/notes-api:anhb --push notes-api
docker buildx prune --builder docker-lab --all --force >/dev/null
docker buildx build --builder docker-lab --cache-from "$cache" --progress=plain \
  -t localhost:5001/notes-api:anhb --push notes-api 2>&1 | grep -c CACHED

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

sha256:c4d2…
6

mode=max exportiert auch die Layer des build-Stages, sonst wären nur die des Final-Images im Cache (Tag 4).

Fortschritt speichern? Kostenlos registrieren

Übung 3: Worker und Web

Teil B (Tag 6). Schreib Dockerfiles und .dockerignore für notes-worker und notes-web:

  • Beide Final-Images laufen nicht als root.
  • notes-worker: Laufzeit python:3.13-slim, kein uv im Final-Image.
  • notes-web: Laufzeit node:24-alpine, kein esbuild, kein src/, keine .env.

Prüfung:

docker build -q -t notes-worker:anhb notes-worker
docker build -q -t notes-web:anhb notes-web

Erwartet: zwei Image-IDs.

Beide laufen nicht als root:

docker run --rm --entrypoint id notes-worker:anhb -u
docker run --rm notes-web:anhb id -u

Erwartet:

65532
1000

Kein uv im Worker:

docker run --rm --entrypoint sh notes-worker:anhb -c 'command -v uv; echo "Exit: $?"'

Erwartet:

Exit: 127

Im Web-Image kein src/, keine .env, aber dist/app.js:

docker run --rm notes-web:anhb ls -a
docker run --rm notes-web:anhb ls dist

Erwartet:

.
..
dist
node_modules
package-lock.json
package.json
public
server.js
app.js

Kein esbuild:

docker run --rm notes-web:anhb ls node_modules | grep -c esbuild

Erwartet:

0

Lösung

Die Dockerfiles entsprechen den Lösungen von Tag 15, Runde 4 (notes-web) und Runde 5 (notes-worker). Wichtig sind die Grenzen zwischen den Stages:

  • Worker: uv kommt per COPY --from=ghcr.io/astral-sh/uv:0.13 nur in den build-Stage, ins Final-Image wandert nur /app/.venv; --no-editable installiert das Paket selbst in die .venv, src/ wird zur Laufzeit nicht gebraucht.
  • Web: Der build-Stage braucht npm ci mit devDependencies für esbuild, der Final-Stage npm ci --omit=dev und kopiert nur dist, public und server.js.

Die .dockerignore für den Worker:

cat > notes-worker/.dockerignore <<'EOF'
.venv
**/__pycache__
Dockerfile*
.dockerignore
*.md
.env*
EOF

Fortschritt speichern? Kostenlos registrieren

Übung 4: Test-Stage und Multi-Plattform

Teil B (Tag 7, 8). Erweitere notes-api/Dockerfile:

  • Stage test mit go vet und go test, separat aufrufbar mit --target test.
  • Cross-Compile ohne Emulation: ein Push liefert linux/amd64 und linux/arm64.
  • Kommentar mit dem Hinweis auf Digest-Pinning am Base-Image, aber kein erfundener Digest.

Prüfung:

docker build -q --target test notes-api >/dev/null; echo "Exit: $?"

Erwartet: Die Test-Stage läuft.

Exit: 0
docker buildx build -q --builder docker-lab --platform linux/amd64,linux/arm64 \
  -t localhost:5001/notes-api:anhb-multi --push notes-api
docker buildx imagetools inspect localhost:5001/notes-api:anhb-multi | grep Platform

Erwartet (nach dem Digest des Pushs):

sha256:78c54d198fe6…
  Platform:    linux/amd64
  Platform:    linux/arm64
  Platform:    unknown/unknown
  Platform:    unknown/unknown

Die build-Stage läuft auf der Build-Plattform:

grep '^FROM --platform' notes-api/Dockerfile

Erwartet:

FROM --platform=$BUILDPLATFORM golang:${GO_VERSION}-alpine AS base

Lösung

Das Muster-Dockerfile aus Anhang A erfüllt alle Punkte und bereitet schon Übung 5 vor:

cat > notes-api/Dockerfile <<'EOF'
# syntax=docker/dockerfile:1
# check=error=true
ARG GO_VERSION=1.27
# in Produktion: @sha256:… pinnen, siehe Tag 8
FROM --platform=$BUILDPLATFORM golang:${GO_VERSION}-alpine AS base
WORKDIR /src
COPY go.mod go.sum ./
RUN --mount=type=cache,target=/go/pkg/mod go mod download
COPY . .

FROM base AS test
RUN --mount=type=cache,target=/go/pkg/mod \
    --mount=type=cache,target=/root/.cache/go-build \
    go vet ./... && go test ./...

FROM base AS build
ARG TARGETOS TARGETARCH VERSION=dev
RUN --mount=type=cache,target=/go/pkg/mod \
    --mount=type=cache,target=/root/.cache/go-build \
    CGO_ENABLED=0 GOOS=$TARGETOS GOARCH=$TARGETARCH \
    go build -trimpath -ldflags="-s -w -X main.version=${VERSION}" -o /out/notes-api .

FROM scratch AS final
ARG VERSION=dev REVISION=unknown CREATED=unknown
LABEL org.opencontainers.image.title="notes-api" \
      org.opencontainers.image.version="${VERSION}" \
      org.opencontainers.image.revision="${REVISION}" \
      org.opencontainers.image.created="${CREATED}"
COPY --link --from=build /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
COPY --link --from=build /out/notes-api /notes-api
USER 65532:65532
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=2s --start-period=5s --start-interval=1s \
    CMD ["/notes-api", "healthcheck"]
STOPSIGNAL SIGTERM
ENTRYPOINT ["/notes-api"]
EOF

Ein normaler Build ohne --target überspringt test, weil final nicht davon abhängt (Tag 7). Weil base schon auf $BUILDPLATFORM läuft, erbt build die native Plattform; nur GOOS/GOARCH wählen das Ziel.

Fortschritt speichern? Kostenlos registrieren

Übung 5: Härten und nachweisen

Teil C (Tag 9, 10). Mit dem Dockerfile aus Übung 4:

  • hadolint, docker build --check und trivy config (HIGH, CRITICAL) ohne Befund.
  • dockle meldet nichts ab Stufe WARN.
  • Container läuft mit --read-only --cap-drop ALL --security-opt no-new-privileges und wird „healthy”.
  • Image in der Registry mit OCI-Labels für Version, Revision und Zeitpunkt sowie SBOM- und Provenance-Attestation.
  • Ein trivy-Scan mit --severity HIGH,CRITICAL --exit-code 1 als Schwelle, deren Ergebnis du begründen kannst.

Prüfung: Die drei Prüfer für das Dockerfile:

hadolint notes-api/Dockerfile; echo "Exit: $?"
docker build --check notes-api 2>&1 | tail -1
trivy config -q --exit-code 1 --severity HIGH,CRITICAL notes-api/Dockerfile
echo "Exit: $?"

Erwartet:

Exit: 0
Check complete, no warnings found.
Exit: 0

dockle ab Stufe WARN:

docker build -q -t notes-api:anhb notes-api
dockle --exit-code 1 --exit-level warn notes-api:anhb >/dev/null; echo "Exit: $?"

Erwartet:

sha256:73b5f9e07c8f…
Exit: 0

Gehärtet und healthy:

docker run -d --name notes-api --read-only --cap-drop ALL \
  --security-opt no-new-privileges -e NOTES_API_KEY=lab-api-key-123 notes-api:anhb
sleep 3
docker ps --filter name=notes-api --format '{{.Status}}'
docker rm -f notes-api

Erwartet (IDs und Zeiten weichen ab):

5f0c…
Up 3 seconds (healthy)
notes-api

Label version in der Registry:

docker buildx imagetools inspect localhost:5001/notes-api:anhb-1.0.0 \
  --format '{{json .Image}}' | jq '.config.Labels'

Erwartet (gekürzt):

{
  "org.opencontainers.image.created": "2026-11-02T18:04:13Z",
  "org.opencontainers.image.revision": "anhb-0001",
  "org.opencontainers.image.title": "notes-api",
  "org.opencontainers.image.version": "1.0.0"
}

SBOM und Provenance hängen als Attestation am Index:

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

Erwartet:

    vnd.docker.reference.type:   attestation-manifest

Lösung

Die ersten drei Punkte erfüllt das Dockerfile aus Übung 4. Für die Registry baust du mit dem Builder docker-lab und übergibst die Label-Werte als Build-Args:

docker buildx build -q --builder docker-lab \
  --build-arg VERSION=1.0.0 --build-arg REVISION=anhb-0001 \
  --build-arg CREATED="$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
  --sbom=true --provenance=mode=max \
  -t localhost:5001/notes-api:anhb-1.0.0 --push notes-api
docker buildx imagetools inspect localhost:5001/notes-api:anhb-1.0.0 \
  --format '{{json .SBOM}}' | jq -r '.SPDX.packages[].name' | sort | head -5
trivy image --severity HIGH,CRITICAL --exit-code 1 notes-api:anhb; echo "Exit $?"

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

sha256:7f20…
example.com/notes-api
github.com/google/uuid
stdlib
…
notes-api (gobinary)
Total: 0 (HIGH: 0, CRITICAL: 0)
Exit 0

Meldet trivy Funde in stdlib, liegt es an der Go-Version im build-Stage: neues golang:1.27-alpine ziehen (--pull) und neu bauen, nicht die Schwelle senken. mode=max enthält die Werte aller Build-Args – noch ein Grund, nie ein Secret per --build-arg zu übergeben.

Fortschritt speichern? Kostenlos registrieren

Übung 6: Leak-Forensik

Teil D (Tag 11). Erst Spielleitung: Bau das Image, ohne dir leak.Dockerfile danach noch einmal anzusehen.

cat > leak.Dockerfile <<'EOF'
# syntax=docker/dockerfile:1
FROM golang:1.27-alpine
ARG ARTIFACT_TOKEN
RUN echo "$ARTIFACT_TOKEN" > /tmp/token && wc -c /tmp/token && rm /tmp/token
COPY .env /app/.env
RUN rm /app/.env
EOF
docker build -q -f leak.Dockerfile --build-arg ARTIFACT_TOKEN=lab-artifact-token-123 \
  -t notes-leak:anhb .

Aufgabe: Finde beide Secrets im Image notes-leak:anhb, jedes mit einem anderen Werkzeug. docker run … ls zählt nicht, denn die Dateien sind gelöscht.

Prüfung: Du hast zwei Befehle, deren Ausgabe lab-artifact-token-123 bzw. lab-api-key-123 enthält. Kontrolle für den ersten:

docker history --no-trunc notes-leak:anhb | grep -c lab-artifact-token-123

Erwartet: mindestens ein Treffer.

3

Lösung

Das Token steht in der History, weil ein ARG in einem RUN als Umgebung des Schritts protokolliert wird. Die .env steckt im Layer von COPY, das spätere rm legt nur eine Löschmarkierung darüber:

docker history --no-trunc --format '{{.CreatedBy}}' notes-leak:anhb \
  | grep -o 'ARTI.*123'
docker save notes-leak:anhb -o leak.tar
mkdir -p leak && tar -xf leak.tar -C leak
for b in leak/blobs/sha256/*; do
  tar -xOf "$b" 2>/dev/null | grep -a lab-api-key && echo "→ Layer ${b##*/}"
done
rm -rf leak leak.tar

docker save schreibt das ganze Image samt golang-Basis, rechne mit einigen hundert MB, die du gleich wieder löschst.

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

ARTIFACT_TOKEN=lab-artifact-token-123
NOTES_API_KEY=lab-api-key-123
→ Layer 1c7e…

tar liest gepackte und ungepackte Layer gleichermaßen; Blobs, die keine Layer sind, verwirft 2>/dev/null. Beide Werte gelten als verbrannt (Tag 15, Runde 3).

Fortschritt speichern? Kostenlos registrieren

Übung 7: Build-Secret richtig

Teil D (Tag 13). Schreib secret.Dockerfile, das dieselbe Arbeit wie leak.Dockerfile erledigt (Token-Länge zählen), aber:

  • Das Token kommt per Secret-Mount als Umgebungsvariable und fehlt nie unbemerkt.
  • .env kommt gar nicht erst in den Kontext.
  • Weder Token noch Key stehen in History oder Layern des Images notes-leak:anhb-fix.

Prüfung:

export ARTIFACT_TOKEN=lab-artifact-token-123
docker build -q -f secret.Dockerfile --secret id=artifact_token,env=ARTIFACT_TOKEN \
  -t notes-leak:anhb-fix .
docker history --no-trunc notes-leak:anhb-fix | grep -c lab-artifact

Erwartet: kein Token in der History.

sha256:596c6fd63a21…
0

Ohne Secret bricht der Build ab:

docker build -q --no-cache -f secret.Dockerfile -t notes-leak:anhb-nosecret . \
  2>&1 | tail -1

Erwartet (gekürzt):

ERROR: failed to build: failed to solve: secret artifact_token: not found

.env kommt nicht in den Kontext:

grep -x '.env\*' .dockerignore

Erwartet:

.env*

Lösung

cat > secret.Dockerfile <<'EOF'
# syntax=docker/dockerfile:1
FROM golang:1.27-alpine
RUN --mount=type=secret,id=artifact_token,env=ARTIFACT_TOKEN,required=true \
    echo "Token-Länge: ${#ARTIFACT_TOKEN}"
EOF
cat > .dockerignore <<'EOF'
.git
.env*
!.env.example
secrets/
**/node_modules
**/.venv
*.Dockerfile
EOF

required=true lässt den Build ohne --secret scheitern, statt still mit leerem Wert weiterzulaufen. Die Projekt-.dockerignore gilt für Builds mit . als Kontext; der Dienstordner notes-api hat seine eigene. Ein neuer Token-Wert baut den Schritt übrigens nicht neu: Secrets gehen nicht in den Cache-Schlüssel ein (Tag 13).

Fortschritt speichern? Kostenlos registrieren

Übung 8: Laufzeit-Secret mit Compose

Teil D (Tag 12, 14). Lege .gitignore, secrets/notes_api_key.txt und compose.yaml an:

  • Projektname notes-anhb, Dienst notes-api aus Übung 4, Image notes-api:anhb-compose, Port nur auf 127.0.0.1:8080.
  • Der Key kommt als Datei unter /run/secrets/notes_api_key an, notes-api loggt source=file.
  • Weder docker compose config noch docker inspect zeigen den Key-Wert.
  • Rotation auf lab-api-key-456 (Lab-Wert) ohne Rebuild; der alte Key wird danach abgewiesen.

Prüfung (nach der Rotation):

git init -q
git check-ignore -v .env secrets/notes_api_key.txt

Erwartet:

.gitignore:1:.env   .env
.gitignore:2:secrets/   secrets/notes_api_key.txt

notes-api liest den Key aus der Datei:

docker compose logs notes-api | grep -o 'source=[a-z]*'

Erwartet:

source=file

Weder config noch inspect zeigen einen Key-Wert:

docker compose config | grep -c lab-api-key
docker inspect notes-anhb-notes-api-1 | grep -c lab-api-key

Erwartet:

0
0

Der alte Key wird abgewiesen, der neue akzeptiert:

curl -s -X POST localhost:8080/notes -H 'X-API-Key: lab-api-key-123' -d '{"text":"x"}'
curl -s -X POST localhost:8080/notes -H 'X-API-Key: lab-api-key-456' -d '{"text":"x"}'

Erwartet (gekürzt, ID weicht ab):

{"error":"invalid api key"}
{"id":"d35dac68-…","text":"x"}

Lösung

cat > .gitignore <<'EOF'
.env
secrets/
EOF
mkdir -p secrets
printf '%s\n' lab-api-key-123 > secrets/notes_api_key.txt
chmod 0644 secrets/notes_api_key.txt
cat > compose.yaml <<'EOF'
name: notes-anhb
services:
  notes-api:
    build:
      context: notes-api
    image: notes-api:anhb-compose
    environment:
      NOTES_API_KEY_FILE: /run/secrets/notes_api_key
    secrets:
      - notes_api_key
    ports:
      - "127.0.0.1:8080:8080"
secrets:
  notes_api_key:
    file: ./secrets/notes_api_key.txt
EOF
docker compose up -d --build
printf '%s\n' lab-api-key-456 > secrets/notes_api_key.txt
docker compose up -d --force-recreate notes-api
docker compose logs notes-api | grep 'api key loaded'

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

notes-api-1  | time=… level=INFO msg="api key loaded" source=file

Der Container-User 65532 muss die Datei lesen können, daher 0644 im Lab (Tag 14). docker compose config zeigt nur den Pfad zur Datei, docker inspect nur NOTES_API_KEY_FILE. Die Rotation braucht keinen neuen Build, nur einen neuen Container, weil notes-api den Key beim Start liest.

Fortschritt speichern? Kostenlos registrieren

Wissensteil

Je Frage ein Punkt, Antwort in ein bis zwei Sätzen.

  1. Wo gilt ein ARG vor dem ersten FROM, wo eines im Stage, und warum taugen weder ARG noch ENV für Secrets?
  2. Warum dauert docker stop bei CMD notes-api (Shell-Form) oft zehn Sekunden?
  3. Was bringt COPY --link im Final-Stage?
  4. Du änderst nur den Wert eines Build-Secrets. Baut der RUN-Schritt neu?
  5. Was ist der Unterschied zwischen notes-api:tag14 und notes-api@sha256:…?
  6. Warum steht --platform=$BUILDPLATFORM am build-Stage und nicht am Final-Stage?
  7. Was unterscheidet die .env neben compose.yaml von env_file:?
  8. Warum USER 65532:65532 statt USER nonroot?
  9. Was verrät --provenance=mode=max, was mode=min nicht verrät?
  10. Ein Kollege hat .env mit einem echten Key committet. Welche drei Schritte?

Lösungen

  1. Vor FROM nur in FROM-Zeilen; im Stage ab der Deklaration bis zum Stage-Ende. Beide landen sichtbar in History, Config oder Provenance (Tag 2, Tag 11).
  2. PID 1 ist /bin/sh, das SIGTERM nicht an die Anwendung weitergibt; nach dem Timeout von 10 s folgt SIGKILL (Tag 2).
  3. Der Layer hängt nicht vom Inhalt der Layer davor ab und kann bei einem neuen Base-Image wiederverwendet werden, statt neu kopiert zu werden (Tag 7).
  4. Nein. Secrets gehen nicht in den Cache-Schlüssel ein; wer neu bauen muss, nimmt --no-cache oder ändert eine echte Eingabe (Tag 13).
  5. Der Tag ist ein veränderlicher Name, der Digest die unveränderliche Prüfsumme des Manifests (Tag 1, Tag 8).
  6. Der Compiler soll nativ und schnell laufen und nur das Binary für TARGETARCH erzeugen; das Final-Image muss dagegen die Zielplattform haben (Tag 7).
  7. Die .env dient der Interpolation von ${VAR} in compose.yaml, env_file: setzt Variablen im Container (Tag 12).
  8. Mit numerischer UID kann die Laufzeit (z. B. Kubernetes runAsNonRoot) prüfen, dass nicht root läuft, ohne /etc/passwd im Image zu brauchen (Tag 9).
  9. Unter anderem die Werte der Build-Args; mode=min lässt sie weg (Tag 10).
  10. Key rotieren, git rm --cached .env plus .gitignore, Historie bereinigen (z. B. git filter-repo) – die Rotation zuerst, denn die Historie bleibt in jedem Klon (Tag 12).

Zum Schluss aufräumen:

docker compose down
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

Erwartet (gekürzt, Namen, IDs und Größen weichen ab):

Untagged: notes-api:anhb
Deleted: sha256:…
…
Total:  …

Bestanden? Dann schreibst du Dockerfiles, die klein, schnell, nachvollziehbar und sicher sind – und du findest die Fehler in denen der anderen.