Zum Inhalt springen
Trainingslager IT-Trainingslager

Anhang B: Abschlussprüfung

Ziel: Das Buch ohne Anleitung anwenden: aus der nackten Demo-Anwendung in acht Übungen einen gesunden, gehärteten, CI-tauglichen Stack bauen, dazu ein kurzer Wissensteil. · Dauer: ca. 150 min · Voraussetzung: Tag 15

Spielregeln

  • Jede Übung nennt Anforderungen und eine Prüfung aus einzelnen Befehlen. Bestanden ist sie, wenn jeder Befehl das Erwartete zeigt. Die Lösung liest du erst danach.
  • Die Übungen bauen aufeinander auf und laufen alle in ~/compose-lab/anhb. Du beginnst mit der Demo-Anwendung von Tag 0 – ohne compose.yaml.
  • Erlaubt sind Anhang A, docker compose … --help und die offizielle Doku, nicht die Tage 1–15. Die fertige Lösung liegt in code/anhb/loesung/.
  • Bestanden hast du mit acht bestandenen Prüfungen und mindestens 8 von 10 Punkten im Wissensteil.
source ~/compose-lab/setup/env.sh
docker compose -p notes down
mkdir -p ~/compose-lab/anhb && cd ~/compose-lab/anhb
cp -R "$LAB/code/notes/." .

IDs, Größen und Zeiten in den Ausgaben weichen bei dir ab.

Übung 1: Drei Dienste, zwei Netze

Teil A (Tag 1, 2, 4). Schreib compose.yaml:

  • Projekt notes, Dienste api, worker, web, gebaut aus den drei Ordnern; worker und web erreichen api unter http://api:8080.
  • Ports nur auf 127.0.0.1, per API_PORT/WEB_PORT änderbar (Standard 8080/3000).
  • Netze frontend und backend, backend intern; worker nur im backend, web nur im frontend.
  • Der API-Key kommt aus .env; fehlt er, bricht Compose mit einer Meldung ab.

Prüfung:

docker compose up -d --build --wait
docker compose ps --format '{{.Service}} {{.Ports}}'

Erwartet (gekürzt): drei Dienste, Ports nur auf 127.0.0.1.

 Container notes-api-1 Healthy
 Container notes-web-1 Healthy
api 127.0.0.1:8080->8080/tcp
web 127.0.0.1:3000->3000/tcp
worker

POST über web:

curl -s -X POST localhost:3000/api/notes -H 'Content-Type: application/json' \
  -d '{"text":"Anhang B"}'; echo

Erwartet (gekürzt, ID weicht ab):

{"id":"e03888b4-73c1-418c-a7ee-5fe873fac1c7","text":"Anhang B"}

backend ist intern:

docker network ls --filter name=notes_ --format '{{.Name}} internal={{.Internal}}'

Erwartet:

notes_backend internal=true
notes_frontend internal=false

worker kommt nicht ins Internet, web sieht worker nicht:

docker compose exec worker python -c \
  "import urllib.request as u; u.urlopen('https://example.com', timeout=3)" 2>&1 \
  | tail -1
docker compose exec web nslookup worker 2>&1 | grep -m1 NXDOMAIN

Erwartet (gekürzt):

urllib.error.URLError: <urlopen error [Errno -3] Temporary failure in name resolution>
** server can't find worker.localdomain: NXDOMAIN

Ohne .env bricht Compose ab:

docker compose --env-file /dev/null up --dry-run 2>&1 | tail -1

Erwartet (gekürzt):

error while interpolating services.worker.environment.NOTES_API_KEY: required variable
NOTES_API_KEY is missing a value: NOTES_API_KEY fehlt (.env)

Lösung

cat > compose.yaml <<'EOF'
# compose.yaml – Anhang B, Übung 1
name: notes

services:
  api:
    build: notes-api
    environment:
      NOTES_API_KEY: ${NOTES_API_KEY:?NOTES_API_KEY fehlt (.env)}
    ports:
      - "127.0.0.1:${API_PORT:-8080}:8080"
    networks: [frontend, backend]

  worker:
    build: notes-worker
    environment:
      NOTES_API_URL: http://api:8080
      NOTES_API_KEY: ${NOTES_API_KEY:?NOTES_API_KEY fehlt (.env)}
    networks: [backend]
    depends_on: [api]

  web:
    build: notes-web
    environment:
      NOTES_API_URL: http://api:8080
      NOTES_API_KEY: ${NOTES_API_KEY:?NOTES_API_KEY fehlt (.env)}
    ports:
      - "127.0.0.1:${WEB_PORT:-3000}:3000"
    networks: [frontend]
    depends_on: [api]

