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 – ohnecompose.yaml. - Erlaubt sind Anhang A,
docker compose … --helpund die offizielle Doku, nicht die Tage 1–15. Die fertige Lösung liegt incode/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, Diensteapi,worker,web, gebaut aus den drei Ordnern; worker und web erreichen api unterhttp://api:8080. - Ports nur auf
127.0.0.1, perAPI_PORT/WEB_PORTänderbar (Standard 8080/3000). - Netze
frontendundbackend,backendintern; worker nur imbackend, web nur imfrontend. - 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"}'; echoErwartet (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 NXDOMAINErwartet (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 -1Erwartet (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 -1Erwartet:
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
dbmitpostgres:18.6-alpine, Benutzer und Datenbanknotes, Passwort aus.env(Pflicht), Volumepgdataam richtigen Pfad, nur imbackend, kein Port. - api speichert in Postgres. Die Tabelle legt ein Job
migratean (notes-api migrate). - Nach
down -vstartetup -d --waitzuverlä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.sqllegt die Rollenotes_ro(NOLOGIN, Mitglied vonpg_read_all_data) an und kommt perconfigs:in den Container. - Die Rolle existiert auch in deinem bestehenden Volume – die Notiz aus Übung 2 bleibt.
- worker fragt alle
WORKER_INTERVALSekunden (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 -1Erwartet (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' >> .envIn 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.sqlDas 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.sqlErwartet (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) undbackup(schreibtbackup/notes.sql), beide im Profiltools, beide imbackend.- Nach
down -vstellst 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 -lErwartet (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.sqlErwartet (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
EOFOben in compose.yaml, direkt nach
name: notes:
include:
- compose.tools.yamlrun 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.yamlstartet web aus der Stagebuildmitnode --watchundNODE_ENV=development– nur mit-f.- Mit
docker compose -f compose.yaml -f compose.dev.yaml watchist eine Änderung annotes-web/public/index.htmlohne Rebuild nach wenigen Sekunden sichtbar. - Ohne
-fläuft web danach wieder im Prod-Image als Usernode.
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_ENVErwartet: 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_ENVErwartet (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
EOFIn 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.jsonDie 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 Stagefinal, mitVERSION=TAG; worker und web heißen analog. /versionliefert den Tag.- Dienst
api-testim Profiltestbaut die Stagetest(Build = Testlauf).
Prüfung:
TAG=2.0 docker compose build
docker image ls notes-api:2.0Erwartet (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:testCompose 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.50CPU, 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/*.txtx-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.txtAchtung:
pids_limit: 100nebendeploy.resources.limitsbricht in Compose 5.6.0 ab:can't set distinct values on 'pids_limit' and 'deploy.resources.limits.pids'. Das Limit gehört dann nachlimits.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 Diensttestsmit, der im Netz einen Rauchtest fährt: healthz von api und web, POST ohne Key → 401, POST über web → 201.ci.shstartet 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; echoErwartet:
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.
- Was unterscheidet
depends_on: [db]voncondition: service_healthy? - Warum prüft der Healthcheck von db mit
pg_isready -h 127.0.0.1? - Wozu dient die
.envnebencompose.yaml, und wer schlägt sie? - Du änderst
POSTGRES_PASSWORDund machstup -d. Was passiert mit dem Passwort in der Datenbank? - Warum ist
compose.override.yamlim Team riskant, und was ist die Alternative? up -d --waitmeldet Exit 0. Welche zwei Dinge sind damit nicht bewiesen?- Warum wirken
uid,gidundmodebei einem Secret ausfile:nicht? - Was bewirkt
internal: truean einem Netz – und was passiert mitports:eines Dienstes, der nur dort hängt? - Warum gehören
configs:undsecrets:mitfile:-Quelle beim Deploy auf einen anderen Docker-Host auf den Prüfstand? - Warum braucht jede CI-Pipeline einen eigenen Projektnamen und ein
down -vimtrap?
Lösungen
- Die kurze Form wartet nur, bis der Container gestartet ist; mit
service_healthystartet der Dienst erst, wenn der Healthcheck von dbhealthymeldet (Tag 5). - Während der Initialisierung lauscht ein temporärer Server nur auf
dem Unix-Socket; ohne
-hwäre db zu früh gesund, Clients über TCP bekämenconnection refused(Tag 5, Tag 15). - 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). - Nichts: Das Image setzt das Passwort nur bei leerem Volume. Clients
mit dem neuen Wert scheitern mit
28P01, bis duALTER ROLEausführst (Tag 10, Tag 15). - Compose lädt sie ohne
-fautomatisch und still, also verhält sich derselbe Befehl auf jedem Rechner anders. Besser:compose.dev.yamlnur mit-f(Tag 7, Tag 15). - 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).
- 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). - 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). - 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). - 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 localErwartet (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.