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 … --helpund 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,/upstreamfunktioniert. - Läuft als
65532:65532,ENTRYPOINTin Exec-Form,docker stopunter 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 3Erwartet: eine Image-ID und eine Container-ID.
Unter 20 MB:
docker image ls notes-api:anhbErwartet (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:anhbErwartet:
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; echoErwartet (gekürzt):
1.0.0
{"status":200,"url":"https://example.com"}
docker stop unter 2 s:
time docker stop notes-api
docker rm notes-apiErwartet (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
EOFJede 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-apienthält weder.envnoch ein Dockerfile. - Nach einer Änderung an
main.gokommtgo mod downloadaus 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 /ctxErwartet: 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 CACHEDErwartet (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: Laufzeitpython:3.13-slim, keinuvim Final-Image.notes-web: Laufzeitnode:24-alpine, keinesbuild, keinsrc/, keine.env.
Prüfung:
docker build -q -t notes-worker:anhb notes-worker
docker build -q -t notes-web:anhb notes-webErwartet: zwei Image-IDs.
Beide laufen nicht als root:
docker run --rm --entrypoint id notes-worker:anhb -u
docker run --rm notes-web:anhb id -uErwartet:
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 distErwartet:
.
..
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 esbuildErwartet:
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:
uvkommt perCOPY --from=ghcr.io/astral-sh/uv:0.13nur in den build-Stage, ins Final-Image wandert nur/app/.venv;--no-editableinstalliert das Paket selbst in die.venv,src/wird zur Laufzeit nicht gebraucht. - Web: Der build-Stage braucht
npm cimit devDependencies füresbuild, der Final-Stagenpm ci --omit=devund kopiert nurdist,publicundserver.js.
Die .dockerignore für den Worker:
cat > notes-worker/.dockerignore <<'EOF'
.venv
**/__pycache__
Dockerfile*
.dockerignore
*.md
.env*
EOFFortschritt speichern? Kostenlos registrieren
Übung 4: Test-Stage und Multi-Plattform
Teil B (Tag 7, 8). Erweitere notes-api/Dockerfile:
- Stage
testmitgo vetundgo test, separat aufrufbar mit--target test. - Cross-Compile ohne Emulation: ein Push liefert
linux/amd64undlinux/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 PlatformErwartet (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/DockerfileErwartet:
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"]
EOFEin 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 --checkundtrivy config(HIGH, CRITICAL) ohne Befund.- dockle meldet nichts ab Stufe WARN.
- Container läuft mit
--read-only --cap-drop ALL --security-opt no-new-privilegesund 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 1als 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-apiErwartet (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.typeErwartet:
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-123Erwartet: 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.tardocker 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.
.envkommt 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-artifactErwartet: 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 -1Erwartet (gekürzt):
ERROR: failed to build: failed to solve: secret artifact_token: not found
.env kommt nicht in den Kontext:
grep -x '.env\*' .dockerignoreErwartet:
.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
EOFrequired=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, Dienstnotes-apiaus Übung 4, Imagenotes-api:anhb-compose, Port nur auf127.0.0.1:8080. - Der Key kommt als Datei unter
/run/secrets/notes_api_keyan,notes-apiloggtsource=file. - Weder
docker compose confignochdocker inspectzeigen 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.txtErwartet:
.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-keyErwartet:
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.
- Wo gilt ein
ARGvor dem erstenFROM, wo eines im Stage, und warum taugen wederARGnochENVfür Secrets? - Warum dauert
docker stopbeiCMD notes-api(Shell-Form) oft zehn Sekunden? - Was bringt
COPY --linkim Final-Stage? - Du änderst nur den Wert eines Build-Secrets. Baut der
RUN-Schritt neu? - Was ist der Unterschied zwischen
notes-api:tag14undnotes-api@sha256:…? - Warum steht
--platform=$BUILDPLATFORMam build-Stage und nicht am Final-Stage? - Was unterscheidet die
.envnebencompose.yamlvonenv_file:? - Warum
USER 65532:65532stattUSER nonroot? - Was verrät
--provenance=mode=max, wasmode=minnicht verrät? - Ein Kollege hat
.envmit einem echten Key committet. Welche drei Schritte?
Lösungen
- Vor
FROMnur inFROM-Zeilen; im Stage ab der Deklaration bis zum Stage-Ende. Beide landen sichtbar in History, Config oder Provenance (Tag 2, Tag 11). - PID 1 ist
/bin/sh, das SIGTERM nicht an die Anwendung weitergibt; nach dem Timeout von 10 s folgt SIGKILL (Tag 2). - 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).
- Nein. Secrets gehen nicht in den Cache-Schlüssel ein; wer neu bauen
muss, nimmt
--no-cacheoder ändert eine echte Eingabe (Tag 13). - Der Tag ist ein veränderlicher Name, der Digest die unveränderliche Prüfsumme des Manifests (Tag 1, Tag 8).
- Der Compiler soll nativ und schnell laufen und nur das Binary für
TARGETARCHerzeugen; das Final-Image muss dagegen die Zielplattform haben (Tag 7). - Die
.envdient der Interpolation von${VAR}incompose.yaml,env_file:setzt Variablen im Container (Tag 12). - Mit numerischer UID kann die Laufzeit (z. B. Kubernetes
runAsNonRoot) prüfen, dass nicht root läuft, ohne/etc/passwdim Image zu brauchen (Tag 9). - Unter anderem die Werte der Build-Args;
mode=minlässt sie weg (Tag 10). - Key rotieren,
git rm --cached .envplus.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 --forceErwartet (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.