networks:
  frontend: {}
  backend:
    internal: true
EOF
docker compose --env-file /dev/null up --dry-run 2>&1 | tail -1

Erwartet:

error while interpolating services.worker.environment.NOTES_API_KEY: required variable
NOTES_API_KEY is missing a value: NOTES_API_KEY fehlt (.env)

api hängt an beiden Netzen und ist die einzige Brücke. --env-file /dev/null ersetzt die .env durch eine leere Datei – so prüfst du Pflichtvariablen, ohne die echte Datei anzufassen.

Fortschritt speichern? Kostenlos registrieren

Übung 2: Postgres und Startreihenfolge

Teil A und B (Tag 3, 5). Erweitere die Datei:

  • Dienst db mit postgres:18.6-alpine, Benutzer und Datenbank notes, Passwort aus .env (Pflicht), Volume pgdata am richtigen Pfad, nur im backend, kein Port.
  • api speichert in Postgres. Die Tabelle legt ein Job migrate an (notes-api migrate).
  • Nach down -v startet up -d --wait zuverlässig mit Exit 0; worker und web warten auf eine gesunde api, web hat einen eigenen Healthcheck.

Prüfung: Leeres Volume, dann hochfahren:

docker compose down -v
docker compose up -d --wait
docker compose ps -a migrate --format '{{.State}} {{.ExitCode}}'

Erwartet (gekürzt):

 Container notes-db-1 Healthy
 Container notes-migrate-1 Exited
 Container notes-api-1 Healthy
 Container notes-web-1 Healthy
exited 0

Eine Notiz überlebt down und up:

curl -s -X POST localhost:8080/notes -H 'X-API-Key: lab-api-key-123' \
  -H 'Content-Type: application/json' -d '{"text":"Anhang B persistent"}'; echo
docker compose down
docker compose up -d --wait
curl -s localhost:8080/notes | jq -r '.[].text'

Erwartet (gekürzt):

{"id":"51dee9cd-d766-4242-9297-b39a8c954a3a","text":"Anhang B persistent"}
…
 Container notes-db-1 Healthy
 Container notes-migrate-1 Exited
 Container notes-api-1 Healthy
 Container notes-web-1 Healthy
Anhang B persistent

Volume und Ports der db:

docker compose config --format json | jq '.services.db.volumes'
docker compose ps db --format '{{.Ports}}'

Erwartet:

[
  {
    "type": "volume",
    "source": "pgdata",
    "target": "/var/lib/postgresql",
    "volume": {}
  }
]
5432/tcp

Lösung

Die Dienste aus Übung 1 bekommen depends_on in langer Form und restart: unless-stopped; neu sind migrate und db (vollständig in code/anhb/loesung/compose.yaml, dort schon mit den Folgeübungen):

  api:
    build: notes-api
    environment:
      NOTES_API_KEY: ${NOTES_API_KEY:?NOTES_API_KEY fehlt (.env)}
      NOTES_DB_URL: "postgres://notes:\
        ${POSTGRES_PASSWORD:?POSTGRES_PASSWORD fehlt (.env)}@db:5432/notes"
    # … ports, networks wie in Übung 1 …
    depends_on:
      db:
        condition: service_healthy
      migrate:
        condition: service_completed_successfully
    restart: unless-stopped

  migrate:
    build: notes-api
    command: ["migrate"]
    environment:
      NOTES_DB_URL: "postgres://notes:\
        ${POSTGRES_PASSWORD:?POSTGRES_PASSWORD fehlt (.env)}@db:5432/notes"
    networks: [backend]
    depends_on:
      db:
        condition: service_healthy
    restart: "no"
    healthcheck:
      disable: true

  # worker und web: depends_on api mit condition: service_healthy,
  # restart: unless-stopped; web zusätzlich:
  #   healthcheck:
  #     test: ["CMD", "wget", "-qO-", "http://127.0.0.1:3000/healthz"]
  #     interval: 10s
  #     timeout: 2s
  #     start_period: 10s
  #     start_interval: 1s

  db:
    image: postgres:18.6-alpine
    environment:
      POSTGRES_USER: notes
      POSTGRES_DB: notes
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?POSTGRES_PASSWORD fehlt (.env)}
    volumes:
      - pgdata:/var/lib/postgresql
    networks: [backend]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "pg_isready", "-h", "127.0.0.1", "-U", "notes", "-d", "notes"]
      interval: 5s
      timeout: 3s
      retries: 10
      start_period: 30s
      start_interval: 1s

