Tag 6: Entwickeln mit compose watch
Ziel: Code ändern, speichern, Ergebnis sehen – ohne
docker compose up --buildvon Hand, mit einem Dev-Target für web. · Dauer: ca. 60 min · Voraussetzung: Tag 5
Briefing
develop.watchbeschreibt 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 watchstartet den Stack und beobachtet die Pfade;docker compose up --watchmacht dasselbe und zeigt zusätzlich die Logs.- Für
.dockerignoregilt auch beim Beobachten: Was nicht ins Image darf, wird auch nicht synchronisiert. compose.override.yamlnebencompose.yamllädt Compose automatisch. Darin läuft web im Build-Stage mitnode --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-workerStarte in einem zweiten Terminal (gleicher Ordner) den Beobachter und lass ihn offen:
cd ~/compose-lab/tag06 && docker compose watchErwartet (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 -2Erwartet (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__.pyFortschritt 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/srcwatch 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/publicErwartet (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.htmlFortschritt 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=notesErwartet (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.txtErwartet:
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 -2Erwartet (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.jsFortschritt 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.mdErwartet:
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 %1Erwartet:
<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 %1Erwartet:
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.yamlErwartet (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' ' '; echoErwartet:
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.txtErwartet:
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.txtErwartet:
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 %1Erwartet (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, undnode_modulesvom 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;
developignorieren sie teilweise – vorher prüfen. .dockerignoreist auch eine Sicherheitsgrenze für watch: Schlüssel,.envund Zertifikate dürfen weder ins Image noch per sync in einen Container.