Tag 10: Secrets in Compose und Rotation
Ziel: API-Key, DB-Passwort und DB-URL kommen als Dateien unter
/run/secrets/statt aus.env, auch Postgres und die Werkzeuge lesen sie dort, und beide Werte lassen sich ohne Rebuild rotieren. · Dauer: ca. 75 min · Voraussetzung: Tag 9
Briefing
- Die Grundlagen kennst du aus „Dockerfiles zum Anfassen” (Tag 13/14):
Build- vs. Laufzeit-Secrets,
_FILE-Variablen, der Wrapper für notes-web,uid/gid/mode. Heute geht es um den ganzen Stack mit Datenbank. - Postgres kennt die
_FILE-Konvention selbst:POSTGRES_PASSWORD_FILE(laut Image-Doku auch fürPOSTGRES_USER,POSTGRES_DB,POSTGRES_INITDB_ARGS). - Eine Secret-Quelle ist eine Datei (
file:) oder eine Variable auf deinem Rechner (environment:). Mit der Härtung aus Tag 9 bleibt nur eine davon übrig (Drill 6). - Ein geändertes Secret merkt Compose nicht. Rotieren heißt: Wert
tauschen, dann gezielt
--force-recreate– beim DB-Passwort in der richtigen Reihenfolge.
secrets/api_key.txt ─────► /run/secrets/api_key ─────► api, worker, web (Wrapper)
secrets/db_password.txt ─► /run/secrets/db_password ─► db (init), psql, backup
secrets/db_url.txt ──────► /run/secrets/db_url ──────► api, migrate
Umgebung im Container: nur …_FILE=/run/secrets/…, nie der Wert
Drill 1: Wo die Secrets heute stehen
source ~/compose-lab/setup/env.sh
docker compose -p notes down
mkdir -p ~/compose-lab/tag10 && cd ~/compose-lab/tag10
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag09/notes/." .
docker compose up -d --build --wait >/dev/null 2>&1; echo "Exit: $?"
for s in worker web db; do
echo "== $s"
docker compose exec "$s" env | grep -E 'NOTES_API_KEY|POSTGRES_PASSWORD'
doneErwartet:
Exit: 0
== worker
NOTES_API_KEY=lab-api-key-123
== web
NOTES_API_KEY=lab-api-key-123
== db
POSTGRES_PASSWORD=lab-db-pw-123
api läuft in scratch. Der Hilfscontainer aus Tag 9 darf
ihre Umgebung nicht lesen – anders als jeder, der
docker inspect aufrufen darf:
docker run --rm --label lab=compose-lab --pid container:notes-api-1 alpine:3.24 \
sh -c 'tr "\0" "\n" < /proc/1/environ | grep NOTES'
docker inspect -f '{{json .Config.Env}}' notes-api-1 | jq -r '.[]' | grep NOTESErwartet:
sh: can't open /proc/1/environ: Permission denied
Der zweite Befehl listet dagegen alle NOTES_…-Variablen
samt Werten, den API-Key eingeschlossen. Ohne Capabilities (der
Hilfscontainer hat kein SYS_PTRACE) bleibt
/proc/1/environ eines fremden Users zu.
docker inspect dagegen liest die Umgebung aus der
Container-Konfiguration, im Klartext, für jeden mit Zugriff auf den
Docker-Socket. Dazu kommt docker compose config (Tag 4),
das die Werte aus .env einsetzt.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Secret-Dateien und Postgres
printf '%s' 'lab-api-key-123' > secrets/api_key.txt
printf '%s' 'lab-db-pw-123' > secrets/db_password.txt
printf '%s' 'postgres://notes:lab-db-pw-123@db:5432/notes' > secrets/db_url.txt
chmod 644 secrets/*.txt
wc -c secrets/*.txtErwartet:
15 secrets/api_key.txt
13 secrets/db_password.txt
44 secrets/db_url.txt
72 total
printf '%s' schreibt ohne Zeilenumbruch.
644 ist nötig, weil eine file:-Quelle ein
Bind-Mount ist und UID 70 bzw. 65532 die Datei lesen müssen (Buch 1, Tag
14). secrets/ steht seit Tag 0 in
.gitignore.
In compose.yaml bekommt db statt
POSTGRES_PASSWORD die Datei, und am Ende kommen drei
Top-Level-Secrets dazu:
db:
<<: *hardening
image: postgres:18.6-alpine
user: "70:70"
environment:
POSTGRES_USER: notes
POSTGRES_DB: notes
POSTGRES_PASSWORD_FILE: /run/secrets/db_password
secrets: [db_password]
# … volumes, tmpfs, configs usw. wie an Tag 9
secrets:
npmrc:
file: ./secrets/npmrc
api_key:
file: ./secrets/api_key.txt
db_password:
file: ./secrets/db_password.txt
db_url:
file: ./secrets/db_url.txtapi und migrate lesen die URL aus der Datei. Die DB-URL steckt
komplett im Secret, der zusammengesetzte
${POSTGRES_PASSWORD…}-String aus Tag 5 entfällt:
api:
# …
environment:
NOTES_API_KEY: ${NOTES_API_KEY:?NOTES_API_KEY fehlt (.env)} # bis Drill 3
NOTES_DB_URL_FILE: /run/secrets/db_url
secrets: [db_url]
migrate:
# …
environment:
NOTES_DB_URL_FILE: /run/secrets/db_url
secrets: [db_url]POSTGRES_PASSWORD_FILE liest das Image nur bei einem
leeren Datenverzeichnis (Tag 3). Damit du siehst, dass
das Passwort wirklich aus der Datei kommt, startest du mit leerem
Volume:
docker compose down -v >/dev/null 2>&1
docker compose up -d --wait 2>&1 | grep -E 'Volume .* Created|Healthy|Exited'
docker compose logs db | grep 'init process complete'
docker compose logs migrate api | grep -E 'migration|store'
docker compose exec db env | grep POSTGRESErwartet (gekürzt, Zeiten weichen bei dir ab):
Volume notes_pgdata Created
Container notes-db-1 Healthy
Container notes-migrate-1 Exited
Container notes-api-1 Healthy
Container notes-web-1 Healthy
Container notes-worker-1 Healthy
db-1 | PostgreSQL init process complete; ready for start up.
migrate-1 | time=… level=INFO msg="migration complete" table=notes
api-1 | time=… level=INFO msg="store ready" store=postgres
POSTGRES_USER=notes
POSTGRES_DB=notes
POSTGRES_PASSWORD_FILE=/run/secrets/db_password
Eine Falle beim Prüfen: im db-Container fragt
Postgres über 127.0.0.1 gar nicht nach dem Passwort.
docker compose exec db sh -c 'PGPASSWORD=falsch psql -h 127.0.0.1 -U notes -d notes \
-Atc "SELECT 1"; grep -E "^host" "$PGDATA/pg_hba.conf"'Erwartet:
1
host all all 127.0.0.1/32 trust
host all all ::1/128 trust
host replication all 127.0.0.1/32 trust
host replication all ::1/128 trust
host all all all scram-sha-256
Lokal gilt trust (Standard von initdb),
über das Netz scram-sha-256. Ob das Passwort stimmt, zeigt
nur ein Zugriff aus einem anderen Container – wie migrate oben oder
psql in Drill 4.
Fortschritt speichern? Kostenlos registrieren
Drill 3: API-Key aus der Datei, .env ohne Secrets
api, worker und web bekommen den Key als Secret. notes-web kennt kein
_FILE, dafür gibt es den Wrapper aus Buch 1:
api:
environment:
NOTES_API_KEY_FILE: /run/secrets/api_key
NOTES_DB_URL_FILE: /run/secrets/db_url
secrets: [api_key, db_url]
worker:
environment:
NOTES_API_URL: http://api:8080
NOTES_API_KEY_FILE: /run/secrets/api_key
INTERVAL: ${WORKER_INTERVAL:-10}
secrets: [api_key]
web:
# notes-web kennt kein _FILE: der Wrapper liest das Secret beim Start
entrypoint: ["/bin/sh", "-c"]
command: ['NOTES_API_KEY="$$(cat /run/secrets/api_key)" exec node server.js']
environment:
NOTES_API_URL: http://api:8080
secrets: [api_key]compose.dev.yaml setzt für web ein eigenes
command:. Der Entrypoint sh -c aus
compose.yaml gilt dort weiter, aus
["node", "--watch", "server.js"] würde
sh -c node … – web startete im Test in einer
Neustartschleife. Also auch dort der Wrapper:
# entrypoint ["/bin/sh", "-c"] aus compose.yaml gilt weiter: Wrapper mit --watch
command:
- NOTES_API_KEY="$$(cat /run/secrets/api_key)" exec node --watch server.jsJetzt fliegen die Secrets aus .env; dort bleiben nur
optionale Werte:
cat > .env <<'EOF'
# .env – nur noch Interpolation (Ports, TAG). Secrets liegen ab Tag 10 in secrets/.
# API_PORT=8080
# WEB_PORT=3000
# TAG=dev
EOF
docker compose up -d --wait 2>&1 | grep -E 'Recreated' | sort -u
docker compose logs api | grep 'api key'
curl -s -X POST localhost:3000/api/notes -H 'Content-Type: application/json' \
-d '{"text":"Tag 10 mit Secrets"}'; echo
curl -s -o /dev/null -w '%{http_code}\n' -X POST localhost:8080/notes \
-H "X-API-Key: $(cat secrets/api_key.txt)" -d '{"text":"direkt"}'Erwartet (gekürzt, IDs weichen ab):
Container notes-api-1 Recreated
Container notes-web-1 Recreated
Container notes-worker-1 Recreated
api-1 | time=… level=INFO msg="api key loaded" source=file
{"id":"b3bfd69a-…","text":"Tag 10 mit Secrets"}
201
Dass up ohne Fehler durchläuft, beweist: Keine
Compose-Datei interpoliert mehr NOTES_API_KEY oder
POSTGRES_PASSWORD – sonst hätte ${…:?…}
abgebrochen. .env.example aus dem Begleitcode enthält
entsprechend nur noch Kommentare.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Die Werkzeuge und das doppelte Secret
psql und backup in
compose.tools.yaml hatten PGPASSWORD aus
.env. Jetzt lesen sie das Secret. "$$@" reicht
die Argumente von run an psql weiter, das letzte
Listenelement psql wird dabei zu $0:
# compose.tools.yaml – Werkzeuge (Stand Tag 10), per include eingebunden
services:
psql:
image: postgres:18.6-alpine
profiles: [tools]
# Passwort aus dem Secret; "$$@" reicht die Argumente von run an psql weiter
entrypoint:
- sh
- -c
- 'PGPASSWORD="$$(cat /run/secrets/db_password)" exec psql "$$@"'
- psql
environment:
PGHOST: db
PGUSER: notes
PGDATABASE: notes
secrets: [db_password]
networks: [backend]
depends_on:
db:
condition: service_healthy
backup:
extends: psql
entrypoint:
- sh
- -c
- >-
PGPASSWORD="$$(cat /run/secrets/db_password)"
exec pg_dump --clean --if-exists > /backup/notes.sql
volumes:
- ./backup:/backup
networks:
backend:
internal: true
secrets:
db_password:
file: ./secrets/db_password.txtDie Datei deklariert db_password selbst, damit sie für
sich allein gültig bleibt – wie das Netz backend an Tag
7.
docker compose run --rm psql -Atc 'SELECT current_user'
docker compose run --rm --entrypoint psql -e PGPASSWORD=falsch psql -Atc 'SELECT 1'
docker compose run --rm backup && head -1 backup/notes.sqlErwartet (gekürzt, Adressen weichen ab):
notes
psql: error: connection to server at "db" (172.22.0.2), port 5432 failed: FATAL:
password authentication failed for user "notes"
-- PostgreSQL database dump
Über das Netz prüft Postgres das Passwort: aus dem Secret klappt es,
falsch nicht. Die doppelte Deklaration von
db_password akzeptiert Compose 5.6 ohne Meldung. Auch eine
abweichende Deklaration im eingebundenen File (im Test:
anderer Dateiname) meldete Compose nicht, es galt still die aus
compose.yaml – halte beide gleich.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Was jetzt noch sichtbar ist
for s in worker web db; do
echo "== $s"; docker compose exec "$s" env | grep -E 'NOTES_|POSTGRES_'
done
docker compose exec web sh -c 'tr "\0" "\n" < /proc/1/environ | grep -c NOTES_API_KEY='
docker run --rm --label lab=compose-lab --pid container:notes-api-1 alpine:3.24 \
grep /run/secrets /proc/1/mountinfo | cut -d' ' -f4,5
grep -c 'lab-' .env
docker compose logs | grep -cE 'lab-(api-key|db-pw)'Erwartet:
== worker
NOTES_API_URL=http://api:8080
NOTES_API_KEY_FILE=/run/secrets/api_key
== web
NOTES_API_URL=http://api:8080
== db
POSTGRES_USER=notes
POSTGRES_DB=notes
POSTGRES_PASSWORD_FILE=/run/secrets/db_password
1
/compose-lab/tag10/secrets/api_key.txt /run/secrets/api_key
/compose-lab/tag10/secrets/db_url.txt /run/secrets/db_url
0
0
- Die Umgebung der Container enthält nur noch Pfade. Ausnahme ist web:
Der Wrapper setzt den Key in die Umgebung von PID 1 (
1), Kindprozesse erben ihn. mountinfoverrät, woher die Datei kommt: ein Bind-Mount aus deinem Home (unter Colima relativ zur Freigabe), read-only.- Logs und
.envsind sauber.
Und die beiden Befehle mit Docker-Zugriff:
docker inspect -f '{{json .Config.Env}} {{range .Mounts}}{{.Source}} {{end}}' \
notes-api-1
docker compose config | grep -cE 'lab-(api-key|db-pw)'Was du siehst: In der Umgebung von api steht kein Key mehr, nur noch
NOTES_API_KEY_FILE und NOTES_DB_URL_FILE mit
Pfaden unter /run/secrets/. Als Mount-Quellen erscheinen
die Dateien unter secrets/. grep -c findet in
der Ausgabe von config keinen Lab-Wert und gibt
0 aus – die Werte stehen nur noch in den Dateien.
Zusammengefasst:
| Wo | Tag 9 (.env) |
Tag 10 (secrets:) |
|---|---|---|
docker inspect, exec … env |
Wert | nur Pfad |
docker compose config |
Wert | nur Pfad der Quelldatei |
Logs, .env |
– | – |
exec … cat /run/secrets/… |
– | Wert |
Die letzte Zeile bleibt: Wer docker exec darf, liest
jedes Secret.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Quelle environment und read_only
Statt einer Datei kann ein Secret aus einer Variablen deiner Shell
kommen – praktisch, wenn ein Passwort-Manager sie setzt. Eine
Zusatzdatei stellt api_key vorübergehend um:
cat > compose.envsecret.yaml <<'EOF'
# compose.envsecret.yaml – nur für Tag 10, Drill 6
secrets:
api_key: !override
environment: NOTES_API_KEY
EOF
NOTES_API_KEY=lab-api-key-123 docker compose -f compose.yaml -f compose.envsecret.yaml \
up -d --wait worker 2>&1 | grep worker-1 | sort -uErwartet (gekürzt):
Container notes-worker-1 Healthy
Container notes-worker-1 Running
Nichts passiert: Eine geänderte Quelle eines Secrets ist für Compose keine Konfigurationsänderung des Dienstes, worker läuft unverändert weiter. Also erzwingen:
NOTES_API_KEY=lab-api-key-123 docker compose -f compose.yaml -f compose.envsecret.yaml \
up -d --wait --no-deps --force-recreate worker 2>&1 | tail -1
docker compose ps -a worker --format 'table {{.Service}}\t{{.Status}}'Erwartet:
cannot create secret "notes_api_key" in read-only service worker: `file` is the sole
supported option
SERVICE STATUS
worker Created
Ein environment:-Secret ist kein Bind-Mount: Compose
kopiert die Datei beim Start in das Dateisystem des Containers – und das
ist seit Tag 9 schreibgeschützt. Zum Vergleich ohne
read_only:
cat >> compose.envsecret.yaml <<'EOF'
services:
worker:
read_only: false
EOF
NOTES_API_KEY=lab-api-key-123 docker compose -f compose.yaml -f compose.envsecret.yaml \
up -d --wait --no-deps --force-recreate worker >/dev/null 2>&1
docker compose exec worker \
sh -c 'ls -ln /run/secrets; grep -c /run/secrets /proc/1/mountinfo'Erwartet (gekürzt):
total 4
-r--r--r-- 1 0 0 15 Oct 29 22:40 api_key
0
Eine Datei im Container (root, 0444, der Standard laut
Referenz), kein Mount. Nur hier wirken uid,
gid und mode (Buch 1). Für gehärtete Dienste
bleibt nur file:. Zurück zum Stand des Tages:
rm compose.envsecret.yaml
docker compose up -d --wait --no-deps --force-recreate worker 2>&1 | grep HealthyErwartet:
Container notes-worker-1 Healthy
Achtung: Wer Secrets auf einem Server per
environment:liefern will (Tag 14), braucht für diese Diensteread_only: falseoder eine Secret-Datei auf dem Server.
Fortschritt speichern? Kostenlos registrieren
Drill 7: API-Key rotieren
printf '%s' 'lab-api-key-456' > secrets/api_key.txt
docker compose exec worker cat /run/secrets/api_key; echo
for k in lab-api-key-123 lab-api-key-456; do
printf '%s → ' "$k"
curl -s -o /dev/null -w '%{http_code}\n' -X POST localhost:8080/notes \
-H "X-API-Key: $k" -d '{"text":"vor dem Neustart"}'
done
docker compose up -d --wait 2>&1 | grep -E '(api|worker|web)-1 Running' | sort -uErwartet:
lab-api-key-456
lab-api-key-123 → 201
lab-api-key-456 → 401
Container notes-api-1 Running
Container notes-web-1 Running
Container notes-worker-1 Running
Der Bind-Mount zeigt den neuen Wert sofort, aber die Programme lesen
ihn nur beim Start – api akzeptiert weiter den alten Key. Und
up -d sieht keinen Grund zum Neuerzeugen, der Inhalt der
Datei gehört nicht zur Konfiguration. Also gezielt die drei Dienste, die
den Key lesen, ohne Build:
docker compose up -d --force-recreate --no-build --wait api worker web 2>&1 \
| grep -E 'Recreated' | sort -u
for k in lab-api-key-123 lab-api-key-456; do
printf '%s → ' "$k"
curl -s -o /dev/null -w '%{http_code}\n' -X POST localhost:8080/notes \
-H "X-API-Key: $k" -d '{"text":"rotiert"}'
done
curl -s -X POST localhost:3000/api/notes -H 'Content-Type: application/json' \
-d '{"text":"über web"}'; echoErwartet (gekürzt, IDs weichen ab):
Container notes-api-1 Recreated
Container notes-web-1 Recreated
Container notes-worker-1 Recreated
lab-api-key-123 → 401
lab-api-key-456 → 201
{"id":"0acfbc45-…","text":"über web"}
db und migrate blieben unberührt, die Notizen liegen in Postgres. Für die Folgetage zurück auf den alten Wert:
printf '%s' 'lab-api-key-123' > secrets/api_key.txt
docker compose up -d --force-recreate --no-build --wait api worker web >/dev/null 2>&1
echo "Exit: $?"Erwartet:
Exit: 0
Fortschritt speichern? Kostenlos registrieren
Drill 8: DB-Passwort rotieren – auf die Reihenfolge kommt es an
Das Passwort lebt an zwei Stellen: in der Rolle notes in
Postgres und in den Secret-Dateien. Erst die falsche Reihenfolge –
Dateien zuerst:
printf '%s' 'postgres://notes:lab-db-pw-456@db:5432/notes' > secrets/db_url.txt
docker compose up -d --force-recreate --no-build --wait api migrate 2>&1 | tail -1
docker compose ps -a api migrate --format 'table {{.Service}}\t{{.Status}}'
curl -s -o /dev/null -w '%{http_code}\n' localhost:8080/healthzErwartet (gekürzt):
service "migrate" didn't complete successfully: exit 1
SERVICE STATUS
api Created
migrate Exited (1) Less than a second ago
000
Ausfall: migrate kommt mit dem neuen Passwort nicht hinein, api wird gar nicht erst gestartet (Tag 5). Zurück:
printf '%s' 'postgres://notes:lab-db-pw-123@db:5432/notes' > secrets/db_url.txt
docker compose up -d --wait >/dev/null 2>&1; echo "Exit: $?"Erwartet:
Exit: 0
Richtig herum: zuerst die Rolle, angemeldet mit dem alten Passwort aus dem Secret.
docker compose run --rm psql -c "ALTER ROLE notes PASSWORD 'lab-db-pw-456'"
docker compose run --rm migrate 2>&1 | grep -o 'password authentication failed.*'
curl -s localhost:8080/healthzErwartet (gekürzt):
ALTER ROLE
password authentication failed for user \"notes\" (SQLSTATE 28P01)
ok
Jetzt läuft das Fenster: Die laufende api hat noch offene Verbindungen und bleibt gesund, jede neue Anmeldung mit dem alten Passwort scheitert. Halte es kurz:
printf '%s' 'lab-db-pw-456' > secrets/db_password.txt
printf '%s' 'postgres://notes:lab-db-pw-456@db:5432/notes' > secrets/db_url.txt
docker compose up -d --force-recreate --no-build --wait api migrate 2>&1 \
| grep -E 'Recreated|Healthy|Exited' | sort -u
docker compose ps -a --format 'table {{.Service}}\t{{.Status}}'
docker compose run --rm psql -Atc 'SELECT count(*) FROM notes'Erwartet (gekürzt, Zahlen weichen ab):
Container notes-api-1 Healthy
Container notes-api-1 Recreated
Container notes-db-1 Healthy
Container notes-migrate-1 Exited
Container notes-migrate-1 Recreated
SERVICE STATUS
api Up 1 second (healthy)
db Up About a minute (healthy)
migrate Exited (0) 2 seconds ago
web Up 37 seconds (healthy)
worker Up 37 seconds
5
- db musst du nicht neu erzeugen:
POSTGRES_PASSWORD_FILEzählt nur bei leerem Volume. Die Datei muss trotzdem stimmen – für psql, backup und jeden Neuaufbau. - worker und web sprechen nicht mit Postgres und laufen einfach weiter.
ALTER ROLE … PASSWORD '…'schickt das Passwort im Klartext an den Server. Mitlog_statement = ddlstünde es im Log; in Produktion\passwordoder einen vorab gehashten Wert nutzen.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
Keine Secrets mehr in .env und in den
Compose-Dateien:
cd ~/compose-lab/tag10
grep -cE '^(NOTES_API_KEY|POSTGRES_PASSWORD)=' .env
grep -cE '\$\{(NOTES_API_KEY|POSTGRES_PASSWORD)' compose.yaml compose.tools.yamlErwartet:
0
compose.yaml:0
compose.tools.yaml:0
Die drei Secret-Dateien:
ls secretsErwartet:
api_key.txt
db_password.txt
db_url.txt
npmrc
Der Stack ist gesund, api liest den Key aus der Datei:
docker compose up -d --wait
docker compose logs api | grep -o 'source=[a-z]*'Erwartet (gekürzt):
Container notes-db-1 Healthy
…
Container notes-web-1 Healthy
source=file
worker und db haben nur die _FILE-Variablen:
docker compose exec worker env | grep NOTES_API_KEY
docker compose exec db env | grep POSTGRES_PASSWORDErwartet:
NOTES_API_KEY_FILE=/run/secrets/api_key
POSTGRES_PASSWORD_FILE=/run/secrets/db_password
POST mit dem Key aus secrets/:
curl -s -o /dev/null -w '%{http_code}\n' -X POST localhost:8080/notes \
-H "X-API-Key: $(cat secrets/api_key.txt)" -d '{"text":"Kontrollpunkt 10"}'Erwartet:
201
psql meldet sich mit dem Secret an, und kein Secret steht im Log:
docker compose run --rm psql -Atc 'SELECT current_user'
docker compose logs | grep -cE 'lab-(api-key|db-pw)'Erwartet (gekürzt):
Container notes-db-1 Healthy
notes
0
Challenge
Rotiere das Datenbank-Passwort mit der Reihenfolge aus Drill 8 zurück
auf lab-db-pw-123, ohne dass das neue Passwort in einem
Container-Argument auftaucht, und prüf am Ende die Anmeldung.
Hinweis: Was über stdin in
docker compose run -T psql fließt, steht weder in
ps noch in der Container-Konfiguration.
Lösung
Zuerst die Rolle ändern, angemeldet mit dem alten Passwort aus
secrets/. Das SQL kommt über stdin:
echo "ALTER ROLE notes PASSWORD 'lab-db-pw-123';" | docker compose run --rm -T psqlErwartet:
Container notes-db-1 Healthy
ALTER ROLE
Dann die Secret-Dateien, ohne Zeilenumbruch:
printf '%s' lab-db-pw-123 > secrets/db_password.txt
printf '%s' postgres://notes:lab-db-pw-123@db:5432/notes > secrets/db_url.txt
cat secrets/db_url.txt; echoErwartet:
postgres://notes:lab-db-pw-123@db:5432/notes
Nur neu erzeugen, wer die DB-URL beim Start liest:
docker compose up -d --force-recreate --no-build --wait api migrateErwartet (gekürzt):
Container notes-migrate-1 Recreate
Container notes-api-1 Recreate
…
Container notes-api-1 Healthy
Gegenprobe mit dem Passwort aus der Datei:
docker compose run --rm -T psql -Atc 'SELECT current_user'Erwartet (gekürzt):
Container notes-db-1 Healthy
notes
Das Passwort steht in einer URL und in einem SQL-String: Erlaubt sind
nur Buchstaben, Ziffern, ., _ und
-, sonst müsstest du @, /,
: kodieren und ' maskieren. Wer erst die
Dateien schreibt und dann die Rolle ändert, hat den Ausfall aus Drill 8.
Zum Abschluss: docker compose down (ohne
-v).
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Secret-Dateien auf dem Host sind ein Zwischenschritt. In Produktion kommen sie aus einem Secret-Store (Vault/OpenBao, Cloud-KMS, CI-Secret) und werden beim Deploy geschrieben – siehe „OpenBao-Secrets zum Anfassen”.
- Rotation ohne Fenster: zwei gültige Werte gleichzeitig (zwei DB-Rollen oder Key-Liste in der Anwendung), umschalten, dann den alten Wert entziehen. Noch besser sind kurzlebige, dynamisch erzeugte DB-Zugänge.
- Anwendungen sollten Secret-Dateien neu lesen können (Signal oder Dateibeobachtung), dann braucht die Rotation keinen Neustart. Kubernetes aktualisiert gemountete Secrets von selbst, Compose nicht.
- Zugriff auf den Docker-Socket ist Root auf dem Host und damit
Zugriff auf alle Secrets:
docker-Gruppe klein halten, Audit-Logging, kein Socket in Containern. - Swarm (
docker stack deploy) verwaltet Secrets verschlüsselt im Cluster; dieenvironment:-Quelle gibt es dort laut Referenz nicht.