volumes:
  pgdata: {}

Jede Zeile hat ihren Tag: -h 127.0.0.1 gegen den temporären Init-Server (5), restart: "no" für den Job (5, Tag 15 Runde 9), /var/lib/postgresql für Postgres 18 (3).

Fortschritt speichern? Kostenlos registrieren

Übung 3: Konfiguration ohne Datenverlust

Teil A (Tag 4). Erweitere die Datei:

  • Ein Init-Skript db/init/10-readonly.sql legt die Rolle notes_ro (NOLOGIN, Mitglied von pg_read_all_data) an und kommt per configs: in den Container.
  • Die Rolle existiert auch in deinem bestehenden Volume – die Notiz aus Übung 2 bleibt.
  • worker fragt alle WORKER_INTERVAL Sekunden (Standard 10), bei dir alle 5.

Prüfung:

docker compose exec db ls /docker-entrypoint-initdb.d
docker compose exec db psql -U notes -d notes -tAc \
  "SELECT rolname FROM pg_roles WHERE rolname = 'notes_ro'"

Erwartet:

10-readonly.sql
notes_ro

Die Notiz aus Übung 2 ist noch da, worker fragt alle 5 s:

curl -s localhost:8080/notes | jq -r '.[].text'
docker compose logs worker | grep 'worker started' | tail -1

Erwartet (gekürzt):

Anhang B persistent
worker-1  | worker started, api=http://api:8080, interval=5s

Lösung

mkdir -p db/init
cat > db/init/10-readonly.sql <<'EOF'
-- Läuft nur beim ersten Start mit leerem Volume (docker-entrypoint-initdb.d)
CREATE ROLE notes_ro NOLOGIN;
GRANT pg_read_all_data TO notes_ro;
EOF
printf '\nWORKER_INTERVAL=5\n' >> .env

In compose.yaml:

  worker:
    environment:
      # … wie bisher …
      INTERVAL: ${WORKER_INTERVAL:-10}

  db:
    # … wie bisher …
    configs:
      - source: db_init
        target: /docker-entrypoint-initdb.d/10-readonly.sql

configs:
  db_init:
    file: ./db/init/10-readonly.sql

Das Init-Skript läuft nur bei leerem Volume. Statt down -v (Notiz weg) spielst du es einmal von Hand ein:

docker compose up -d --wait
docker compose exec -T db psql -U notes -d notes < db/init/10-readonly.sql

Erwartet (gekürzt):

 Container notes-db-1 Recreated
 Container notes-worker-1 Recreated
 …
CREATE ROLE
GRANT ROLE

Fortschritt speichern? Kostenlos registrieren

Übung 4: Backup und Restore

Teil A und B (Tag 3, 7). Lege Werkzeuge in eine eigene Datei compose.tools.yaml, die compose.yaml per include einbindet:

  • psql (Client aus dem Postgres-Image) und backup (schreibt backup/notes.sql), beide im Profil tools, beide im backend.
  • Nach down -v stellst du die Notiz aus dem Backup wieder her.

Prüfung:

docker compose up -d --wait
docker compose run --rm psql -c 'SELECT 1'
docker compose ps -aq psql | wc -l

Erwartet (gekürzt): psql antwortet, und kein psql-Container bleibt übrig.

 ?column? 
----------
        1
(1 row)

0

Backup mit der Notiz:

docker compose run --rm backup
grep -c 'Anhang B persistent' backup/notes.sql

Erwartet (gekürzt):

1

Nach down -v ist alles leer, nach dem Restore wieder da:

docker compose down -v
docker compose up -d --wait
curl -s localhost:8080/notes; echo
docker compose run --rm -T psql -q < backup/notes.sql >/dev/null
curl -s localhost:8080/notes | jq -r '.[].text'

Erwartet (gekürzt):

…
[]
Anhang B persistent

