Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 6: Entwickeln mit compose watch

Ziel: Code ändern, speichern, Ergebnis sehen – ohne docker compose up --build von Hand, mit einem Dev-Target für web. · Dauer: ca. 60 min · Voraussetzung: Tag 5

Briefing

  • develop.watch beschreibt pro Dienst, was bei einer Dateiänderung passiert: rebuild (Image neu bauen, Container ersetzen), sync (Datei in den laufenden Container kopieren), sync+restart (kopieren, dann Container neu starten).
  • docker compose watch startet den Stack und beobachtet die Pfade; docker compose up --watch macht dasselbe und zeigt zusätzlich die Logs.
  • Für .dockerignore gilt auch beim Beobachten: Was nicht ins Image darf, wird auch nicht synchronisiert.
  • compose.override.yaml neben compose.yaml lädt Compose automatisch. Darin läuft web im Build-Stage mit node --watch.
 notes-api/**        ──rebuild──────► api     (neues Image, neuer Container)
 notes-worker/**     ──rebuild──────► worker
 notes-web/public/   ──sync─────────► web:/app/public
 notes-web/server.js ──sync+restart─► web:/app/server.js
 notes-web/src/, package.json ──rebuild──► web

Drill 1: rebuild für api und worker

source ~/compose-lab/setup/env.sh
docker compose -p notes down
mkdir -p ~/compose-lab/tag06 && cd ~/compose-lab/tag06
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag05/notes/." .

Ergänze bei api und worker jeweils einen Block develop (am Ende des Dienstes):

  api:
    # … wie an Tag 5 …
    develop:
      watch:
        - action: rebuild
          path: ./notes-api

  worker:
    # … wie an Tag 5 …
    develop:
      watch:
        - action: rebuild
          path: ./notes-worker

Starte in einem zweiten Terminal (gleicher Ordner) den Beobachter und lass ihn offen:

cd ~/compose-lab/tag06 && docker compose watch

Erwartet (gekürzt, Build-Ausgabe weggelassen):

 Image notes-api Built
 Image notes-worker Built
 Image notes-web Built
 Container notes-db-1 Healthy
 Container notes-migrate-1 Exited
 Container notes-api-1 Healthy
 Container notes-web-1 Started
Watch enabled

Zurück im ersten Terminal: eine Änderung an notes-api.

curl -s localhost:8080/healthz
sed -i '' 's#fmt.Fprintln(w, "ok")#fmt.Fprintln(w, "ok (Tag 6)")#' notes-api/main.go
sleep 10
curl -s localhost:8080/healthz
docker compose ps -a --format 'table {{.Service}}\t{{.Status}}'

Unter Linux heißt es sed -i ohne ''. Erwartet (gekürzt, Zeiten weichen bei dir ab):

ok
ok (Tag 6)
SERVICE   STATUS
api       Up 2 seconds (healthy)
db        Up 2 minutes (healthy)
migrate   Exited (0) 1 second ago
web       Up 11 seconds (healthy)
worker    Up 2 minutes

Im zweiten Terminal:

Rebuilding service(s) ["api"] after changes were detected...
service(s) ["api"] successfully built
 Container notes-api-1 Recreate
 Container notes-api-1 Recreated
 Container notes-api-1 Started

Nach etwa drei Sekunden lief der neue Container – der Go-Build kam fast komplett aus dem Cache. migrate lief dabei wieder mit, denn api hängt von ihm ab (Tag 5). Dasselbe für worker:

sed -i '' 's#print(f"summary: #print(f"Zusammenfassung: #' \
  notes-worker/src/notes_worker/__init__.py
sleep 12
docker compose logs worker | tail -2

Erwartet (gekürzt):

worker-1  | worker started, api=http://api:8080, interval=10s
worker-1  | Zusammenfassung: 0 notes, 0 words

Zurückbauen (watch baut dabei erneut):

sed -i '' 's#"ok (Tag 6)"#"ok"#' notes-api/main.go
sed -i '' 's#print(f"Zusammenfassung: #print(f"summary: #' \
  notes-worker/src/notes_worker/__init__.py

Fortschritt speichern? Kostenlos registrieren

Drill 2: sync ins Prod-Image

Jetzt web. Ergänze bei web:

  web:
    # … wie an Tag 5 …
    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
        - action: rebuild
          path: ./notes-web/src

watch liest die Datei nur beim Start: Im zweiten Terminal Ctrl+C, dann wieder docker compose watch. web läuft noch mit dem Prod-Image aus Tag 5 – als User node, /app gehört root:

docker compose exec web sh -c 'id; ls -ld /app/public /app/public/index.html'
sed -i '' 's#<h1>notes</h1>#<h1>notes (watch)</h1>#' notes-web/public/index.html
sleep 5
curl -s localhost:3000/ | grep '<h1>'
echo "hallo aus watch" > notes-web/public/hallo.txt
sleep 5
docker compose exec web ls -ln /app/public
rm notes-web/public/hallo.txt
sleep 5
docker compose exec web ls /app/public

Erwartet (gekürzt):

uid=1000(node) gid=1000(node) groups=1000(node)
drwxr-xr-x    2 root     root          4096 Oct 29 20:23 /app/public
-rwxr-xr-x    1 root     root           273 Oct 29 20:23 /app/public/index.html
  <h1>notes (watch)</h1>
-rw-r--r--    1 1000     1000            16 Oct 29 20:48 hallo.txt
-rwxr-xr-x    1 1000     1000           283 Oct 29 20:48 index.html
hallo.txt
index.html

Im zweiten Terminal:

Syncing service "web" after 1 changes were detected
rm: can't remove '/app/public/hallo.txt': Permission denied
… level=warning msg="Error handling changed files: deleting paths in …: exit code 1"

Halb funktioniert ist die gefährlichste Variante: Neue und geänderte Dateien kommen an (Compose kopiert sie über die Docker-API und übergibt sie an UID 1000), aber Löschen führt Compose mit rm als Container-User aus – und node darf im Ordner von root nichts löschen. Die Doku verlangt deshalb, dass der USER das Ziel beschreiben darf. Stell index.html zurück:

sed -i '' 's#<h1>notes (watch)</h1>#<h1>notes</h1>#' notes-web/public/index.html

Fortschritt speichern? Kostenlos registrieren

Drill 3: Dev-Target per compose.override.yaml

Statt das Prod-Image aufzuweichen, läuft web beim Entwickeln im Stage build des Dockerfiles: root, alle Dev-Abhängigkeiten, Quellcode in /app.

cat > compose.override.yaml <<'EOF'
# compose.override.yaml – Entwicklung (Tag 6), wird automatisch geladen
services:
  web:
    build:
      target: build
    command: ["node", "--watch", "server.js"]
    environment:
      NODE_ENV: development
EOF
docker compose config --format json \
  | jq -c '.services.web | {target: .build.target, command, env: .environment.NODE_ENV}'
docker compose ls --filter name=notes

Erwartet (Pfade weichen ab):

{"target":"build","command":["node","--watch","server.js"],"env":"development"}
NAME                STATUS              CONFIG FILES
notes               running(4)          /Users/du/compose-lab/tag06/compose.yaml,/User…

Compose führt beide Dateien zusammen; Details der Regeln an Tag 7. Im zweiten Terminal Ctrl+C. Erst ohne Build starten:

docker compose up -d --wait >/dev/null 2>&1
docker compose exec web id -un
docker compose up -d --wait --build >/dev/null 2>&1
docker compose exec web sh -c 'id -un; ls /app; cat /proc/1/cmdline | tr "\0" " "'
echo
docker image ls --filter reference=notes-web --format '{{.Repository}} {{.Size}}'

Erwartet (gekürzt):

node
root
dist
node_modules
package-lock.json
package.json
public
server.js
src
node --watch server.js
notes-web 280MB

Die Falle in der ersten Zeile: Ohne --build baut Compose nur, wenn das Image fehlt. web lief mit neuem Befehl, aber im alten Prod-Image. Beachte auch: Das Dev-Image heißt ebenfalls notes-web und ersetzt das Prod-Image – eigene Tags gibt es an Tag 8. Starte docker compose watch im zweiten Terminal neu; es baut beim Start selbst.

Fortschritt speichern? Kostenlos registrieren

Drill 4: sync, sync+restart, rebuild

echo "hallo aus watch" > notes-web/public/hallo.txt
sleep 4; curl -s localhost:3000/hallo.txt
rm notes-web/public/hallo.txt
sleep 4; curl -s -o /dev/null -w 'hallo.txt nach rm: %{http_code}\n' \
  localhost:3000/hallo.txt

Erwartet:

hallo aus watch
hallo.txt nach rm: 404

Als root klappt auch das Löschen. Jetzt server.js (Aktion sync+restart):

docker inspect -f '{{.State.StartedAt}}' notes-web-1
sed -i '' 's#notes-web listening on#notes-web (dev) listening on#' notes-web/server.js
sleep 8
docker inspect -f '{{.State.StartedAt}}' notes-web-1
docker compose logs web | tail -2

Erwartet (gekürzt, Zeiten weichen ab):

2026-10-29T20:49:10.28…Z
2026-10-29T20:49:46.49…Z
web-1  | SIGTERM received, shutting down
web-1  | notes-web (dev) listening on :3000

Der Container wurde neu gestartet. Mit node --watch würde ein reines sync genügen – live geprüft: Node meldet Restarting 'server.js' und startet nur den Prozess neu, der Container läuft weiter. sync+restart funktioniert dagegen mit jedem Programm. Zuletzt src/: Den Code bündelt esbuild beim Build nach dist/, deshalb rebuild:

sed -i '' 's#^load();$#console.log("notes-web Tag 6");\nload();#' notes-web/src/app.js
sleep 8
curl -s localhost:3000/assets/app.js | grep -o 'notes-web Tag 6'

Erwartet:

notes-web Tag 6

Zurückbauen:

sed -i '' 's#notes-web (dev) listening on#notes-web listening on#' notes-web/server.js
sed -i '' '/^console.log("notes-web Tag 6");$/d' notes-web/src/app.js

Fortschritt speichern? Kostenlos registrieren

Drill 5: .dockerignore und ignore

echo "GEHEIM=lab-api-key-123" > notes-web/public/.env.local
echo "# Notiz" > notes-web/public/NOTIZ.md
sleep 5
docker compose exec web ls -A /app/public
grep -E '^\*\*/\.env\*|^\*\.md' notes-web/.dockerignore
rm notes-web/public/.env.local notes-web/public/NOTIZ.md

