Zum Inhalt springen
Trainingslager IT-Trainingslager

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/rundeNN darüber. Dein Stand von Tag 14 bleibt unberührt.
  • Alle Runden laufen als Projekt notes. Jede Lösung endet mit docker 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/." .
ls

Erwartet:

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 infinity

Lage: 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 up startet den beim ersten Mal nur angelegten Container – ohne Portfreigabe (8080/tcp, kein ->). --wait prü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.yaml

Erwartet:

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; echo

Erwartet (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 -v

Fortschritt 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-80

Erwartet (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.yaml

Erwartet:

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_healthy
docker 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 -v

Erwartet (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.yaml

Erwartet (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 -v

Erwartet (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 -9

Erwartet (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 -v

Erwartet (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 -v

Erwartet (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 -v

Fortschritt 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 -v

Erwartet (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 watch

Lage: 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.yaml

Im 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.yaml

Erwartet (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 -v

Erwartet (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.yaml

Erwartet:

      - "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.yaml

Erwartet:

        condition: service_completed_successfully

R3 – pg_isready fragt über TCP:

grep pg_isready runde03/compose.yaml

Erwartet:

      test: ["CMD", "pg_isready", "-h", "127.0.0.1", "-U", "notes", "-d", "notes"]

R4 – Volume an /var/lib/postgresql:

grep 'pgdata:' runde04/compose.yaml

Erwartet:

      - 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 runde06

Erwartet:

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.yaml

Erwartet:

  summarizer:

R8 – Watch-Ziel /app/public:

grep 'target: /app' runde08/compose.yaml

Erwartet:

          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/notes

Erwartet:

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; echo

Erwartet (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 local

Erwartet (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_on in kurzer Form, pg_isready ohne -h, Einmal-Jobs mit restart-Policy, …/postgresql/data – ein paar jq-Regeln auf der aufgelösten Datei.
  • up --wait prü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.