Auch die Rolle notes_ro ist zurück:

docker compose exec db psql -U notes -d notes -tAc \
  "SELECT rolname FROM pg_roles WHERE rolname = 'notes_ro'"

Erwartet:

notes_ro

Lösung

cat > compose.tools.yaml <<'EOF'
# compose.tools.yaml – Werkzeuge, per include eingebunden
services:
  psql:
    image: postgres:18.6-alpine
    profiles: [tools]
    entrypoint: ["psql"]
    environment:
      PGHOST: db
      PGUSER: notes
      PGDATABASE: notes
      PGPASSWORD: ${POSTGRES_PASSWORD:?POSTGRES_PASSWORD fehlt (.env)}
    networks: [backend]
    depends_on:
      db:
        condition: service_healthy
  backup:
    extends: psql
    entrypoint: ["sh", "-c", "pg_dump --clean --if-exists > /backup/notes.sql"]
    volumes:
      - ./backup:/backup
networks:
  backend:
    internal: true
EOF

Oben in compose.yaml, direkt nach name: notes:

include:
  - compose.tools.yaml

run startet Dienste mit Profil auch ohne --profile. Nach down -v legt das Init-Skript die Rolle wieder an, migrate die leere Tabelle, und das Backup mit --clean --if-exists ersetzt sie samt Inhalt.

Fortschritt speichern? Kostenlos registrieren

Übung 5: Entwickeln mit watch

Teil B (Tag 6, 7):

  • compose.dev.yaml startet web aus der Stage build mit node --watch und NODE_ENV=development – nur mit -f.
  • Mit docker compose -f compose.yaml -f compose.dev.yaml watch ist eine Änderung an notes-web/public/index.html ohne Rebuild nach wenigen Sekunden sichtbar.
  • Ohne -f läuft web danach wieder im Prod-Image als User node.

Prüfung: Starte im zweiten Terminal docker compose -f compose.yaml -f compose.dev.yaml watch und warte auf Watch enabled. Dann hier:

sed -i '' 's#<h1>notes</h1>#<h1>notes dev</h1>#' notes-web/public/index.html
sleep 5
curl -s localhost:3000/ | grep '<h1>'
docker compose exec web printenv NODE_ENV

Erwartet: Die Änderung ist ohne Rebuild sichtbar, der Dev-Modus aktiv.

  <h1>notes dev</h1>
development

watch beendest du mit Strg+C. Dann zurück zur Prod-Variante:

sed -i '' 's#<h1>notes dev</h1>#<h1>notes</h1>#' notes-web/public/index.html
docker compose up -d --build --wait
docker compose exec web id -u
docker compose exec web printenv NODE_ENV

Erwartet (gekürzt):

 Image notes-web Built
 Container notes-web-1 Recreated
 …
 Container notes-web-1 Healthy
1000
production

Lösung

cat > compose.dev.yaml <<'EOF'
# compose.dev.yaml – Entwicklung, nur per -f zusammen mit compose.yaml
services:
  web:
    build:
      target: build
    command: ["node", "--watch", "server.js"]
    environment:
      NODE_ENV: development
EOF

In compose.yaml bei web (ohne watch wirkungslos):

    develop:
      watch:
        - action: sync
          path: ./notes-web/public
          target: /app/public
        - action: sync+restart
          path: ./notes-web/server.js
          target: /app/server.js
        - action: rebuild
          path: ./notes-web/package.json

Die Datei heißt bewusst nicht compose.override.yaml (Tag 15, Runde 6). Ohne explizites image: taggt der Dev-Build notes-web mit dem Build-Stage – deshalb --build beim Zurückwechseln.

Fortschritt speichern? Kostenlos registrieren

Übung 6: Bauen mit Versionen

Teil B (Tag 8):

  • api und migrate nutzen ein Image ${COMPOSE_PROJECT_NAME}-api:${TAG:-dev} aus der Stage final, mit VERSION = TAG; worker und web heißen analog.
  • /version liefert den Tag.
  • Dienst api-test im Profil test baut die Stage test (Build = Testlauf).

Prüfung:

TAG=2.0 docker compose build
docker image ls notes-api:2.0

Erwartet (gekürzt, ID und Größe weichen ab):

 Image notes-worker:2.0 Built
 Image notes-api:2.0 Built
 Image notes-web:2.0 Built
