Zum Inhalt springen
Trainingslager IT-Trainingslager

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ür POSTGRES_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'
done

Erwartet:

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 NOTES

Erwartet:

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/*.txt

Erwartet:

      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.txt

api 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 POSTGRES

Erwartet (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.js

Jetzt 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.txt

Die 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.sql

Erwartet (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.
  • mountinfo verrät, woher die Datei kommt: ein Bind-Mount aus deinem Home (unter Colima relativ zur Freigabe), read-only.
  • Logs und .env sind 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 -u

Erwartet (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 Healthy

Erwartet:

 Container notes-worker-1 Healthy

Achtung: Wer Secrets auf einem Server per environment: liefern will (Tag 14), braucht für diese Dienste read_only: false oder 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 -u

Erwartet:

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"}'; echo

Erwartet (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/healthz

Erwartet (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/healthz

Erwartet (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_FILE zä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. Mit log_statement = ddl stünde es im Log; in Produktion \password oder 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.yaml

Erwartet:

0
compose.yaml:0
compose.tools.yaml:0

Die drei Secret-Dateien:

ls secrets

Erwartet:

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_PASSWORD

Erwartet:

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 psql

Erwartet:

 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; echo

Erwartet:

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 migrate

Erwartet (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; die environment:-Quelle gibt es dort laut Referenz nicht.