Erwartet:

NOTIZ.md
index.html
*.md
**/.env*

.env.local passt auf **/.env* und bleibt draußen – gut so. NOTIZ.md wurde synchronisiert: *.md gilt nur in der Wurzel des Build-Kontexts (notes-web/), für alle Ebenen braucht es **/*.md (wie im ersten Buch). Weitere Muster nur für watch setzt ignore: in der Regel, z. B. ignore: [node_modules/]; Pfade dort sind relativ zu path.

Fortschritt speichern? Kostenlos registrieren

Drill 6: initial_sync

Was passiert mit Änderungen, während watch nicht läuft? Im zweiten Terminal Ctrl+C.

sed -i '' 's#<h1>notes</h1>#<h1>notes (offline geändert)</h1>#' \
  notes-web/public/index.html
docker compose watch --no-up >/dev/null 2>&1 &
sleep 8; curl -s localhost:3000/ | grep '<h1>'; kill %1

Erwartet:

  <h1>notes</h1>

Der Container hat die alte Datei. Ergänze vorübergehend in der sync-Regel für public die Zeile initial_sync: true und wiederhole den Block (die Seite steht noch auf „offline geändert”):

docker compose config -q; echo "Exit: $?"
docker compose watch --no-up >/dev/null 2>&1 &
sleep 8; curl -s localhost:3000/ | grep '<h1>'; kill %1

Erwartet:

Exit: 0
  <h1>notes (offline geändert)</h1>

Mit initial_sync gleicht Compose beim Start ab, was unter path liegt. Nimm die Zeile wieder heraus und stell index.html zurück (<h1>notes</h1>).

Fortschritt speichern? Kostenlos registrieren

Drill 7: watch oder up --watch

docker compose watch --help | grep -E -- '--no-up|--prune'

Erwartet:

      --no-up     Do not build & start services before watching
      --prune     Prune dangling images on rebuild (default true)

Starte im zweiten Terminal docker compose up --watch, warte bis „Watch enabled” und beende mit Ctrl+C. Dann dasselbe mit docker compose watch. Im ersten Terminal jeweils:

docker compose ps -a --format 'table {{.Service}}\t{{.Status}}'

Erwartet nach up --watch und Ctrl+C (gekürzt):

 Compose Stopping Gracefully Stopping... press Ctrl+C again to force
 Container notes-web-1 Stopped
 Container notes-api-1 Stopped
 Container notes-db-1 Stopped
SERVICE   STATUS
api       Exited (0) Less than a second ago
db        Exited (0) Less than a second ago
…

Erwartet nach watch und Ctrl+C:

SERVICE   STATUS
api       Up 10 seconds (healthy)
db        Up 12 seconds (healthy)
migrate   Exited (0) 11 seconds ago
web       Up 9 seconds (healthy)
worker    Up 9 seconds

up --watch verhält sich wie up im Vordergrund: Logs aller Dienste, Ctrl+C stoppt den Stack. watch zeigt nur seine eigenen Meldungen, der Stack läuft nach Ctrl+C weiter. --prune entfernt nach einem Rebuild die alten, namenlosen Images.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

cd ~/compose-lab/tag06
docker compose up -d --build --wait
ls compose.override.yaml

Erwartet (gekürzt):

…
 Container notes-db-1 Healthy
 Container notes-api-1 Healthy
 Container notes-web-1 Healthy
 Container notes-worker-1 Healthy
compose.override.yaml

Sechs Watch-Regeln:

docker compose config --format json | jq '[.services[].develop.watch[]?] | length'

Erwartet:

6

web läuft im build-Stage als root und mit node --watch:

docker compose exec web id -u
docker compose exec web cat /proc/1/cmdline | tr '\0' ' '; echo

Erwartet:

0
node --watch server.js

Jetzt watch in einem zweiten Terminal starten: docker compose watch --no-up. Dann hier eine Datei anlegen:

echo kontrollpunkt > notes-web/public/kp.txt
sleep 5
curl -s localhost:3000/kp.txt

Erwartet:

kontrollpunkt

Und wieder löschen:

rm notes-web/public/kp.txt
sleep 5
curl -s -o /dev/null -w '%{http_code}\n' localhost:3000/kp.txt

Erwartet:

404

watch im zweiten Terminal beendest du mit Strg+C. Den vollständigen Stand findest du in code/tag06/notes/.

Challenge

Mach das Prod-Image von web so watch-tauglich, dass für public/ auch das Löschen funktioniert – ohne Dev-Target. Prüfe es mit abgeschaltetem Override und stell danach alles zurück.

Hinweis: Die Doku zu watch empfiehlt COPY --chown; compose.override.yaml lädt Compose nur, solange sie so heißt.

Lösung

Im Stage prod von notes-web/Dockerfile eine Zeile ändern (Lösung in code/tag06/challenge/notes-web/Dockerfile):

COPY --chown=node:node public/ ./public/
cd ~/compose-lab/tag06
cp notes-web/Dockerfile /tmp/Dockerfile.orig
cp "$LAB/code/tag06/challenge/notes-web/Dockerfile" notes-web/Dockerfile
docker build --check notes-web 2>&1 | tail -1
mv compose.override.yaml compose.override.yaml.aus
docker compose up -d --wait --build web >/dev/null 2>&1
docker compose exec web sh -c 'id -un; ls -ld /app/public'
docker compose watch --no-up >/dev/null 2>&1 &
sleep 4
echo "hallo" > notes-web/public/hallo.txt
sleep 4; curl -s localhost:3000/hallo.txt
rm notes-web/public/hallo.txt
sleep 4; curl -s -o /dev/null -w 'nach rm: %{http_code}\n' localhost:3000/hallo.txt
kill %1

Erwartet (gekürzt):

Check complete, no warnings found.
node
drwxr-xr-x    2 node     node          4096 Oct 29 20:52 /app/public
hallo
nach rm: 404

Mit --chown gehört der Ordner node, also darf watch auch löschen. Für Produktion ist das ein Rückschritt: Ein Angreifer im Container könnte die ausgelieferten Seiten verändern. Deshalb bleibt im Buch das Prod-Image unverändert und Entwicklung läuft im Dev-Target. Zurückbauen:

mv compose.override.yaml.aus compose.override.yaml
cp /tmp/Dockerfile.orig notes-web/Dockerfile
docker compose up -d --build --wait >/dev/null 2>&1; echo "Exit: $?"

Erwartet:

Exit: 0

Zum Abschluss des Tages: docker compose down.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Dev-Container gehören nie in eine Registry für Produktion. Trenne Image-Namen oder Tags (Tag 8) und baue in CI nur das Ziel prod/final.
  • Bind-Mounts des ganzen Quellordners sind die ältere Alternative zu sync; auf macOS sind sie langsamer, und node_modules vom Mac passt nicht zu Linux-Binärdateien.
  • Teams mit vielen Diensten starten lokal nur den Teil, an dem sie arbeiten (docker compose watch api), den Rest als fertige Images – oder per Profile (Tag 7).
  • Remote-Entwicklungsumgebungen (Dev Containers, Codespaces, Gitpod) nutzen dieselbe Compose-Datei; develop ignorieren sie teilweise – vorher prüfen.
  • .dockerignore ist auch eine Sicherheitsgrenze für watch: Schlüssel, .env und Zertifikate dürfen weder ins Image noch per sync in einen Container.