Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 15: Wettkampf – Desaster-Drills

Ziel: Zehn kaputte Dockerfiles unter Zeitdruck erst diagnostizieren und dann reparieren, nur mit den Werkzeugen aus Tag 1–14. · Dauer: ca. 150 min · Voraussetzung: Tag 14

Briefing

  • Jede Runde: Lage, Zeitlimit, kaputter Stand, Hinweis, Lösung. Stell dir eine Uhr. Den Hinweis liest du frühestens nach der halben Zeit.
  • Erst beweisen, dann ändern: Zu jeder Runde gehört ein Befehl, der den Fehler zeigt, und derselbe Befehl zeigt nach dem Fix, dass er weg ist.
  • Jede Runde legt die unveränderte Demo-Anwendung an und den kaputten Stand aus code/tag15/rundeNN darüber. Dein Stand von Tag 14 bleibt unberührt.
  • Reparierte Images heißen notes-…:rNN-fix. Der Kontrollpunkt prüft genau diese.
  • Wertung: 2 Punkte in der Zeit ohne Hinweis, 1 Punkt mit Hinweis oder knapp drüber, 0 Punkte mit Lösung.

Runde 1: Von 1 GB auf unter 20 MB

source ~/docker-lab/setup/env.sh
rm -rf ~/docker-lab/tag15/runde01 && mkdir -p ~/docker-lab/tag15/runde01
cd ~/docker-lab/tag15/runde01
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag15/runde01/." .
ls notes-api

Erwartet:

Dockerfile      Dockerfile.naiv go.mod          go.sum          main.go

Jede Runde beginnt so: Ordner leeren, unveränderte Demo-Anwendung hinein, kaputten Stand darüber. Wiederholst du die drei Zeilen, fängst du die Runde von vorn an.

Lage: Die Registry schlägt Alarm: Jedes neue notes-api-Image belegt über ein Gigabyte. Ziel sind unter 20 MB bei gleicher Funktion. Zeitlimit: 10 min.

cat notes-api/Dockerfile
docker build -q -t notes-api:r01 notes-api
docker image ls notes-api:r01 --format '{{.Tag}}  {{.Size}}'

Erwartet (für die letzten beiden Befehle, kann je nach Version abweichen):

sha256:3f9a…
r01  1.12GB

Achtung: Image-Größen, Digests und Zeiten in diesem Kapitel weichen bei dir ab. Es zählt das Verhältnis vorher gegen nachher.

Hinweis: Wer braucht zur Laufzeit noch den Go-Compiler und den Modul-Cache?

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
ENTRYPOINT ["/notes-api"]
EOF
docker build -q -t notes-api:r01-fix notes-api
docker image ls notes-api --format '{{.Tag}}  {{.Size}}'
docker run -d --name notes-api -e NOTES_API_KEY=lab-api-key-123 \
  -p 127.0.0.1:8080:8080 notes-api:r01-fix
sleep 1; curl -s localhost:8080/healthz; docker rm -f notes-api

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

r01-fix  7.4MB
r01      1.12GB
4b1e…
ok
notes-api

Warum? Der Final-Stage enthält nur noch Binary und CA-Zertifikate; Compiler, Quellcode und Caches bleiben im build-Stage (Tag 5). CGO_ENABLED=0 macht das Binary statisch, nur so läuft es in scratch.

Fortschritt speichern? Kostenlos registrieren

Runde 2: Cache bricht bei jeder Codeänderung

Lage: Jeder Einzeiler-Fix lädt in der CI alle Go-Module neu, und sogar ein neuer Kommentar im Dockerfile baut alles von vorn. Ziel: Nach einer Änderung an main.go oder am Dockerfile kommt go mod download aus dem Cache. Zeitlimit: 10 min.

rm -rf ~/docker-lab/tag15/runde02 && mkdir -p ~/docker-lab/tag15/runde02
cd ~/docker-lab/tag15/runde02
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag15/runde02/." .
docker build -q -t notes-api:r02 notes-api
echo '// Runde 2' >> notes-api/main.go
docker build --progress=plain -t notes-api:r02 notes-api 2>&1 \
  | grep -E '^#[0-9]+ (\[build|CACHED)'

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