IMAGE           ID             DISK USAGE   CONTENT SIZE   EXTRA
notes-api:2.0   fa5046f5bf77       16.4MB          4.5MB
TAG=2.0 docker compose up -d --wait
curl -s localhost:8080/version; echo
docker compose ps -a migrate --format '{{.Image}}'

Erwartet (gekürzt):

 Container notes-api-1 Recreated
 …
 Container notes-api-1 Healthy
 …
2.0
notes-api:2.0

Die Tests laufen als Build:

docker compose --profile test build api-test; echo "Exit: $?"

Erwartet (gekürzt):

#13 [test 1/1] RUN --mount=type=cache,target=/go/pkg/mod … go test ./...
 …
 Image notes-api:test Built
Exit: 0

Lösung

x-api-build: &api-build
  context: notes-api
  target: final
  args:
    VERSION: ${TAG:-dev}

services:
  api:
    build: *api-build
    image: ${COMPOSE_PROJECT_NAME}-api:${TAG:-dev}
    # …
  migrate:
    build: *api-build
    image: ${COMPOSE_PROJECT_NAME}-api:${TAG:-dev}
    # …
  worker:
    build: notes-worker
    image: ${COMPOSE_PROJECT_NAME}-worker:${TAG:-dev}
    # …
  web:
    build: notes-web
    image: ${COMPOSE_PROJECT_NAME}-web:${TAG:-dev}
    # …
  api-test:
    profiles: [test]
    build:
      context: notes-api
      target: test
    image: ${COMPOSE_PROJECT_NAME}-api:test

Compose stellt COMPOSE_PROJECT_NAME für die Interpolation bereit, auch wenn er aus name: stammt. Der Anker hält beide Build-Definitionen gleich.

Fortschritt speichern? Kostenlos registrieren

Übung 7: Härten und Secrets

Teil C (Tag 9, 10). Für api (und migrate, soweit sinnvoll):

  • Dateisystem read-only, keine Capabilities, no-new-privileges.
  • Höchstens 0.50 CPU, 64 MB Speicher, 100 Prozesse.
  • API-Key und DB-URL kommen als Secret-Dateien aus secrets/, nicht aus der Umgebung.

Prüfung:

docker compose up -d --wait
docker compose config --format json \
  | jq '.services.api | {read_only, cap_drop, security_opt}'
docker compose config --format json | jq '.services.api.deploy.resources.limits'

Erwartet (gekürzt):

{
  "read_only": true,
  "cap_drop": [
    "ALL"
  ],
  "security_opt": [
    "no-new-privileges:true"
  ]
}
{
  "cpus": 0.5,
  "memory": "67108864",
  "pids": 100
}

Key aus der Datei, nicht aus der Umgebung:

docker compose logs api | grep -o 'source=[a-z]*'
docker compose config --format json | jq '.services.api.environment'

Erwartet:

source=file
{
  "NOTES_API_KEY_FILE": "/run/secrets/api_key",
  "NOTES_DB_URL_FILE": "/run/secrets/db_url"
}

POST mit Key:

curl -s -o /dev/null -w '%{http_code}\n' -X POST localhost:8080/notes \
  -H 'X-API-Key: lab-api-key-123' -H 'Content-Type: application/json' \
  -d '{"text":"gehärtet"}'

Erwartet:

201

Lösung

