Tag 15: Wettkampf – Desaster-Drills
Ziel: Zehn kaputte Compose-Stände 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 Demo-Anwendung mit dem Stand von Tag 8 an und
den kaputten Stand aus
code/tag15/rundeNNdarüber. Dein Stand von Tag 14 bleibt unberührt. - Alle Runden laufen als Projekt
notes. Jede Lösung endet mitdocker compose down -v, damit die nächste Runde mit leerem Volume beginnt. - Wertung: 2 Punkte in der Zeit ohne Hinweis, 1 Punkt mit Hinweis oder knapp drüber, 0 Punkte mit Lösung.
Runde 1: Belegt und offen
source ~/compose-lab/setup/env.sh
docker compose -p notes down
rm -rf ~/compose-lab/tag15/runde01 && mkdir -p ~/compose-lab/tag15/runde01
cd ~/compose-lab/tag15/runde01
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag08/notes/." .
cp -R "$LAB/code/tag15/runde01/." .
lsErwartet:
README.md compose.tools.yaml db notes-web secrets
compose.dev.yaml compose.yaml notes-api notes-worker
Jede Runde beginnt so: Ordner leeren, Demo-Anwendung mit dem Stand von Tag 8 hinein, kaputten Stand darüber. Wiederholst du die Zeilen, fängst du die Runde von vorn an. Container und Volumes bleiben dabei unberührt. Erst spielst du Spielleitung – ein anderer Dienst belegt Port 8080:
docker run -d --name notes-blocker --label lab=compose-lab \
-p 127.0.0.1:8080:80 alpine:3.24 sleep infinityLage: Ein Kollege hat die Ports in
compose.yaml „vereinfacht”. Sein erstes up
scheiterte, beim zweiten war alles grün – trotzdem antwortet unter
localhost:8080 nicht notes-api. Der Security-Scan meldet
außerdem web im WLAN. Ziel: api auf 8081, beide Ports nur lokal,
notes-blocker bleibt stehen. Zeitlimit: 10
min.
docker compose up -d --wait; echo "Exit: $?"
docker compose up -d --wait; echo "Exit: $?"
docker compose ps --format 'table {{.Service}}\t{{.Status}}\t{{.Ports}}'
curl -sS -m 3 localhost:8080/healthz; echo "curl: $?"Erwartet (gekürzt, IDs und Zeiten weichen bei dir ab):
Container notes-migrate-1 Exited
Container notes-api-1 Starting
Error response from daemon: failed to set up container networking: driver failed
programming external connectivity on endpoint notes-api-1 (…): Bind for
127.0.0.1:8080 failed: port is already allocated
Exit: 1
…
Container notes-api-1 Healthy
Container notes-web-1 Healthy
Exit: 0
SERVICE STATUS PORTS
api Up 3 seconds (healthy) 8080/tcp
db Up 6 seconds (healthy) 5432/tcp
web Up 1 second (healthy) 0.0.0.0:3000->3000/tcp, [::]:3000->3000/tcp
worker Up 1 second
curl: (52) Empty reply from server
curl: 52
Achtung: Das zweite
upstartet den beim ersten Mal nur angelegten Container – ohne Portfreigabe (8080/tcp, kein->).--waitprüft Gesundheit, nicht Erreichbarkeit. Die Antwort auf 8080 kam vom Blocker.
Hinweis: Wem gehört 8080? docker ps
kennt den Filter publish=. Und was steht in
ports: vor dem ersten Doppelpunkt, wenn keine IP dasteht
(Tag 1, Tag 4)?
Lösung
docker ps --filter publish=8080 --format '{{.Names}} {{.Ports}}'
grep -nE '^ +- "[0-9]+:' compose.yamlErwartet:
notes-blocker 127.0.0.1:8080->80/tcp
22: - "8080:8080"
76: - "3000:3000"
Beide Ports ohne IP heißen 0.0.0.0 und :: –
alle Interfaces. Zurück zur Schreibweise aus Tag 1, den Port legst du in
.env fest:
sed -i '' -e 's#"8080:8080"#"127.0.0.1:${API_PORT:-8080}:8080"#' \
-e 's#"3000:3000"#"127.0.0.1:${WEB_PORT:-3000}:3000"#' compose.yaml
printf '\nAPI_PORT=8081\n' >> .env
docker compose up -d --wait; echo "Exit: $?"
docker compose ps --format 'table {{.Service}}\t{{.Ports}}'
curl -s localhost:8081/healthz; echoErwartet (gekürzt):
Container notes-api-1 Recreated
Container notes-web-1 Recreated
…
Container notes-api-1 Healthy
Container notes-web-1 Healthy
Exit: 0
SERVICE PORTS
api 127.0.0.1:8081->8080/tcp
db 5432/tcp
web 127.0.0.1:3000->3000/tcp
worker
ok
Warum? Der Port ist ein Teil der Dienstdefinition, also erzeugt
Compose api und web neu. Mit Variable und Standardwert passt jeder
Rechner den Port in .env an, ohne die Datei zu ändern.
Aufräumen:
docker rm -f notes-blocker && docker compose down -vFortschritt speichern? Kostenlos registrieren
Runde 2: Der Healthcheck ist doch da
rm -rf ~/compose-lab/tag15/runde02 && mkdir -p ~/compose-lab/tag15/runde02
cd ~/compose-lab/tag15/runde02
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag08/notes/." .
cp -R "$LAB/code/tag15/runde02/." .
docker compose up -d --wait; echo "Exit: $?"
docker compose ps -a --format 'table {{.Service}}\t{{.Status}}'Lage: Die CI meldet auf frischem Volume rot, lokal
„klappt es meistens”. db hat einen sauberen Healthcheck mit
-h 127.0.0.1. Ziel: down -v und
up --wait liefern zuverlässig Exit 0,
GET /notes liefert 200. Zeitlimit: 10
min.
Erwartet (gekürzt):
Container notes-db-1 Started
Container notes-migrate-1 Started
Container notes-api-1 Started
Container notes-api-1 Waiting
Container notes-api-1 Error dependency api failed to start
dependency failed to start: container notes-api-1 is unhealthy
Exit: 1
SERVICE STATUS
api Restarting (1) Less than a second ago
db Up Less than a second (health: starting)
migrate Exited (1) Less than a second ago
web Created
worker Created
Wart ein paar Sekunden und schau noch einmal hin:
docker compose ps -a --format 'table {{.Service}}\t{{.Status}}'
curl -s -w ' %{http_code}\n' localhost:8080/notes
docker compose logs --no-log-prefix migrate | cut -c1-80Erwartet (gekürzt):
SERVICE STATUS
api Up 17 seconds (healthy)
db Up 18 seconds (healthy)
migrate Exited (1) 18 seconds ago
web Created
worker Created
{"error":"storage"} 500
time=… level=ERROR msg="database unreachable" source=env err="failed to c
Der gefährlichste Zustand: api ist dank
restart: unless-stopped irgendwann „healthy”, aber die
Tabelle fehlt, weil migrate einmal scheiterte und nie wieder lief.
Hinweis: Ein Healthcheck allein wartet auf niemanden. Wer liest ihn (Tag 5)?
Lösung
grep -n 'depends_on: \[' compose.yamlErwartet:
24: depends_on: [db, migrate]
39: depends_on: [db]
Die kurze Form wartet nur auf „gestartet”. Ersetze beide Zeilen durch die lange Form (api: Zeile 24, migrate: Zeile 39):
api:
# …
depends_on:
db:
condition: service_healthy
migrate:
condition: service_completed_successfully
migrate:
# …
depends_on:
db:
condition: service_healthydocker compose down -v
docker compose up -d --wait; echo "Exit: $?"
docker compose ps -a --format 'table {{.Service}}\t{{.Status}}'
curl -s -w ' %{http_code}\n' localhost:8080/notes
docker compose down -vErwartet (gekürzt):
Container notes-db-1 Healthy
Container notes-migrate-1 Exited
Container notes-api-1 Healthy
Container notes-web-1 Healthy
Exit: 0
SERVICE STATUS
api Up 3 seconds (healthy)
db Up 5 seconds (healthy)
migrate Exited (0) 3 seconds ago
web Up 1 second (healthy)
worker Up 1 second
[] 200
Warum? condition: service_healthy macht aus dem
Healthcheck von db eine Bedingung,
service_completed_successfully aus dem Exit-Code von
migrate. Die Datei entspricht jetzt wieder
code/tag08/notes/compose.yaml.
Fortschritt speichern? Kostenlos registrieren
Runde 3: Zu früh gesund
rm -rf ~/compose-lab/tag15/runde03 && mkdir -p ~/compose-lab/tag15/runde03
cd ~/compose-lab/tag15/runde03
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag08/notes/." .
cp -R "$LAB/code/tag15/runde03/." .
docker compose up -d --wait; echo "Exit: $?"
docker compose ps -a --format 'table {{.Service}}\t{{.Status}}'Lage: Seit ein Kollege ein Init-Skript für Testdaten
ergänzt hat (db/init/20-testdaten.sql), scheitert migrate
auf frischem Volume – obwohl db „healthy” ist. Ein zweites
up geht durch. Ziel: Exit 0 beim ersten up
nach down -v, die Testdaten bleiben.
Zeitlimit: 10 min.
Erwartet (gekürzt):
Container notes-db-1 Healthy
Container notes-migrate-1 Started
Container notes-migrate-1 Error service "migrate" didn't complete successfully: exit 1
service "migrate" didn't complete successfully: exit 1
Exit: 1
SERVICE STATUS
api Created
db Up 1 second (healthy)
migrate Exited (1) Less than a second ago
web Created
worker Created
Hinweis: Wo lauscht Postgres, während die Init-Skripte laufen, und wo fragt der Healthcheck (Tag 5, Drill 2)?
Lösung
docker compose logs --no-log-prefix db \
| grep -E 'running /docker|Unix socket' | cut -c1-80
grep -n pg_isready compose.yamlErwartet (gekürzt):
… [46] LOG: listening on Unix socket "/var/run/postgresql/.s.PGSQL.5432"
/usr/local/bin/docker-entrypoint.sh: running /docker-entrypoint-initdb.d/10-readon
/usr/local/bin/docker-entrypoint.sh: running /docker-entrypoint-initdb.d/20-testda
124: test: ["CMD", "pg_isready", "-U", "notes", "-d", "notes"]
Der temporäre Server (PID 46) lauscht nur auf dem Socket, das neue
Skript hält ihn mit pg_sleep(8) acht Sekunden am Leben. In
dieser Zeit sagt pg_isready ohne -h über den
Socket „accepting connections”, migrate bekommt über TCP aber
connection refused. Mit -h 127.0.0.1:
sed -i '' 's#"pg_isready", "-U"#"pg_isready", "-h", "127.0.0.1", "-U"#' compose.yaml
docker compose down -v
docker compose up -d --wait; echo "Exit: $?"
docker compose ps -a --format 'table {{.Service}}\t{{.Status}}'
docker compose exec db psql -U notes -d notes -tAc 'SELECT count(*) FROM demo_seed'
docker compose down -vErwartet (gekürzt):
Container notes-db-1 Healthy
Container notes-migrate-1 Exited
Container notes-api-1 Healthy
Exit: 0
SERVICE STATUS
api Up 3 seconds (healthy)
db Up 13 seconds (healthy)
migrate Exited (0) 4 seconds ago
web Up 1 second (healthy)
worker Up 1 second
1000
Warum? Erst der echte Server lauscht auf TCP – genau dort, wo api und
migrate hinwollen. db braucht jetzt zehn Sekunden bis „healthy”; das
deckt start_period: 30s ab. Das Fenster gab es vorher auch,
nur war es zu kurz, um es zu bemerken.
Fortschritt speichern? Kostenlos registrieren
Runde 4: Postgres 18 will nicht
rm -rf ~/compose-lab/tag15/runde04 && mkdir -p ~/compose-lab/tag15/runde04
cd ~/compose-lab/tag15/runde04
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag08/notes/." .
cp -R "$LAB/code/tag15/runde04/." .
docker compose up -d --wait; echo "Exit: $?"
docker compose ps -a --format 'table {{.Service}}\t{{.Status}}'Lage: Der db-Block wurde aus einer älteren Anleitung
übernommen. Jetzt startet nichts mehr. Ziel: Stack gesund, eine Notiz
überlebt down und up, und kein anonymes Volume
bleibt zurück. Zeitlimit: 10 min.
Erwartet (gekürzt):
Container notes-db-1 Started
Container notes-db-1 Waiting
Container notes-db-1 Error dependency db failed to start
dependency failed to start: container notes-db-1 is unhealthy
Exit: 1
SERVICE STATUS
api Created
db Restarting (1) Less than a second ago
migrate Created
web Created
worker Created
Hinweis: Das Log von db ist ausnahmsweise sehr
gesprächig. Und wohin hat Docker VOLUME /var/lib/postgresql
aus dem Image gelegt (Tag 3)?
Lösung
docker compose logs --no-log-prefix db | head -9Erwartet (gekürzt):
Error: in 18+, these Docker images are configured to store database data in a
format which is compatible with "pg_ctlcluster" (specifically, using
major-version-specific directory names). This better reflects how
PostgreSQL itself works, and how upgrades are to be performed.
See also https://github.com/docker-library/postgres/pull/1259
Counter to that, there appears to be PostgreSQL data in:
/var/lib/postgresql/data (unused mount/volume)
Zwei Fehler in einem: der falsche Pfad und – wie an Tag 3 – ein
anonymes Volume, das Docker für den VOLUME-Pfad des Images
angelegt hat. rm -v nimmt es mit:
sed -i '' 's#pgdata:/var/lib/postgresql/data$#pgdata:/var/lib/postgresql#' compose.yaml
docker compose rm -sfv db
docker compose up -d --wait; echo "Exit: $?"
curl -s -X POST localhost:8080/notes -H 'X-API-Key: lab-api-key-123' \
-H 'Content-Type: application/json' -d '{"text":"Runde 4 überlebt down"}'; echo
docker compose down && docker compose up -d --wait >/dev/null 2>&1
curl -s localhost:8080/notes; echo
docker compose down -vErwartet (gekürzt):
Going to remove notes-db-1
Container notes-db-1 Removed
…
Exit: 0
{"id":"d8eb9558-…","text":"Runde 4 überlebt down"}
…
[{"id":"d8eb9558-…","text":"Runde 4 überlebt down"}]
Warum? Ab Postgres 18 liegen die Daten in
/var/lib/postgresql/18/docker, das Image verweigert den
Start, wenn darunter ein fremder Mount liegt. Gut so: Mit Postgres 17
wäre das Muster still gelaufen und die Daten hätten nach dem nächsten
Upgrade im anonymen Volume gelegen.
Fortschritt speichern? Kostenlos registrieren
Runde 5: Die Shell schlägt .env
rm -rf ~/compose-lab/tag15/runde05 && mkdir -p ~/compose-lab/tag15/runde05
cd ~/compose-lab/tag15/runde05
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag08/notes/." .
cp -R "$LAB/code/tag15/runde05/." .
export NOTES_API_KEY=lab-api-key-456 # Spielleitung: Rest aus einem Rotationstest
docker compose up -d --wait >/dev/null 2>&1; echo "Exit: $?"
curl -s -w ' %{http_code}\n' -X POST localhost:8080/notes \
-H 'X-API-Key: lab-api-key-123' -H 'Content-Type: application/json' \
-d '{"text":"Runde 5"}'
curl -s -w ' %{http_code}\n' -X POST localhost:3000/api/notes \
-H 'Content-Type: application/json' -d '{"text":"Runde 5 über web"}'Lage: Alles grün, aber jeder POST mit dem Key aus
.env endet mit 401 – über web klappt es. In
compose.yaml und .env hat niemand etwas
geändert. Ziel: Der Key aus .env gilt. Den Key selbst gibst
du dabei nirgends aus. Zeitlimit: 8 min.
Erwartet (gekürzt, IDs weichen ab):
Exit: 0
{"error":"invalid api key"} 401
{"id":"38b25335-…","text":"Runde 5 über web"} 201
Hinweis: Wer gewinnt beim Interpolieren (Tag 4)? Und
was würde up tun, wenn diese Quelle fehlte?
Lösung
grep NOTES_API_KEY .env
docker compose up -d --dry-run 2>&1 | grep -c Recreate
env -u NOTES_API_KEY docker compose up -d --dry-run 2>&1 | grep ' Recreate *$'Erwartet:
NOTES_API_KEY=lab-api-key-123
0
Container notes-api-1 Recreate
Container notes-web-1 Recreate
Container notes-worker-1 Recreate
--dry-run zeigt, was up täte, ohne etwas zu
ändern. Ohne die Shell-Variable würde Compose drei Dienste neu erzeugen
– also stammt ihr laufender Wert aus der Shell. web funktioniert, weil
es denselben falschen Key mitschickt, den auch api erwartet; nur wer den
Key aus .env benutzt, scheitert.
unset NOTES_API_KEY
docker compose up -d --wait; echo "Exit: $?"
curl -s -w ' %{http_code}\n' -X POST localhost:8080/notes \
-H 'X-API-Key: lab-api-key-123' -H 'Content-Type: application/json' \
-d '{"text":"Runde 5"}'
docker compose down -vErwartet (gekürzt):
Container notes-api-1 Recreated
Container notes-worker-1 Recreated
Container notes-web-1 Recreated
…
Exit: 0
{"id":"7fda1c3f-…","text":"Runde 5"} 201
Warum? Für die Interpolation schlägt die Shell-Umgebung die
.env (Tag 4). Ein vergessenes export überlebt
jede Änderung an Dateien. env -u oder eine frische Shell
sind der schnellste Gegenbeweis.
Fortschritt speichern? Kostenlos registrieren
Runde 6: Der unsichtbare Override
rm -rf ~/compose-lab/tag15/runde06 && mkdir -p ~/compose-lab/tag15/runde06
cd ~/compose-lab/tag15/runde06
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag08/notes/." .
cp -R "$LAB/code/tag15/runde06/." .
docker compose up -d --build --wait >/dev/null 2>&1; echo "Exit: $?"
docker compose exec web sh -c 'id -u; echo "NODE_ENV=$NODE_ENV"; ls /app | tr "\n" " "'
echo; docker image ls notes-web --format '{{.Tag}} {{.Size}}'Lage: Auf deinem Rechner läuft web als root mit
NODE_ENV=development, und das frisch gebaute
notes-web:dev ist größer als in der CI – mit derselben
compose.yaml. Ziel: Ohne -f läuft web wieder
im Prod-Image. Zeitlimit: 8 min.
Erwartet (gekürzt, Größen weichen ab):
Exit: 0
0
NODE_ENV=development
dist node_modules package-lock.json package.json public server.js src
dev 280MB
Hinweis: Welche Dateien liest
docker compose ohne -f (Tag 6, Tag 7)? Compose
merkt sich an jedem Container, aus welchen Dateien er entstand.
Lösung
docker compose ls --format json \
| jq -r '.[] | select(.Name == "notes") | .ConfigFiles' | tr ',' '\n'Erwartet:
/Users/du/compose-lab/tag15/runde06/compose.yaml
/Users/du/compose-lab/tag15/runde06/compose.override.yaml
Ein liegengebliebenes compose.override.yaml aus Tag 6 –
Compose lädt es ohne -f automatisch und still. Es baute das
Ziel build (root, mit src/) und taggte es als
notes-web:dev. Weg damit, dann neu bauen:
rm compose.override.yaml
docker compose up -d --build --wait; echo "Exit: $?"
docker compose exec web sh -c 'id -u; echo "NODE_ENV=$NODE_ENV"; ls /app | tr "\n" " "'
echo; docker image ls notes-web --format '{{.Tag}} {{.Size}}'
docker ps --filter label=com.docker.compose.project=notes --format \
'{{.Names}} {{.Label "com.docker.compose.project.config_files"}}' | sed "s#$PWD/##g"Erwartet (gekürzt):
Image notes-api:dev Built
Image notes-web:dev Built
Image notes-worker:dev Built
Container notes-migrate-1 Recreated
Container notes-api-1 Recreated
Container notes-web-1 Recreated
…
Exit: 0
1000
NODE_ENV=production
dist node_modules package-lock.json package.json public server.js
dev 266MB
notes-web-1 compose.yaml
notes-api-1 compose.yaml
notes-migrate-1 compose.yaml
notes-worker-1 compose.yaml,compose.override.yaml
notes-db-1 compose.yaml,compose.override.yaml
Warum? worker und db hat Compose nicht neu erzeugt, ihre Definition
war gleich – sie tragen das alte Label weiter, und
docker compose ls zeigt den Override deshalb noch an. Nach
down ist auch das sauber. Seit Tag 7 heißt die Datei
compose.dev.yaml und wirkt nur mit -f.
docker compose down -vFortschritt speichern? Kostenlos registrieren
Runde 7: Geister nach der Umbenennung
rm -rf ~/compose-lab/tag15/runde07 && mkdir -p ~/compose-lab/tag15/runde07
cd ~/compose-lab/tag15/runde07
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag08/notes/." .
cp -R "$LAB/code/tag15/runde07/." .
docker compose up -d --wait >/dev/null 2>&1; echo "Exit: $?"
sed -i '' 's/^ worker:$/ summarizer:/' compose.yaml # Spielleitung: Umbenennung
docker compose up -d --wait 2>&1 | grep -io 'found orphan containers ([^)]*)'
docker compose down; echo "Exit: $?"
docker ps --filter label=com.docker.compose.project=notes \
--format '{{.Names}}\t{{.Status}}'Lage: Der Dienst worker heißt jetzt
summarizer. Seitdem stehen zwei Zusammenfassungen pro Takt
im Log, und nach docker compose down läuft noch etwas.
Ziel: Nach down ist das Projekt leer, beim nächsten
up gibt es genau einen Zusammenfasser.
Zeitlimit: 8 min.
Erwartet (gekürzt):
Exit: 0
Found orphan containers (notes-worker-1)
…
Network notes_backend Resource is still in use
Network notes_frontend Removed
Exit: 0
notes-worker-1 Up 11 seconds
Hinweis: Die Warnung beim up nennt den
Schalter schon. Gilt er auch für down?
Lösung
docker logs --tail 1 notes-worker-1
docker compose down --remove-orphans
docker ps -aq --filter label=com.docker.compose.project=notes | wc -l
docker compose up -d --wait 2>&1 | grep -ci orphan
docker compose ps --format 'table {{.Service}}\t{{.Status}}'
docker compose down -vErwartet (gekürzt):
error: [Errno -3] Temporary failure in name resolution
Container notes-worker-1 Stopped
Container notes-worker-1 Removed
Network notes_backend Removed
0
0
SERVICE STATUS
api Up 2 seconds (healthy)
db Up 5 seconds (healthy)
summarizer Up 1 second
web Up 1 second (healthy)
Warum? Compose verwaltet nur, was in der aktuellen Datei steht. Der
alte Container trägt weiter das Projekt-Label, hängt am Netz
notes_backend und blockiert dessen Löschung –
down meldet trotzdem Exit 0. --remove-orphans
(oder COMPOSE_REMOVE_ORPHANS=1) räumt solche Waisen bei
up und down mit ab.
Fortschritt speichern? Kostenlos registrieren
Runde 8: watch synct ins Leere
rm -rf ~/compose-lab/tag15/runde08 && mkdir -p ~/compose-lab/tag15/runde08
cd ~/compose-lab/tag15/runde08
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag08/notes/." .
cp -R "$LAB/code/tag15/runde08/." .
docker compose up -d --wait >/dev/null 2>&1; echo "Exit: $?"
docker compose watchLage: Die Designerin ändert
notes-web/public/index.html, das Terminal mit
watch meldet brav „Syncing”, aber der Browser zeigt den
alten Stand – ohne Fehler. Ziel: Eine Änderung ist nach wenigen Sekunden
sichtbar. Zeitlimit: 10 min.
In einem zweiten Terminal:
cd ~/compose-lab/tag15/runde08
sed -i '' 's#<h1>notes</h1>#<h1>notes (Runde 8)</h1>#' notes-web/public/index.html
sleep 5; curl -s localhost:3000/ | grep '<h1>'Erwartet (im zweiten Terminal):
<h1>notes</h1>
Im ersten Terminal:
Watch enabled
Syncing service "web" after 2 changes were detected
Hinweis: Synchronisiert wird – nur wohin? Vergleich das Ziel der Regel mit dem Arbeitsverzeichnis des Images.
Lösung
Im zweiten Terminal:
grep -n 'target: /' compose.yaml
docker compose exec web sh -c 'pwd; ls -l /usr/src/app/public'Erwartet (gekürzt):
92: target: /usr/src/app/public
95: target: /app/server.js
/app
total 4
-rwxr-xr-x 1 node node 283 Oct 29 22:34 index.html
Compose legt den Ordner einfach an und kopiert hinein – kein Fehler,
aber Express liest aus /app/public. watch
liest die Datei nur beim Start: erst reparieren, dann im ersten Terminal
Ctrl+C und neu starten.
sed -i '' 's#target: /usr/src/app/public#target: /app/public#' compose.yamlIm ersten Terminal Ctrl+C, dann
docker compose watch. Im zweiten:
sed -i '' 's#<h1>notes (Runde 8)</h1>#<h1>notes (Runde 8 repariert)</h1>#' \
notes-web/public/index.html
sleep 5; curl -s localhost:3000/ | grep '<h1>'Erwartet:
<h1>notes (Runde 8 repariert)</h1>
Warum? target ist ein absoluter Pfad im Container,
Compose prüft nicht, ob die Anwendung dort liest. Ohne
initial_sync (Tag 6) kommt nur an, was sich nach dem Start
von watch ändert – daher die zweite Änderung. Zum Schluss
im ersten Terminal Ctrl+C, dann
docker compose down -v.
Fortschritt speichern? Kostenlos registrieren
Runde 9: Einmal-Job in der Endlosschleife
rm -rf ~/compose-lab/tag15/runde09 && mkdir -p ~/compose-lab/tag15/runde09
cd ~/compose-lab/tag15/runde09
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag08/notes/." .
cp -R "$LAB/code/tag15/runde09/." .
SECONDS=0; docker compose up -d --wait --wait-timeout 60
echo "Exit: $? nach ${SECONDS}s"
docker compose ps -a --format 'table {{.Service}}\t{{.Status}}'Lage: Jemand hat die restart-Policies
„vereinheitlicht”. Seitdem kehrt up --wait nicht mehr
zurück (deshalb hier --wait-timeout 60), api startet nie.
Ziel: up --wait mit Exit 0 in wenigen Sekunden.
Zeitlimit: 8 min.
Erwartet (gekürzt):
Container notes-db-1 Healthy
Container notes-migrate-1 Started
Container notes-migrate-1 Waiting
timeout waiting for dependencies
Exit: 1 nach 62s
SERVICE STATUS
api Created
db Up About a minute (healthy)
migrate Restarting (0) 8 seconds ago
web Created
worker Created
Hinweis: Restarting (0) – ein Job, der
erfolgreich endet und trotzdem neu startet. Wann gilt er für
service_completed_successfully als fertig?
Lösung
docker compose logs --no-log-prefix migrate | grep -c 'migration complete'
grep -n 'restart:' compose.yamlErwartet (gekürzt, Zahlen weichen ab):
10
29: restart: unless-stopped
46: restart: unless-stopped
61: restart: unless-stopped
81: restart: unless-stopped
120: restart: unless-stopped
Zehnmal „migration complete” in einer Minute. Zeile 46 gehört zu
migrate. Zurück auf "no":
sed -i '' '46s#restart: unless-stopped#restart: "no"#' compose.yaml
SECONDS=0; docker compose up -d --wait; echo "Exit: $? nach ${SECONDS}s"
docker compose ps -a --format 'table {{.Service}}\t{{.Status}}'
docker compose down -vErwartet (gekürzt):
Container notes-migrate-1 Recreated
Container notes-migrate-1 Exited
Container notes-api-1 Healthy
Exit: 0 nach 4s
SERVICE STATUS
api Up 3 seconds (healthy)
db Up About a minute (healthy)
migrate Exited (0) 3 seconds ago
web Up 1 second (healthy)
worker Up 1 second
Warum? Mit unless-stopped startet Docker migrate nach
jedem Exit 0 neu, der Container erreicht nie dauerhaft „exited”, und api
wartet ewig. Einmal-Jobs bekommen restart: "no" – mit
Anführungszeichen, sonst liest YAML false (Tag 5).
Fortschritt speichern? Kostenlos registrieren
Runde 10: Rotation in falscher Reihenfolge
Diese Runde nutzt Secrets wie an Tag 10. Spielleitung: Secrets anlegen, Stack starten, dann „rotiert” ein Kollege das DB-Passwort nur in den Dateien:
rm -rf ~/compose-lab/tag15/runde10 && mkdir -p ~/compose-lab/tag15/runde10
cd ~/compose-lab/tag15/runde10
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag08/notes/." .
cp -R "$LAB/code/tag15/runde10/." .
printf '%s\n' lab-api-key-123 > secrets/api_key.txt
printf '%s\n' lab-db-pw-123 > secrets/db_password.txt
printf '%s\n' 'postgres://notes:lab-db-pw-123@db:5432/notes' > secrets/db_url.txt
chmod 644 secrets/*.txt
docker compose up -d --wait >/dev/null 2>&1; echo "Exit: $?"
sed -i '' 's/lab-db-pw-123/lab-db-pw-456/' secrets/db_password.txt secrets/db_url.txt
docker compose up -d --force-recreate --wait; echo "Exit: $?"
docker compose ps -a --format 'table {{.Service}}\t{{.Status}}'Lage: Nach der Rotation startet api nicht mehr. Die
Daten im Volume dürfen nicht verloren gehen, also kein
down -v. Ziel: Stack gesund mit dem neuen Passwort
lab-db-pw-456. Zeitlimit: 10 min.
Erwartet (gekürzt):
Exit: 0
Container notes-db-1 Healthy
Container notes-migrate-1 Error service "migrate" didn't complete successfully: exit 1
service "migrate" didn't complete successfully: exit 1
Exit: 1
SERVICE STATUS
api Created
db Up 2 seconds (healthy)
migrate Exited (1) 1 second ago
web Created
worker Created
Hinweis: Wann liest das Postgres-Image
POSTGRES_PASSWORD_FILE – und wo steht das Passwort
wirklich?
Lösung
docker compose logs --no-log-prefix migrate | tail -1 | grep -o 'password auth.*28P01)'
docker compose logs --no-log-prefix db | grep -i 'skipping'Erwartet:
password authentication failed for user \"notes\" (SQLSTATE 28P01)
PostgreSQL Database directory appears to contain a database; Skipping initialization
Das Secret ändert nur, was das Image bei leerem
Volume setzt. Das Passwort steht in der Datenbank selbst. Im
Container darf psql über den Unix-Socket ohne Passwort
(Standard-pg_hba.conf des Images), damit setzt du das
neue:
docker compose exec db psql -U notes -d notes \
-c "ALTER ROLE notes PASSWORD 'lab-db-pw-456'"
docker compose up -d --wait; echo "Exit: $?"
curl -s -w ' %{http_code}\n' -X POST localhost:8080/notes \
-H 'X-API-Key: lab-api-key-123' -H 'Content-Type: application/json' \
-d '{"text":"Runde 10 mit neuem Passwort"}'Erwartet (gekürzt):
ALTER ROLE
Container notes-migrate-1 Exited
Container notes-api-1 Healthy
Container notes-web-1 Healthy
Exit: 0
{"id":"430dfa84-…","text":"Runde 10 mit neuem Passwort"} 201
Warum? Ändert sich nur der Inhalt einer Secret-Datei, erzeugt
up -d keinen Container neu – deshalb hat der Kollege
--force-recreate gebraucht. Die richtige Reihenfolge (Tag
10): erst ALTER ROLE, dann die Secret-Dateien, dann die
Clients neu erzeugen. Der Befehl steht im Lab mit Klartext-Passwort in
der Shell-Historie; in Produktion nimmst du \password notes
in einer interaktiven psql-Sitzung. Lass die Runde für den
Kontrollpunkt stehen und räum erst danach ab.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
Wertung: Trag deine Punkte (0–2) pro Runde zusammen. Die Befehle zeigen, ob die reparierten Stände wirklich da sind.
R1 – Port nur lokal und per Variable:
cd ~/compose-lab/tag15
grep '127.0.0.1' runde01/compose.yamlErwartet:
- "127.0.0.1:${API_PORT:-8080}:8080"
- "127.0.0.1:${WEB_PORT:-3000}:3000"
test: ["CMD", "wget", "-qO-", "http://127.0.0.1:3000/healthz"]
test: ["CMD", "pg_isready", "-h", "127.0.0.1", "-U", "notes", "-d", "notes"]
R2 – depends_on in langer Form:
grep service_completed_successfully runde02/compose.yamlErwartet:
condition: service_completed_successfully
R3 – pg_isready fragt über TCP:
grep pg_isready runde03/compose.yamlErwartet:
test: ["CMD", "pg_isready", "-h", "127.0.0.1", "-U", "notes", "-d", "notes"]
R4 – Volume an /var/lib/postgresql:
grep 'pgdata:' runde04/compose.yamlErwartet:
- pgdata:/var/lib/postgresql
pgdata: {}
R5 – kein NOTES_API_KEY in der Shell:
echo "${NOTES_API_KEY:-leer}"Erwartet:
leer
R6 – kein compose.override.yaml:
ls runde06Erwartet:
README.md
compose.dev.yaml
compose.tools.yaml
compose.yaml
db
notes-api
notes-web
notes-worker
secrets
R7 – summarizer statt worker:
grep -E '^ (summarizer|worker):' runde07/compose.yamlErwartet:
summarizer:
R8 – Watch-Ziel /app/public:
grep 'target: /app' runde08/compose.yamlErwartet:
target: /app/public
target: /app/server.js
R9 – migrate ohne Neustart:
docker compose -f runde09/compose.yaml config --format json \
| jq '.services.migrate.restart'Erwartet:
"no"
R10 – neues Passwort im Secret, die API antwortet:
grep -c lab-db-pw-456 runde10/secrets/db_url.txt
curl -s -o /dev/null -w '%{http_code}\n' localhost:8080/notesErwartet:
1
200
Danach räumst du Runde 10 ab:
cd runde10
docker compose down -v| 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 eine
compose.yaml mit drei Desastern. Finde
alle drei zuerst nur mit Werkzeugen (up --wait,
ps, port, container inspect,
curl), erst dann darfst du die Datei lesen. Ziel:
up --wait mit Exit 0, api unter localhost:8080
erreichbar, worker ohne Neustarts.
Hinweis: Je ein Desaster zeigt sich im Health-Log,
im Zustand OOMKilled und in der Spalte
PORTS.
Lösung
Diagnose:
rm -rf ~/compose-lab/tag15/challenge && mkdir -p ~/compose-lab/tag15/challenge
cd ~/compose-lab/tag15/challenge
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag08/notes/." .
cp -R "$LAB/code/tag15/challenge/." .
docker compose up -d --wait --wait-timeout 60; echo "Exit: $?"
docker compose ps -a --format 'table {{.Service}}\t{{.Status}}\t{{.Ports}}'
docker container inspect --format '{{json .State.Health.Log}}' notes-web-1 \
| jq -r '.[-1].Output'
docker container inspect notes-worker-1 \
-f 'OOMKilled={{.State.OOMKilled}} Restarts={{.RestartCount}}'
curl -sS -m 3 localhost:8080/healthz; echo "curl: $?"Erwartet (gekürzt, Zahlen weichen ab):
Container notes-api-1 Healthy
Container notes-worker-1 Healthy
container notes-web-1 is unhealthy
Exit: 1
SERVICE STATUS PORTS
api Up 32 seconds (healthy) 8080/tcp
db Up 34 seconds (healthy) 5432/tcp
migrate Exited (0) 33 seconds ago
web Up 31 seconds (unhealthy) 127.0.0.1:3000->3000/tcp
worker Restarting (137) 4 seconds ago
OCI runtime exec failed: exec failed: unable to start container process: exec:
"curl": executable file not found in $PATH
OOMKilled=true Restarts=9
curl: (7) Failed to connect to localhost port 8080 after 0 ms: Couldn't connect to se…
curl: 7
Damit liegen alle drei offen: Der web-Healthcheck ruft
curl, das in node:26-alpine fehlt (Tag 5:
BusyBox-wget). Ein Speicherlimit von 8 MB tötet den
Python-Worker mit Exit 137 (Tag 9). Und api hat zwar
ports:, hängt aber nur am internen Netz
backend – Docker veröffentlicht dann still nichts (Tag 2).
Reparatur:
sed -i '' -e 's#"CMD", "curl", "-fsS",#"CMD", "wget", "-qO-",#' \
-e 's#memory: 8M#memory: 128M#' compose.yaml
sed -i '' '23s#networks: \[backend\]#networks: [frontend, backend]#' compose.yaml
grep -nE 'wget|memory|networks: \[frontend, backend\]' compose.yaml
docker compose up -d --wait; echo "Exit: $?"
docker compose ps -a --format 'table {{.Service}}\t{{.Status}}\t{{.Ports}}'
docker stats --no-stream --format '{{.Name}} {{.MemUsage}}' notes-worker-1
curl -s localhost:8080/healthz; echoErwartet (gekürzt, Werte weichen ab):
23: networks: [frontend, backend]
61: memory: 128M
87: test: ["CMD", "wget", "-qO-", "http://127.0.0.1:3000/healthz"]
Container notes-api-1 Recreate
Container notes-web-1 Recreate
Container notes-worker-1 Recreate
…
Exit: 0
SERVICE STATUS PORTS
api Up 2 seconds (healthy) 127.0.0.1:8080->8080/tcp
db Up 56 seconds (healthy) 5432/tcp
migrate Exited (0) 3 seconds ago
web Up 1 second (healthy) 127.0.0.1:3000->3000/tcp
worker Up 1 second
notes-worker-1 23.59MiB / 128MiB
ok
Der Worker braucht im Leerlauf rund 24 MiB; 128 MB ist der Wert aus Tag 9. Zum Schluss aufräumen:
docker compose down -v --rmi localErwartet (gekürzt, Namen und IDs weichen ab):
…
Image notes-api:dev Removed
Image notes-web:dev Removed
…
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Desaster-Drills eignen sich als Team-Gameday: rotierende Spielleitung, feste Zeitlimits, nach jeder Runde fünf Minuten „Wie hätte die CI das gefangen?“.
- Viele Runden fängt ein Lint-Schritt in der Pipeline: Ports ohne
127.0.0.1,depends_onin kurzer Form,pg_isreadyohne-h, Einmal-Jobs mit restart-Policy,…/postgresql/data– ein paarjq-Regeln auf der aufgelösten Datei. up --waitprüft Gesundheit, nicht Erreichbarkeit (Runde 1, Challenge). Ein Smoke-Test von außen gehört nach jedem Deploy dazu (Tag 13, Tag 14).- Automatisch geladene Dateien (
compose.override.yaml,.env) und Shell-Variablen machen Rechner unterschiedlich. In CI und auf Servern deshalb immer explizite-f-Listen und eine saubere Umgebung. - Passwort-Rotation ist ein Ablauf mit Reihenfolge, kein Dateitausch: erst in der Datenbank, dann im Secret-Speicher, dann die Clients – als Runbook, geübt.