#6 [build 1/5] FROM docker.io/library/golang:1.27-alpine@sha256:…
#7 [build 2/5] WORKDIR /src
#7 CACHED
#8 [build 3/5] COPY . .
#9 [build 4/5] RUN go mod download
#10 [build 5/5] RUN CGO_ENABLED=0 go build -trimpath …

Hinweis: Was ändert sich seltener, go.mod oder main.go – und muss das Dockerfile selbst überhaupt im Kontext liegen?

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
ENTRYPOINT ["/notes-api"]
EOF
cat > notes-api/.dockerignore <<'EOF'
Dockerfile*
.dockerignore
*.md
.git
.env*
**/*.test
EOF
docker build -q -t notes-api:r02-fix notes-api
echo '// noch eine Zeile' >> notes-api/main.go
echo '# nur ein Kommentar' >> notes-api/Dockerfile
docker build --progress=plain -t notes-api:r02-fix notes-api 2>&1 \
  | grep -E '^#[0-9]+ (\[build|CACHED)'

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

#6 [build 1/6] FROM docker.io/library/golang:1.27-alpine@sha256:…
#7 [build 2/6] WORKDIR /src
#7 CACHED
#8 [build 3/6] COPY go.mod go.sum ./
#8 CACHED
#9 [build 4/6] RUN --mount=type=cache,target=/go/pkg/mod go mod download
#9 CACHED
#10 [build 5/6] COPY . .
#11 [build 6/6] RUN --mount=type=cache,target=/go/pkg/mod --mount=type=cache,…

Warum? Ab dem ersten geänderten Schritt baut BuildKit alles neu (Tag 4). Deshalb kommen die selten geänderten Abhängigkeiten zuerst. Das Dockerfile darf in der .dockerignore stehen: BuildKit bekommt es trotzdem, nur COPY . . sieht es nicht mehr. Der Cache-Mount macht auch den Compile-Schritt inkrementell.

Fortschritt speichern? Kostenlos registrieren

Runde 3: API-Key im Layer – finden, entfernen, rotieren

Erst spielst du Spielleitung und legst das Desaster an:

rm -rf ~/docker-lab/tag15/runde03 && mkdir -p ~/docker-lab/tag15/runde03
cd ~/docker-lab/tag15/runde03
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag15/runde03/." .
docker build -q --build-arg NOTES_API_KEY=lab-api-key-123 \
  -t localhost:5001/notes-api:r03 notes-api
docker push -q localhost:5001/notes-api:r03
docker rmi -f localhost:5001/notes-api:r03 >/dev/null

Lage: Ein Kollege freut sich: „localhost:5001/notes-api:r03 startet ganz ohne -e.” Du hast nur die Registry, nicht seinen Rechner. Finde heraus, wo der Key steckt, bau ein sauberes Image und mach den alten Key wertlos. Zeitlimit: 15 min.

Hinweis: Ein Image ohne Shell verrät seine Konfiguration und Geschichte trotzdem (Tag 11) – und ein veröffentlichter Key gilt als verbrannt, egal wie schnell du bist.

Lösung

Finden:

docker pull -q localhost:5001/notes-api:r03
docker image inspect --format '{{json .Config.Env}}' localhost:5001/notes-api:r03
docker history --no-trunc --format '{{.CreatedBy}}' localhost:5001/notes-api:r03 \
  | grep -n lab-api-key
docker build --check notes-api 2>&1 | grep SecretsUsedInArgOrEnv

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

localhost:5001/notes-api:r03
["PATH=/usr/local/sbin:/usr/local/bin:…","NOTES_API_KEY=lab-api-key-123"]
4:ENV NOTES_API_KEY=lab-api-key-123
WARNING: SecretsUsedInArgOrEnv - https://docs.docker.com/go/dockerfile/rule/secrets…
WARNING: SecretsUsedInArgOrEnv - https://docs.docker.com/go/dockerfile/rule/secrets…

Der Key steht im Image-Config und in der History, die Build Checks hätten ihn vorher gemeldet (ARG in Zeile 18, ENV in Zeile 19). Entfernen und neu veröffentlichen:

sed -i.bak '/NOTES_API_KEY/d' notes-api/Dockerfile && rm notes-api/Dockerfile.bak
docker build -q -t localhost:5001/notes-api:r03 notes-api
docker push -q localhost:5001/notes-api:r03
docker history --no-trunc localhost:5001/notes-api:r03 | grep -c lab-api-key

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

sha256:8d41…
localhost:5001/notes-api:r03
0

Rotieren: Der neue Key ist im Lab lab-api-key-456 (ebenfalls ein Lab-Wert). Er kommt nur zur Laufzeit in den Container, der alte muss abgewiesen werden:

docker run -d --name notes-api -e NOTES_API_KEY=lab-api-key-456 \
  -p 127.0.0.1:8080:8080 localhost:5001/notes-api:r03
sleep 1
curl -s -X POST localhost:8080/notes -H 'X-API-Key: lab-api-key-123' -d '{"text":"alt"}'
curl -s -X POST localhost:8080/notes -H 'X-API-Key: lab-api-key-456' -d '{"text":"neu"}'
docker rm -f notes-api

Erwartet (gekürzt, IDs weichen ab):

e5a2…
{"error":"invalid api key"}
{"id":"0b7e…","text":"neu"}
notes-api

Sicherheit: Das Überschreiben des Tags löscht das alte Manifest nicht. Wer den alten Digest kennt oder das Image schon gezogen hat, hat den Key. In echt rotierst du deshalb zuerst und räumst danach auf; Tag 11 zeigt, warum Löschen allein nie reicht.

Fortschritt speichern? Kostenlos registrieren

Runde 4: .env im Image

Lage: Der Pentest-Bericht meldet „Zugangsdaten im Image notes-web“. Finde sie, entferne sie und sorg dafür, dass sie nie wieder hineinkommen. Zeitlimit: 10 min.

rm -rf ~/docker-lab/tag15/runde04 && mkdir -p ~/docker-lab/tag15/runde04
cd ~/docker-lab/tag15/runde04
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag15/runde04/." .
docker build -q -t notes-web:r04 notes-web
docker run --rm notes-web:r04 ls -A /app

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

sha256:c27e…
.env               node_modules       public             src
Dockerfile         package-lock.json  server.js
dist               package.json

Hinweis: COPY . . kopiert alles, was im Kontext liegt, und COPY --from=build /app ./ reicht es unbesehen weiter.

Lösung

Beweis, dann Fix: .dockerignore hält die Datei aus dem Kontext, der Final-Stage kopiert nur noch, was er braucht.

docker run --rm notes-web:r04 cat /app/.env
cat > notes-web/.dockerignore <<'EOF'
node_modules
dist
.env*
Dockerfile*
.dockerignore
*.md
EOF
cat > notes-web/Dockerfile <<'EOF'
# syntax=docker/dockerfile:1
FROM node:24-alpine AS build
WORKDIR /app
COPY package.json package-lock.json ./
RUN --mount=type=cache,target=/root/.npm npm ci
COPY . .
RUN npm run build

FROM node:24-alpine
ENV NODE_ENV=production
WORKDIR /app
COPY package.json package-lock.json ./
RUN --mount=type=cache,target=/root/.npm npm ci --omit=dev
COPY --from=build /app/dist ./dist
COPY public ./public
COPY server.js ./
USER node
EXPOSE 3000
CMD ["node", "server.js"]
EOF
docker build -q -t notes-web:r04-fix notes-web
docker run --rm notes-web:r04-fix ls -A /app

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

# nur für "node --env-file=.env server.js" auf dem Laptop – Lab-Wert
NOTES_API_KEY=lab-api-key-123
NOTES_API_URL=http://localhost:8080
sha256:51d0…
dist               package-lock.json  public
node_modules       package.json       server.js

Warum? Zwei Schutzschichten: Die .dockerignore hält .env aus dem Kontext (Tag 3), das explizite COPY nimmt auch künftig nichts Unbekanntes mit. Ins Repository gehört die Datei ebenso wenig: .env in die .gitignore (Tag 12). Wurde notes-web:r04 irgendwo hin gepusht, gilt Runde 3: Key rotieren.

Fortschritt speichern? Kostenlos registrieren

Runde 5: Container läuft als root

Lage: Die Admission-Policy im Cluster lehnt notes-worker ab: „container must not run as root”. Ziel: numerischer non-root-User, und der Worker läuft auch mit schreibgeschütztem Dateisystem ohne Capabilities. Zeitlimit: 10 min.

rm -rf ~/docker-lab/tag15/runde05 && mkdir -p ~/docker-lab/tag15/runde05
cd ~/docker-lab/tag15/runde05
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag15/runde05/." .
docker build -q -t notes-worker:r05 notes-worker
docker image inspect --format 'User="{{.Config.User}}"' notes-worker:r05
docker run --rm --entrypoint id notes-worker:r05

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

sha256:a4c3…
User=""
uid=0(root) gid=0(root) groups=0(root)

Hinweis: Ein leerer Config.User heißt root, und Kubernetes kann runAsNonRoot nur bei einer numerischen UID sicher prüfen (Tag 9).

Lösung

cat > notes-worker/Dockerfile <<'EOF'
# syntax=docker/dockerfile:1
FROM python:3.13-slim AS build
COPY --from=ghcr.io/astral-sh/uv:0.13 /uv /bin/uv
ENV UV_COMPILE_BYTECODE=1 UV_LINK_MODE=copy
WORKDIR /app
COPY pyproject.toml uv.lock ./
RUN --mount=type=cache,target=/root/.cache/uv \
    uv sync --locked --no-dev --no-install-project
COPY src ./src
RUN --mount=type=cache,target=/root/.cache/uv \
    uv sync --locked --no-dev --no-editable

FROM python:3.13-slim
WORKDIR /app
COPY --from=build /app/.venv /app/.venv
ENV PATH="/app/.venv/bin:$PATH"
USER 65532:65532
ENTRYPOINT ["notes-worker"]
EOF
docker build -q -t notes-worker:r05-fix notes-worker
docker run --rm --entrypoint id notes-worker:r05-fix
docker run -d --name notes-worker --read-only --cap-drop ALL \
  --security-opt no-new-privileges -e NOTES_API_KEY=lab-api-key-123 \
  -e NOTES_API_URL=http://127.0.0.1:9 notes-worker:r05-fix
sleep 2; docker logs notes-worker; docker rm -f notes-worker

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

sha256:e90b…
uid=65532 gid=65532 groups=65532
0c4f…
worker started, api=http://127.0.0.1:9, interval=10s
error: …
notes-worker

Warum? USER 65532:65532 braucht keinen Eintrag in /etc/passwd, deshalb zeigt id nur Zahlen. Die .venv gehört root, ist aber für alle lesbar; der Worker schreibt nichts, also klappt --read-only. Der error ist hier richtig: Auf Port 9 lauscht keine API.

Fortschritt speichern? Kostenlos registrieren

Runde 6: docker stop hängt 10 Sekunden

Lage: Jedes Deployment dauert pro Container zehn Sekunden länger als nötig, und im Log fehlt shutdown complete. Ziel: docker stop unter einer Sekunde, sauberer Shutdown, Exit-Code 0. Zeitlimit: 10 min.

rm -rf ~/docker-lab/tag15/runde06 && mkdir -p ~/docker-lab/tag15/runde06
cd ~/docker-lab/tag15/runde06
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag15/runde06/." .
docker build -q -t notes-api:r06 notes-api
docker run -d --name notes-api -e NOTES_API_KEY=lab-api-key-123 notes-api:r06
sleep 1; SECONDS=0; docker stop notes-api; echo "stop: ${SECONDS}s"
docker logs notes-api
docker inspect --format 'Exit {{.State.ExitCode}}' notes-api; docker rm notes-api

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

9c2d…
notes-api
stop: 10s
notes-api startet als UID 65532
time=… level=INFO msg="api key loaded" source=env
time=… level=INFO msg=listening addr=:8080 version=dev pid=7
Exit 137
notes-api

Hinweis: Wer ist PID 1 (docker top), und wer bekommt das SIGTERM von docker stop (Tag 2)?

Lösung

docker run -d --name notes-api -e NOTES_API_KEY=lab-api-key-123 notes-api:r06
sleep 1; docker top notes-api; docker rm -f notes-api

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

UID     PID    PPID   C  STIME  TTY  TIME      CMD
65532   4711   4690   0  …      ?    00:00:00  /bin/sh /usr/local/bin/entrypoint.sh
65532   4735   4711   0  …      ?    00:00:00  notes-api
notes-api

PID 1 ist die Shell. Sie hat keinen Handler für SIGTERM, und als PID 1 ignoriert der Kernel das Signal dann; notes-api bekommt es nie. Nach 10 s folgt SIGKILL, Exit 137. exec ersetzt die Shell durch den Server:

cat > notes-api/entrypoint.sh <<'EOF'
#!/bin/sh
# Startskript: kurzes Banner, dann den Server als PID 1 starten
echo "notes-api startet als UID $(id -u)"
exec notes-api "$@"
EOF
docker build -q -t notes-api:r06-fix notes-api
docker run -d --name notes-api -e NOTES_API_KEY=lab-api-key-123 notes-api:r06-fix
sleep 1; SECONDS=0; docker stop notes-api; echo "stop: ${SECONDS}s"
docker logs notes-api 2>&1 | tail -2
docker inspect --format 'Exit {{.State.ExitCode}}' notes-api; docker rm notes-api

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

sha256:77b2…
3e1a…
notes-api
stop: 0s
time=… level=INFO msg="signal received, shutting down"
time=… level=INFO msg="shutdown complete"
Exit 0
notes-api

Warum? Mit exec ist notes-api PID 1 und fängt SIGTERM selbst. Ohne Startskript wäre die Exec-Form ENTRYPOINT ["notes-api"] noch einfacher; docker run --init hilft, wenn du das Image nicht ändern kannst (Tag 2).

Fortschritt speichern? Kostenlos registrieren

Runde 7: exec format error

Lage: notes-api wird für amd64 und arm64 gebaut. Auf den arm64-Servern startet der Container mit exec format error, auf den amd64-Servern läuft er. Ziel: Beide Varianten enthalten das passende Binary, ohne Emulation im Build. Zeitlimit: 15 min.

rm -rf ~/docker-lab/tag15/runde07 && mkdir -p ~/docker-lab/tag15/runde07
cd ~/docker-lab/tag15/runde07
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag15/runde07/." .
docker buildx build -q --builder docker-lab --platform linux/amd64,linux/arm64 \
  -t localhost:5001/notes-api:r07 --push notes-api
docker buildx imagetools inspect localhost:5001/notes-api:r07 | grep Platform

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

sha256:bf79ece823d6…
  Platform:    linux/amd64
  Platform:    linux/arm64
  Platform:    unknown/unknown
  Platform:    unknown/unknown

Laut Index ist alles da. Ob die Binaries stimmen, sagt erst ein Blick hinein.

Hinweis: Hol dir die arm64-Variante mit --platform, kopier das Binary heraus und frag file. Wer setzt im Dockerfile GOARCH (Tag 7)?

Lösung

Die arm64-Variante anlegen, ohne sie zu starten, und das Binary prüfen. Das klappt auf jedem Rechner, egal welche Architektur er hat. --pull always holt den aktuellen Stand aus der Registry:

docker create --pull always --platform linux/arm64 --name notes-r07 \
  localhost:5001/notes-api:r07
docker cp notes-r07:/notes-api ./notes-api.bin
file notes-api.bin
docker rm notes-r07 && rm notes-api.bin

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

…
Digest: sha256:bf79ece823d6…
3071a0197017…
notes-api.bin: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked…
notes-r07

Die arm64-Variante enthält ein x86-64-Binary: GOARCH=amd64 ist fest verdrahtet. Die Zielplattform muss aus TARGETOS und TARGETARCH kommen, die im Stage deklariert sein müssen:

cat > notes-api/Dockerfile <<'EOF'
# syntax=docker/dockerfile:1
ARG GO_VERSION=1.27
FROM --platform=$BUILDPLATFORM 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 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
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
ENTRYPOINT ["/notes-api"]
EOF
docker build -q -t notes-api:r07-fix notes-api
docker buildx build -q --builder docker-lab --platform linux/amd64,linux/arm64 \
  -t localhost:5001/notes-api:r07 --push notes-api
docker create --pull always --platform linux/arm64 --name notes-r07 \
  localhost:5001/notes-api:r07
docker cp notes-r07:/notes-api ./notes-api.bin
file notes-api.bin
docker rm notes-r07 && rm notes-api.bin

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

sha256:f4e149f4e34d…
sha256:0e81f37cee9d…
…
notes-api.bin: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), statically…
notes-r07

Jetzt steckt in der arm64-Variante ein ARM aarch64-Binary. unknown/unknown sind die Attestations, die buildx mitschickt (Tag 10). Der Go-Compiler läuft dank --platform=$BUILDPLATFORM immer nativ und erzeugt nur das Binary für die Zielplattform.

Fortschritt speichern? Kostenlos registrieren

Runde 8: x509: certificate signed by unknown authority

Lage: Seit dem Umstieg auf ein „noch kleineres” Image liefert /upstream nur Fehler. Ziel: /upstream antwortet mit Status 200, das Image bleibt scratch. Zeitlimit: 10 min.

rm -rf ~/docker-lab/tag15/runde08 && mkdir -p ~/docker-lab/tag15/runde08
cd ~/docker-lab/tag15/runde08
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag15/runde08/." .
docker build -q -t notes-api:r08 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:r08
sleep 1; curl -s localhost:8080/upstream | jq -r .error | grep -o 'x509: .*'
docker rm -f notes-api

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

sha256:2a7d…
5f3b…
x509: certificate signed by unknown authority
notes-api

Hinweis: Woher kennt ein Go-Programm in einem leeren Dateisystem die vertrauenswürdigen Zertifizierungsstellen?

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
ENTRYPOINT ["/notes-api"]
EOF
docker build -q -t notes-api:r08-fix 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:r08-fix
sleep 1; curl -s localhost:8080/upstream; docker rm -f notes-api

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

sha256:9e14…
c81d…
{"status":200,"url":"https://example.com"}
notes-api

Warum? Go liest unter Linux das CA-Bündel aus Standardpfaden wie /etc/ssl/certs/ca-certificates.crt. In scratch fehlt es, also kopierst du es aus dem build-Stage (Tag 5). Dasselbe gilt für Zeitzonen. Die Alternative ist gcr.io/distroless/static-debian13:nonroot, das CA-Zertifikate schon mitbringt.

Fortschritt speichern? Kostenlos registrieren

Runde 9: COPY failed wegen zu gieriger .dockerignore

Lage: Ein Kollege hat den Build-Kontext „aufgeräumt”. Seitdem bricht der Build ab, obwohl go.sum im Ordner liegt. Zeitlimit: 10 min.

rm -rf ~/docker-lab/tag15/runde09 && mkdir -p ~/docker-lab/tag15/runde09
cd ~/docker-lab/tag15/runde09
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag15/runde09/." .
ls notes-api
docker build -t notes-api:r09 notes-api

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

Dockerfile      Dockerfile.naiv go.mod          go.sum          main.go
 => ERROR [build 3/6] COPY go.mod go.sum ./                                    0.0s
------
 > [build 3/6] COPY go.mod go.sum ./:
------
ERROR: failed to build: failed to solve: failed to compute cache key: failed to
calculate checksum of ref …: "/go.sum": not found

Hinweis: Die Datei liegt im Ordner, aber liegt sie auch im Kontext? Bau dir einen Kontext-Spion (Tag 3).

Lösung

Der Spion kopiert den ganzen Kontext und listet ihn auf, -f - liest das Dockerfile von stdin:

docker build --no-cache --progress=plain -f - notes-api 2>&1 <<'EOF' | grep '/ctx/'
# syntax=docker/dockerfile:1
FROM golang:1.27-alpine
COPY . /ctx
RUN find /ctx -type f
EOF
cat notes-api/.dockerignore
docker build --check --build-arg BUILDKIT_DOCKERFILE_CHECK=experimental=all notes-api

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

#7 0.171 /ctx/go.mod
#7 0.171 /ctx/main.go
# Allowlist: alles raus, nur der Quellcode rein
*
!*.go
!go.mod
WARNING: CopyIgnoredFile - https://docs.docker.com/go/dockerfile/rule/copy-ignored-…
Attempting to Copy file "go.sum" that is excluded by .dockerignore

Die Allowlist vergisst go.sum. Der Build Check CopyIgnoredFile findet das, ohne zu bauen; ist er bei deiner Version noch experimentell, schaltet ihn experimental=all ein. Fix:

cat > notes-api/.dockerignore <<'EOF'
# Allowlist: alles raus, nur der Quellcode rein
*
!*.go
!go.mod
!go.sum
EOF
docker build -q -t notes-api:r09-fix notes-api

Erwartet (kann je nach Version abweichen):

sha256:0d93…

Warum? Bei einer Allowlist braucht jede neue Datei eine eigene !-Ausnahme, und die letzte passende Zeile gewinnt. Eine Denylist wie in Runde 2 (Tag 3) ist robuster; wer Allowlists nimmt, lässt docker build --check in der CI laufen.

Fortschritt speichern? Kostenlos registrieren

Runde 10: Healthcheck „unhealthy” ohne curl

Lage: Der Container läuft, curl von außen sagt ok, aber Docker meldet „unhealthy”, und der Orchestrator startet ihn ständig neu. Zeitlimit: 10 min.

rm -rf ~/docker-lab/tag15/runde10 && mkdir -p ~/docker-lab/tag15/runde10
cd ~/docker-lab/tag15/runde10
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag15/runde10/." .
docker build -q -t notes-api:r10 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:r10
sleep 20; curl -s localhost:8080/healthz
docker inspect --format '{{.State.Health.Status}}' notes-api
docker inspect --format '{{json .State.Health.Log}}' notes-api | jq -r '.[-1].Output'
docker rm -f notes-api

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

sha256:b5c2…
7a90…
ok
unhealthy
OCI runtime exec failed: exec failed: unable to start container process: exec:
"/bin/sh": stat /bin/sh: no such file or directory: unknown
notes-api

Hinweis: Die Shell-Form braucht /bin/sh, curl braucht curl, und scratch hat beides nicht. Was kann das Binary selbst (Tag 2)?

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
docker build -q -t notes-api:r10-fix 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:r10-fix
sleep 3; docker inspect --format '{{.State.Health.Status}}' notes-api
docker image inspect --format '{{json .Config.Healthcheck.Test}}' notes-api:r10-fix
docker rm -f notes-api

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

sha256:4e6f…
d2b8…
healthy
["CMD","/notes-api","healthcheck"]
notes-api

Warum? CMD in Exec-Form startet das Binary direkt, ohne Shell, und notes-api healthcheck fragt /healthz selbst ab. --start-interval prüft in der Startphase jede Sekunde statt alle zehn; es braucht Docker Engine 25 oder neuer.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Wertung: Trag deine Punkte (0–2) pro Runde zusammen. Die Befehle prüfen, ob die reparierten Stände wirklich da sind.

R1 – unter 20 MB:

cd ~/docker-lab/tag15
docker image ls notes-api:r01-fix

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

IMAGE               ID             DISK USAGE   CONTENT SIZE   EXTRA
notes-api:r01-fix   27e9e8c40069       10.7MB         3.23MB

R2 – go.mod und go.sum vor dem Quellcode:

grep -n '^COPY' runde02/notes-api/Dockerfile

Erwartet:

5:COPY go.mod go.sum ./
7:COPY . .
15:COPY --from=build /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
16:COPY --from=build /out/notes-api /notes-api

R3 – kein Key im Image in der Registry:

docker history --no-trunc localhost:5001/notes-api:r03 | grep -c lab-api-key

Erwartet:

0

R4 – keine .env im Web-Image:

docker run --rm notes-web:r04-fix ls -a /app

Erwartet:

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

R5 – der Worker läuft als UID 65532:

docker run --rm --entrypoint id notes-worker:r05-fix -u

Erwartet:

65532

R6 – das Startskript nutzt exec:

grep '^exec' runde06/notes-api/entrypoint.sh

Erwartet:

exec notes-api "$@"

R7 – das Binary passt zur Plattform. Ohne laufenden Server endet der Healthcheck mit Exit 1, nicht mit exec format error:

docker run --rm --entrypoint /notes-api notes-api:r07-fix healthcheck; echo "Exit: $?"

Erwartet:

Exit: 1

R8 – das CA-Bündel steckt im Final-Stage:

grep 'ca-certificates.crt /etc/ssl/certs/' runde08/notes-api/Dockerfile

Erwartet:

COPY --from=build /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/

R9 – das Image ist gebaut:

docker image ls notes-api:r09-fix

Erwartet (gekürzt):

IMAGE               ID             DISK USAGE   CONTENT SIZE   EXTRA
notes-api:r09-fix   cb96c18496c5       10.7MB         3.23MB

R10 – Healthcheck ohne Shell:

docker image inspect --format '{{json .Config.Healthcheck.Test}}' notes-api:r10-fix

Erwartet:

["CMD","/notes-api","healthcheck"]
Punkte Urteil
17–20 Wettkampfreif: weiter mit Anhang B
10–16 Solide: die Runden mit 0 Punkten am Tag dahinter nachtrainieren
unter 10 Teil A und B (Tag 1–8) noch einmal, dann Revanche

Challenge

Blindflug: code/tag15/challenge enthält ein Dockerfile mit sechs Desastern aus den Runden. Finde alle sechs zuerst nur mit Werkzeugen (docker build --check, hadolint, docker image inspect, docker run), erst dann darfst du die Datei lesen. Repariere sie zu einem Image notes-api:final, das gehärtet läuft und „healthy” wird.

Hinweis: --check meldet eins der sechs Desaster gleich zweimal; für die übrigen genügt je ein Diagnosebefehl aus den Runden 2, 5, 7, 8 und 10.

Lösung

Diagnose:

rm -rf ~/docker-lab/tag15/challenge && mkdir -p ~/docker-lab/tag15/challenge
cd ~/docker-lab/tag15/challenge
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag15/challenge/." .
docker build --check notes-api 2>&1 | grep WARNING
docker build -q --build-arg NOTES_API_KEY=lab-api-key-123 -t notes-api:blind notes-api
docker image inspect --format \
  'User="{{.Config.User}}" Health={{json .Config.Healthcheck.Test}}' notes-api:blind
docker run --rm notes-api:blind

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

WARNING: SecretsUsedInArgOrEnv - https://docs.docker.com/go/dockerfile/rule/secrets…
WARNING: SecretsUsedInArgOrEnv - https://docs.docker.com/go/dockerfile/rule/secrets…
sha256:aa31…
User="" Health=["CMD-SHELL","wget -qO- http://localhost:8080/healthz || exit 1"]
exec /notes-api: exec format error

Damit liegen fünf offen: Key per ARG/ENV (Runde 3), root (Runde 5), Healthcheck per Shell (Runde 10), GOARCH=amd64 (Runde 7) und – nach dem Fix der Architektur – x509 bei /upstream (Runde 8). Das sechste zeigt nur der Build-Log: Nach einer Änderung an main.go läuft go mod download erneut, weil COPY . . davor steht (Runde 2). Die reparierte Fassung bündelt alle Runden und ergänzt # check=error=true (Tag 9), damit der Key nie wieder durch den Build kommt:

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 build
WORKDIR /src
COPY go.mod go.sum ./
RUN --mount=type=cache,target=/go/pkg/mod go mod download
COPY . .
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
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
hadolint notes-api/Dockerfile; echo "Exit: $?"
docker build --check notes-api 2>&1 | tail -1
docker build -q --build-arg VERSION=15.0.0 -t notes-api:final notes-api
docker run -d --name notes-api --read-only --cap-drop ALL \
  --security-opt no-new-privileges -e NOTES_API_KEY=lab-api-key-123 \
  -p 127.0.0.1:8080:8080 notes-api:final
sleep 3; docker ps --filter name=notes-api --format '{{.Status}}'
curl -s localhost:8080/version; curl -s localhost:8080/upstream
time docker stop notes-api

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

Exit: 0
Check complete, no warnings found.
sha256:b913de03eeb0…
91c4…
Up 3 seconds (healthy)
15.0.0
{"status":200,"url":"https://example.com"}
notes-api

real    0m0.554s
…

Von den Schwächen aus Dockerfile.naiv (Tag 0) ist keine übrig: kein Compiler im Image, kein root, kein Key, keine Shell-Form. Zum Schluss aufräumen:

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):

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

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Desaster-Drills eignen sich als Team-Gameday: rotierende Spielleitung, feste Zeitlimits, nach jeder Runde fünf Minuten Postmortem „Wie hätte die CI das gefangen?“.
  • Die meisten Runden lassen sich automatisch verhindern: Build Checks mit error=true, hadolint, ein Größenbudget pro Image, trivy --scanners secret und eine Admission-Policy für runAsNonRoot (Tag 9, Tag 10, Tag 11).
  • Ein geleakter Key ist ein Incident: sofort rotieren, alle betroffenen Digests in der Registry löschen oder sperren, Pull-Logs der Registry auswerten.
  • exec format error in Produktion verhindert ein Multi-Plattform-Index plus eine Pipeline-Prüfung mit docker buildx imagetools inspect (Tag 7).
  • Hinter einem Firmen-Proxy mit TLS-Inspektion kommt die Firmen-CA ins CA-Bündel des Images – nie InsecureSkipVerify oder curl -k als „Fix”.