mkdir -p secrets
printf '%s\n' lab-api-key-123 > secrets/api_key.txt
printf '%s\n' 'postgres://notes:lab-db-pw-123@db:5432/notes' > secrets/db_url.txt
chmod 644 secrets/*.txt
x-hardening: &hardening
  read_only: true
  cap_drop: [ALL]
  security_opt: ["no-new-privileges:true"]

services:
  api:
    # … build, image …
    <<: *hardening
    environment:
      NOTES_API_KEY_FILE: /run/secrets/api_key
      NOTES_DB_URL_FILE: /run/secrets/db_url
    secrets: [api_key, db_url]
    deploy:
      resources:
        limits:
          cpus: "0.50"
          memory: 64M
          pids: 100
    # … ports, networks, depends_on, restart …
  migrate:
    # … build, image, command …
    <<: *hardening
    environment:
      NOTES_DB_URL_FILE: /run/secrets/db_url
    secrets: [db_url]

secrets:
  api_key:
    file: ./secrets/api_key.txt
  db_url:
    file: ./secrets/db_url.txt

Achtung: pids_limit: 100 neben deploy.resources.limits bricht in Compose 5.6.0 ab: can't set distinct values on 'pids_limit' and 'deploy.resources.limits.pids'. Das Limit gehört dann nach limits.pids.

notes-api ist ein statisches Binary in scratch und braucht kein beschreibbares Dateisystem. secrets/ steht in .gitignore; die Dateien sind Bind-Mounts, die Rechte vom Mac gelten, daher 644 im Lab (Tag 10).

Fortschritt speichern? Kostenlos registrieren

Übung 8: Compose in CI

Teil D (Tag 13):

  • compose.ci.yaml (nur mit -f) entfernt alle veröffentlichten Ports und bringt einen Dienst tests mit, der im Netz einen Rauchtest fährt: healthz von api und web, POST ohne Key → 401, POST über web → 201.
  • ci.sh startet mit eigenem Projektnamen, liefert den Exit-Code der Tests und räumt immer auf – Container, Volumes und eigene Images –, auch bei Fehlern.
  • Dein Stack auf Port 8080 läuft dabei weiter.

Prüfung:

bash ci.sh; echo "Exit: $?"
NOTES_API_KEY=lab-api-key-456 bash ci.sh; echo "Exit: $?"

Erwartet (gekürzt): grün, dann rot.

 Container ci-…-tests-run-… Created
✔ api healthz
✔ web healthz
✔ POST ohne Key
✔ POST über web
Exit: 0
…
✔ api healthz
✔ web healthz
✔ POST ohne Key
✘ POST über web (401)
Exit: 1

Keine CI-Reste, dein Stack läuft weiter:

docker ps -a --filter label=com.docker.compose.project --format '{{.Names}}' \
  | grep -c '^ci-'
docker image ls --format '{{.Repository}}' | grep -c '^ci-'
curl -s localhost:8080/healthz; echo

Erwartet:

0
0
ok

Lösung

mkdir -p tests
cat > tests/smoke.sh <<'EOF'
#!/bin/sh
# smoke.sh – Rauchtest im CI-Netz, Ausgabe ✔/✘, Exit-Code = Zahl der Fehler
fail=0
check() {
  if [ "$2" = "$3" ]; then echo "✔ $1"; else echo "✘ $1 ($2)"; fail=$((fail + 1)); fi
}
code() { curl -s -o /dev/null -w '%{http_code}' "$@"; }
check "api healthz" "$(curl -s http://api:8080/healthz)" ok
check "web healthz" "$(code http://web:3000/healthz)" 200
check "POST ohne Key" "$(code -X POST -H 'Content-Type: application/json' \
  -d '{"text":"ci"}' http://api:8080/notes)" 401
check "POST über web" "$(code -X POST -H 'Content-Type: application/json' \
  -d '{"text":"ci"}' http://web:3000/api/notes)" 201
exit "$fail"
EOF
cat > compose.ci.yaml <<'EOF'
# compose.ci.yaml – CI, nur per -f zusammen mit compose.yaml
services:
  api:
    ports: !reset []
  web:
    ports: !reset []
  tests:
    image: curlimages/curl:8.23.0
    profiles: [ci]
    entrypoint: ["/bin/sh", "/tests/smoke.sh"]
    volumes:
      - ./tests:/tests:ro
    networks: [frontend]
    depends_on:
      api:
        condition: service_healthy
      web:
        condition: service_healthy
EOF
cat > ci.sh <<'EOF'
#!/usr/bin/env bash
# ci.sh – Pipeline lokal: eigener Projektname, Aufräumen per trap, Exit-Code der Tests
set -euo pipefail
cd "$(dirname "$0")"
P="ci-$$"
dc() { docker compose -p "$P" -f compose.yaml -f compose.ci.yaml "$@"; }
cleanup() {
  dc down -v --remove-orphans >/dev/null 2>&1 || true
  docker image ls --format '{{.Repository}}:{{.Tag}}' | grep "^$P-" \
    | xargs -r docker rmi >/dev/null 2>&1 || true
}
trap cleanup EXIT
dc up -d --build --wait --quiet-pull >/dev/null 2>&1
dc run --rm tests
EOF
shellcheck ci.sh tests/smoke.sh; echo "Exit: $?"
bash ci.sh; echo "Exit: $?"

Erwartet (gekürzt):

Exit: 0
 Container ci-…-tests-run-… Created
✔ api healthz
✔ web healthz
✔ POST ohne Key
✔ POST über web
Exit: 0

Drei Stolpersteine: Ohne profiles: [ci] startet up --wait auch tests, und dessen Exit 0 lässt --wait scheitern. Weil die Images ${COMPOSE_PROJECT_NAME}-… heißen, baut jeder Lauf eigene ci-…-Images – die räumt cleanup mit ab. Und NOTES_API_KEY=… bash ci.sh beweist die Gegenprobe: web schickt einen Key, den api (aus der Secret-Datei) nicht kennt.

Fortschritt speichern? Kostenlos registrieren

Wissensteil

Je Frage ein Punkt, Antwort in ein bis zwei Sätzen.

  1. Was unterscheidet depends_on: [db] von condition: service_healthy?
  2. Warum prüft der Healthcheck von db mit pg_isready -h 127.0.0.1?
  3. Wozu dient die .env neben compose.yaml, und wer schlägt sie?
  4. Du änderst POSTGRES_PASSWORD und machst up -d. Was passiert mit dem Passwort in der Datenbank?
  5. Warum ist compose.override.yaml im Team riskant, und was ist die Alternative?
  6. up -d --wait meldet Exit 0. Welche zwei Dinge sind damit nicht bewiesen?
  7. Warum wirken uid, gid und mode bei einem Secret aus file: nicht?
  8. Was bewirkt internal: true an einem Netz – und was passiert mit ports: eines Dienstes, der nur dort hängt?
  9. Warum gehören configs: und secrets: mit file:-Quelle beim Deploy auf einen anderen Docker-Host auf den Prüfstand?
  10. Warum braucht jede CI-Pipeline einen eigenen Projektnamen und ein down -v im trap?

Lösungen

  1. Die kurze Form wartet nur, bis der Container gestartet ist; mit service_healthy startet der Dienst erst, wenn der Healthcheck von db healthy meldet (Tag 5).
  2. Während der Initialisierung lauscht ein temporärer Server nur auf dem Unix-Socket; ohne -h wäre db zu früh gesund, Clients über TCP bekämen connection refused (Tag 5, Tag 15).
  3. Sie liefert Werte für die Interpolation von ${VAR} in der Datei, nicht für den Container. Eine gleichnamige Variable in der Shell gewinnt (Tag 4, Tag 15).
  4. Nichts: Das Image setzt das Passwort nur bei leerem Volume. Clients mit dem neuen Wert scheitern mit 28P01, bis du ALTER ROLE ausführst (Tag 10, Tag 15).
  5. Compose lädt sie ohne -f automatisch und still, also verhält sich derselbe Befehl auf jedem Rechner anders. Besser: compose.dev.yaml nur mit -f (Tag 7, Tag 15).
  6. Dass die Ports erreichbar sind und dass die Anwendung fachlich funktioniert (etwa die Tabelle existiert) – dafür braucht es einen Test von außen (Tag 13, Tag 15).
  7. Compose bindet die Datei per Bind-Mount ein; Besitzer und Rechte kommen vom Host. Laut Doku setzt Compose die drei nur bei der Quelle environment: um (Tag 10).
  8. Dienste im Netz erreichen einander, aber nichts außerhalb; ein Dienst nur in einem internen Netz wird nicht veröffentlicht, ports: bleibt ohne Wirkung (Tag 2, Tag 15).
  9. Die Quelle wird auf dem Docker-Host aufgelöst, der den Container startet; der Mac-Pfad existiert auf dem Server nicht. Deshalb content:/environment: oder Dateien auf dem Server (Tag 14).
  10. Sonst teilen sich parallele Läufe Container, Netze, Volumes und Images, und Reste eines abgebrochenen Laufs verfälschen den nächsten (Tag 13).

Zum Schluss aufräumen:

docker compose down -v --rmi local

Erwartet (gekürzt, Namen und IDs weichen ab):

…
 Image notes-api:2.0 Removed
 Image notes-api:dev Removed
…

Bestanden? Dann betreibst du mehrere Container als ein System, das mit einem Befehl startet, sich selbst prüft und überall gleich läuft – und du findest die Fehler in den Compose-Dateien der anderen.