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/rundeNNdarü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-apiErwartet:
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-apiErwartet (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/nullLage: 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 SecretsUsedInArgOrEnvErwartet (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-keyErwartet (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-apiErwartet (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 /appErwartet (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 /appErwartet (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:r05Erwartet (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-workerErwartet (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-apiErwartet (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-apiErwartet (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-apiErwartet (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 PlatformErwartet (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.binErwartet (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.binErwartet (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-apiErwartet (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-apiErwartet (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-apiErwartet (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-apiErwartet (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-apiErwartet (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-apiErwartet (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-apiErwartet (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-fixErwartet (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/DockerfileErwartet:
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-keyErwartet:
0
R4 – keine .env im Web-Image:
docker run --rm notes-web:r04-fix ls -a /appErwartet:
.
..
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 -uErwartet:
65532
R6 – das Startskript nutzt exec:
grep '^exec' runde06/notes-api/entrypoint.shErwartet:
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/DockerfileErwartet:
COPY --from=build /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
R9 – das Image ist gebaut:
docker image ls notes-api:r09-fixErwartet (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-fixErwartet:
["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:blindErwartet (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-apiErwartet (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 --forceErwartet (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 secretund eine Admission-Policy fürrunAsNonRoot(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 errorin Produktion verhindert ein Multi-Plattform-Index plus eine Pipeline-Prüfung mitdocker buildx imagetools inspect(Tag 7).- Hinter einem Firmen-Proxy mit TLS-Inspektion kommt die Firmen-CA ins
CA-Bündel des Images – nie
InsecureSkipVerifyodercurl -kals „Fix”.