Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 9: Ressourcen und Härtung

Ziel: Jeder Dienst bekommt Grenzen für CPU, Speicher und Prozesse, ein schreibgeschütztes Dateisystem, keine Capabilities und rotierende Logs – gemeinsam definiert in einem Extension-Feld. · Dauer: ca. 75 min · Voraussetzung: Tag 8

Briefing

  • Ohne Angaben darf ein Container den ganzen Speicher und alle CPUs des Docker-Hosts nutzen, beliebig viele Prozesse starten und in sein Dateisystem schreiben.
  • deploy.resources.limits setzt Grenzen für cpus, memory und pids. Wer zu viel Speicher will, wird vom Kernel beendet (OOM-Kill, Exit 137).
  • read_only, cap_drop: [ALL], no-new-privileges und ein Nicht-root-user nehmen einem Angreifer im Container fast alles, was er bräuchte.
  • Logs rotiert der Treiber local mit max-size/max-file.
  • Ein Extension-Feld x-hardening mit YAML-Anker hält die Härtung an einer Stelle.
 x-hardening: &hardening ──<<:──► api, migrate, worker, web, db
   read_only · cap_drop [ALL] · no-new-privileges · logging local 10m×3
 je Dienst: deploy.resources.limits { cpus, memory, pids } · tmpfs · user · init

Drill 1: Was ein Container heute darf

source ~/compose-lab/setup/env.sh
docker compose -p notes down
mkdir -p ~/compose-lab/tag09 && cd ~/compose-lab/tag09
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag08/notes/." .
docker compose up -d --build --wait >/dev/null 2>&1; echo "Exit: $?"
docker stats --no-stream --format \
  'table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.PIDs}}' \
  notes-api-1 notes-worker-1 notes-web-1 notes-db-1

Erwartet (gekürzt, Werte weichen bei dir ab):

Exit: 0
NAME             CPU %     MEM USAGE / LIMIT     PIDS
notes-api-1      0.00%     2.625MiB / 7.737GiB   8
notes-worker-1   0.08%     23.58MiB / 7.737GiB   1
notes-web-1      0.00%     19.98MiB / 7.737GiB   11
notes-db-1       0.04%     29.52MiB / 7.737GiB   10

Das „Limit” ist der ganze Speicher der Colima-VM. Ein Speicherleck in einem Dienst nimmt allen anderen den Platz. Jetzt die Rechte, von innen gesehen:

docker compose exec web sh -c 'id; grep -E "^(CapEff|CapBnd|NoNewPrivs)" /proc/1/status
  touch /tmp/x && echo "/tmp beschreibbar"'
docker compose exec -u 0 web sh -c 'grep CapEff /proc/self/status
  chown node /app && echo "chown als root ok"'

Erwartet:

uid=1000(node) gid=1000(node) groups=1000(node)
CapEff: 0000000000000000
CapBnd: 00000000a80425fb
NoNewPrivs: 0
/tmp beschreibbar
CapEff: 00000000a80425fb
chown als root ok

CapBnd ist die Obergrenze der Capabilities (Docker-Standard: 14 Stück, etwa CHOWN, NET_RAW, SETUID). User node hat keine wirksamen, aber wer im Container root wird – per exec -u 0 oder über eine Lücke –, bekommt sie alle.

notes-api läuft in scratch ohne Shell. Ein Hilfscontainer, der ihren PID-Namespace teilt, liest ihre Prozessdaten trotzdem:

docker run --rm --label lab=compose-lab --pid container:notes-api-1 alpine:3.24 \
  sh -c 'grep -E "^(Uid|CapBnd|NoNewPrivs)" /proc/1/status
         awk "\$5==\"/\" {print \$5, \$6}" /proc/1/mountinfo'

Erwartet:

Uid:    65532   65532   65532   65532
CapBnd: 00000000a80425fb
NoNewPrivs: 0
/ rw,relatime

Nicht-root, aber Capabilities im Bounding-Set und ein beschreibbares Wurzel- Dateisystem (rw). Diesen Hilfscontainer brauchst du heute öfter.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Limits für CPU, Speicher und Prozesse

Trag bei api die Limits ein, und so wie im Trainingsplan steht, auch pids_limit:

  api:
    # … wie an Tag 8 …
    deploy:
      resources:
        limits:
          cpus: "0.50"
          memory: 64M
    pids_limit: 100

Dasselbe für worker ("0.25"/128M), web ("0.50"/128M), db ("1.0"/512M, pids_limit: 200) und migrate (wie api, ohne pids_limit).

docker compose up -d --wait; echo "Exit: $?"

Erwartet (gekürzt, der genannte Dienst kann abweichen):

services.worker: can't set distinct values on 'pids_limit' and
'deploy.resources.limits.pids': invalid compose project
Exit: 1

Compose 5.6 behandelt pids_limit und deploy.resources.limits.pids als dasselbe Feld. Steht limits da, gilt dort pids als 0 – und das widerspricht der 100 (live geprüft; ohne deploy: funktioniert pids_limit allein). Also gehört das Prozesslimit mit in den limits-Block:

    deploy:
      resources:
        limits:
          cpus: "0.50"
          memory: 64M
          pids: 100

Ersetze pids_limit bei allen vier Diensten entsprechend (db: pids: 200).

docker compose up -d --wait >/dev/null 2>&1; echo "Exit: $?"
docker stats --no-stream --format 'table {{.Name}}\t{{.MemUsage}}\t{{.PIDs}}' \
  notes-api-1 notes-worker-1 notes-web-1 notes-db-1
docker compose exec web cat /sys/fs/cgroup/cpu.max /sys/fs/cgroup/memory.max \
  /sys/fs/cgroup/pids.max

Erwartet (gekürzt):

Exit: 0
NAME             MEM USAGE / LIMIT   PIDS
notes-api-1      2.188MiB / 64MiB    7
notes-worker-1   23.59MiB / 128MiB   2
notes-web-1      24.17MiB / 128MiB   11
notes-db-1       32.29MiB / 512MiB   10
50000 100000
134217728
100

Die Limits landen als cgroup-Werte im Container: cpu.max heißt „50 ms Rechenzeit pro 100 ms”, also eine halbe CPU. Probier es mit einer Endlosschleife in Node:

docker compose exec -d web \
  node -e 'const t = Date.now(); while (Date.now() - t < 15000) {}'
sleep 6
docker stats --no-stream --format 'table {{.Name}}\t{{.CPUPerc}}' notes-web-1
docker compose exec web grep -E 'nr_throttled|throttled_usec' /sys/fs/cgroup/cpu.stat

Erwartet (gekürzt, Zahlen weichen ab):

NAME          CPU %
notes-web-1   51.34%
nr_throttled 75
throttled_usec 3694773

Mehr als 50 % gibt es nicht, der Rest der Zeit wird gedrosselt. Neben limits kennt deploy.resources auch reservations. Eine Speicherreservierung von 256M landete im Test als memory.low (weiche Garantie bei Speicherknappheit), eine CPU-Reservierung änderte am cgroup nichts sichtbar. Im Endstand bleibt es bei limits.

Tipp: Die Referenz kennt auch mem_limit und cpus direkt am Dienst. Laut Doku müssen sie mit deploy.resources.limits übereinstimmen, wenn beide gesetzt sind – im Buch steht alles einheitlich unter deploy.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Wenn das Limit greift

Was passiert bei 200 MB in einem Container mit 128 MB Limit? docker compose events zeigt, was Docker dabei meldet:

docker compose events --json worker > events.json &
docker compose exec worker python -c 'b = bytearray(200 * 1024 * 1024); print("ok")'
echo "Exit: $?"
sleep 2; kill %1
jq -c '{action, service}' events.json
docker compose ps worker --format 'table {{.Service}}\t{{.Status}}'
docker compose exec worker cat /sys/fs/cgroup/memory.events
rm events.json

Erwartet (gekürzt):

Exit: 137
{"action":"exec_create: python -c b = bytearray(200 * 1024 * 1024); …",…}
{"action":"exec_start: python -c b = bytearray(200 * 1024 * 1024); …",…}
{"action":"oom","service":"worker"}
{"action":"exec_die","service":"worker"}
SERVICE   STATUS
worker    Up About a minute
low 0
high 0
max 35
oom 1
oom_kill 1
oom_group_kill 0

Exit 137 = 128 + 9 (SIGKILL). Der Kernel hat den größten Prozess im cgroup beendet – hier den exec-Prozess, der worker selbst lief weiter. Trifft es den Hauptprozess, sieht es anders aus. Eine Zusatzdatei setzt das Limit von worker vorübergehend auf 16 MB:

cat > compose.oom.yaml <<'EOF'
# compose.oom.yaml – nur für Tag 9, Drill 3
services:
  worker:
    deploy:
      resources:
        limits:
          memory: 16M
EOF
docker compose -f compose.yaml -f compose.oom.yaml up -d --no-deps worker
sleep 10
docker compose ps -a worker --format 'table {{.Service}}\t{{.Status}}'
docker compose logs worker | wc -l
docker compose events --json --since 15s --until 1s worker 2>/dev/null \
  | jq -r 'select(.action == "oom" or .action == "die")
           | "\(.time[11:19]) \(.action) \(.attributes.exitCode // "")"' | tail -4

Erwartet (gekürzt, Zeiten weichen ab):

 Container notes-worker-1 Recreate
 Container notes-worker-1 Recreated
 Container notes-worker-1 Started
SERVICE   STATUS
worker    Restarting (137) 3 seconds ago
       0
23:33:17 oom
23:33:17 die 137
23:33:20 oom
23:33:20 die 137

Das ist das typische Bild eines zu knappen Limits: Restarting (137), keine einzige Logzeile – Python stirbt beim Laden der Module –, und nur die Events nennen den Grund. --until beendet den Event-Strom; Compose 5.6 meldet danach ein EOF auf stderr, daher 2>/dev/null. Zurück zum richtigen Limit:

rm compose.oom.yaml
docker compose up -d --wait worker 2>&1 | grep -E 'Recreated|Healthy'

Erwartet:

 Container notes-worker-1 Recreated
 Container notes-worker-1 Healthy

Das Prozesslimit wirkt genauso hart, bei web mit pids: 100:

docker compose exec web sh -c 'for i in $(seq 1 120); do sleep 5 & done; wait'
docker compose exec web cat /sys/fs/cgroup/pids.events

Erwartet:

sh: can't fork: Resource temporarily unavailable
max 1

Eine Fork-Bombe oder ein Thread-Leck legt so nur den eigenen Container lahm, nicht den Host.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Schreibgeschützt mit tmpfs

Ab jetzt sammelst du die Härtung in einem Extension-Feld. Ergänze unter x-api-build:

x-hardening: &hardening
  read_only: true

und setze in api, migrate, worker und web als erste Zeile <<: *hardening:

  api:
    <<: *hardening
    build: *api-build
    # …

<< ist der Merge-Key von YAML: Er kopiert alle Schlüssel des Ankers in den Dienst. Was der Dienst selbst setzt, gewinnt.

docker compose up -d --wait 2>&1 | grep -E 'Recreated' | sort -u
docker compose exec web sh -c 'touch /tmp/x; touch /app/x'
docker compose exec worker touch /tmp/x
docker run --rm --label lab=compose-lab --pid container:notes-api-1 alpine:3.24 \
  sh -c 'awk "\$5==\"/\" {print \$5, \$6}" /proc/1/mountinfo'
curl -s -X POST localhost:3000/api/notes -H 'Content-Type: application/json' \
  -d '{"text":"read only"}'; echo

Erwartet (gekürzt, IDs weichen ab):

 Container notes-api-1 Recreated
 Container notes-migrate-1 Recreated
 Container notes-web-1 Recreated
 Container notes-worker-1 Recreated
touch: /tmp/x: Read-only file system
touch: /app/x: Read-only file system
touch: cannot touch '/tmp/x': Read-only file system
/ ro,relatime
{"id":"b720e8f5-…","text":"read only"}

Alle drei laufen weiter – sie schreiben nichts auf die Platte. Ein Angreifer kann jetzt aber auch kein Werkzeug mehr ablegen. Viele Programme brauchen trotzdem ein /tmp; bei web gibst du es als tmpfs (im Speicher, verschwindet mit dem Container):

  web:
    <<: *hardening
    # …
    tmpfs: [/tmp]
docker compose up -d --wait web >/dev/null 2>&1
docker compose exec web sh -c 'touch /tmp/x && echo "/tmp beschreibbar"
  grep " /tmp " /proc/mounts'

Erwartet:

/tmp beschreibbar
tmpfs /tmp tmpfs rw,nosuid,nodev,noexec,relatime,inode64 0 0

Docker hängt tmpfs mit noexec ein: Was dort landet, lässt sich nicht ausführen.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Capabilities und no-new-privileges

Erweitere den Anker:

x-hardening: &hardening
  read_only: true
  cap_drop: [ALL]
  security_opt: ["no-new-privileges:true"]
docker compose up -d --wait >/dev/null 2>&1
docker compose exec web grep -E '^(CapEff|CapBnd|NoNewPrivs)' /proc/1/status
docker compose exec -u 0 web sh -c 'touch /tmp/f && chown node /tmp/f
  cat /etc/shadow >/dev/null && echo "shadow lesbar"'

Erwartet:

CapEff: 0000000000000000
CapBnd: 0000000000000000
NoNewPrivs: 1
chown: /tmp/f: Operation not permitted
shadow lesbar
  • cap_drop: [ALL] leert das Bounding-Set. Selbst root darf nun keine fremden Dateien mehr übernehmen (CHOWN), keine Rohsockets öffnen (NET_RAW), nicht die UID wechseln (SETUID).
  • /etc/shadow gehört root – Besitzerrechte brauchen keine Capability. Deshalb bleibt ein Nicht-root-User (aus dem Dockerfile oder per user:) Pflicht.
  • no-new-privileges verhindert, dass ein Prozess über setuid-Programme oder Datei-Capabilities mehr Rechte bekommt, als er beim Start hatte.

Braucht ein Dienst doch eine Capability, gibst du genau diese mit cap_add: zurück (Tag 11: der Proxy für Port 443).

Fortschritt speichern? Kostenlos registrieren

Drill 6: Postgres gehärtet

Jetzt db. Zuerst nur der Anker:

  db:
    <<: *hardening
    image: postgres:18.6-alpine
    # …
docker compose up -d --wait --wait-timeout 20 db 2>&1 | tail -1
docker compose ps -a db --format 'table {{.Service}}\t{{.Status}}'
docker compose logs db | tail -4

Erwartet (gekürzt):

container notes-db-1 is unhealthy
SERVICE   STATUS
db        Restarting (1) Less than a second ago
db-1  | find: /var/lib/postgresql/18/docker: Permission denied
db-1  | chmod: /var/lib/postgresql/18/docker: Operation not permitted
db-1  | chmod: /var/run/postgresql: Read-only file system
db-1  | find: /var/lib/postgresql/18/docker: Permission denied

Das Entrypoint-Skript startet als root, will Rechte im Datenordner richten und dann per su-exec zu postgres wechseln. Ohne Capabilities darf root nicht einmal in den Ordner, der UID 70 gehört. Also gleich als UID 70 starten (das Alpine-Image hat postgres mit UID/GID 70):

    user: "70:70"
docker compose up -d --wait --wait-timeout 20 db 2>&1 | tail -1
docker compose logs db | grep FATAL | tail -1

Erwartet (gekürzt):

container notes-db-1 is unhealthy
db-1  | … FATAL:  could not create lock file "/var/run/postgresql/.s.PGSQL.5432.lock":
Read-only file system

Postgres legt Socket und Lock-Datei in /var/run/postgresql ab. Das und /tmp bekommen tmpfs, dazu mehr Zeit zum Herunterfahren:

    user: "70:70"
    tmpfs: [/var/run/postgresql, /tmp]
    stop_grace_period: 30s
docker compose up -d --wait db 2>&1 | grep -E 'db-1 (Recreated|Healthy)'
docker compose exec db sh -c 'id; grep -E "^(CapEff|NoNewPrivs)" /proc/1/status'
docker compose stop db
docker compose logs db | grep -E 'shutdown request|shut down$' | tail -2
docker compose up -d --wait >/dev/null 2>&1; echo "Exit: $?"

Erwartet (gekürzt, Zeiten weichen ab):

 Container notes-db-1 Recreated
 Container notes-db-1 Healthy
uid=70(postgres) gid=70(postgres) groups=70(postgres)
CapEff: 0000000000000000
NoNewPrivs: 1
 Container notes-db-1 Stopping
 Container notes-db-1 Stopped
db-1  | … [1] LOG:  received fast shutdown request
db-1  | … [1] LOG:  database system is shut down
Exit: 0

docker compose stop schickt das Stoppsignal des Images und wartet stop_grace_period (Standard laut Referenz: 10 s), dann folgt SIGKILL. Unter Last braucht Postgres für einen sauberen Checkpoint länger – ein Kill hieße Crash-Recovery beim nächsten Start.

Das Volume aus Tag 8 funktioniert ohne Umbau: Das Entrypoint-Skript hatte die Dateien schon damals UID 70 übergeben. Auch ein leeres Volume initialisiert Postgres als UID 70 (live geprüft mit down -v), inklusive Init-Skript aus Tag 4.

Fortschritt speichern? Kostenlos registrieren

Drill 7: init und Logging

worker bekommt einen Init-Prozess:

  worker:
    <<: *hardening
    # …
    init: true
docker compose up -d --wait worker >/dev/null 2>&1
docker compose exec worker sh -c 'for p in /proc/[0-9]*; do
  printf "%s " "${p#/proc/}"; tr "\0" " " < "$p/cmdline"; echo; done'

Erwartet (gekürzt):

1 /sbin/docker-init -- notes-worker
7 /app/.venv/bin/python /app/.venv/bin/notes-worker
8 sh -c for p in /proc/[0-9]*; do …

docker-init ist PID 1, leitet Signale weiter und räumt verwaiste Kindprozesse ab. Der Python-Prozess fängt SIGTERM zwar selbst ab, aber ohne Init sammelt niemand Zombies ein, falls der Worker einmal Unterprozesse startet.

Jetzt die Logs. Ohne Angabe nimmt Docker den Standardtreiber des Daemons:

docker info --format '{{.LoggingDriver}}'

Erwartet:

json-file

json-file rotiert ohne Optionen nie – ein gesprächiger Dienst füllt die Platte der VM. Der Treiber local rotiert von sich aus (Standard laut Doku: 5 Dateien à 20 MB, komprimiert). Den Unterschied siehst du mit zwei Hilfscontainern, die je 100 000 Zeilen schreiben:

docker run -d --name notes-chatter --label lab=compose-lab --log-driver local \
  --log-opt max-size=100k --log-opt max-file=2 alpine:3.24 \
  sh -c 'seq 1 100000; sleep 600' >/dev/null
docker run -d --name notes-chatter2 --label lab=compose-lab alpine:3.24 \
  sh -c 'seq 1 100000; sleep 600' >/dev/null
sleep 3
for c in notes-chatter notes-chatter2; do
  echo "$c: $(docker logs "$c" | wc -l) Zeilen, erste: $(docker logs "$c" | head -1)"
done
docker rm -f notes-chatter notes-chatter2 >/dev/null

Erwartet (gekürzt, Zahlen weichen ab):

notes-chatter:     5704 Zeilen, erste: 94297
notes-chatter2:   100000 Zeilen, erste: 1

Mit local und max-size=100k/max-file=2 sind nur die letzten rund 6 000 Zeilen übrig, der Rest ist wegrotiert. Für den Stack kommt das in den Anker:

x-hardening: &hardening
  read_only: true
  cap_drop: [ALL]
  security_opt: ["no-new-privileges:true"]
  logging:
    driver: local
    options:
      max-size: "10m"
      max-file: "3"
docker compose up -d --wait >/dev/null 2>&1; echo "Exit: $?"
docker compose logs --tail 1 api
docker inspect -f '{{.HostConfig.LogConfig}}' notes-api-1

Erwartet (gekürzt):

Exit: 0
api-1  | time=… level=INFO msg=listening addr=:8080 version=dev pid=1

docker inspect zeigt dazu den Logging-Treiber local mit den Optionen aus der Datei, max-size 10m und max-file 3.

docker compose logs funktioniert mit local wie gewohnt. Höchstens 30 MB Logs pro Container, danach fallen die ältesten Zeilen weg – wer sie länger braucht, schickt sie an ein zentrales System (Tag 12, Enterprise-Notiz).

Fortschritt speichern? Kostenlos registrieren

Drill 8: Entwicklung, Werkzeuge und die Grenze des Ankers

Die vollständige Datei liegt in code/tag09/notes/compose.yaml. Fünf Dienste nutzen den Anker:

grep -n '<<: \*hardening' compose.yaml

Erwartet:

25:    <<: *hardening
53:    <<: *hardening
74:    <<: *hardening
99:    <<: *hardening
148:    <<: *hardening

Im Entwicklungsmodus (Tag 7) synct watch Dateien nach /app – das scheitert an read_only. compose.dev.yaml schaltet es für web ab:

# compose.dev.yaml – Entwicklung, nur per -f zusammen mit compose.yaml (Stand Tag 9)
services:
  web:
    build:
      target: build
    command: ["node", "--watch", "server.js"]
    environment:
      NODE_ENV: development
    read_only: false
TAG=watch docker compose -f compose.yaml -f compose.dev.yaml \
  up -d --build --wait --no-deps web 2>&1 | grep -E 'Built|Healthy'
docker compose exec web sh -c 'id -u; touch /app/public/x && echo "/app beschreibbar"
  rm -f /app/public/x'
docker compose up -d --wait >/dev/null 2>&1
docker image rm notes-web:watch >/dev/null

Erwartet (gekürzt):

 Image notes-web:watch Built
 Container notes-web-1 Healthy
0
/app beschreibbar

Ohne die Zeile read_only: false meldet derselbe touch Read-only file system (live geprüft). Die Stage build läuft als root; schreiben darf sie trotz cap_drop: [ALL], weil /app root gehört. TAG=watch hält das Dev-Image vom notes-web:dev fern (Tag 8).

psql und backup in compose.tools.yaml bleiben ungehärtet: Sie laufen Sekunden, haben keine Ports und backup schreibt nach ./backup. Der Anker würde dort auch gar nicht funktionieren:

cp compose.tools.yaml tools.bak
sed -i.tmp 's/^    profiles: \[tools\]/    <<: *hardening\n    profiles: [tools]/' \
  compose.tools.yaml
docker compose up --dry-run -d 2>&1 | tail -1
mv tools.bak compose.tools.yaml && rm -f compose.tools.yaml.tmp

Erwartet (gekürzt):

failed to parse /Users/du/compose-lab/tag09/compose.tools.yaml: go-yaml load error in
composer at L5.C9: unknown anchor 'hardening' referenced

YAML-Anker gelten nur in der Datei, in der sie stehen – auch bei include. Wer die Härtung in mehreren Dateien braucht, nimmt extends (Tag 7) auf einen gehärteten Basisdienst.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Fünf Dienste mit dem Anker:

cd ~/compose-lab/tag09
grep -c '<<: \*hardening' compose.yaml

Erwartet:

5

Der Stack ist gesund, die Speicherlimits greifen:

docker compose up -d --wait
docker stats --no-stream --format '{{.Name}} {{.MemUsage}}'

Erwartet (gekürzt, Verbrauch weicht ab):

 Container notes-db-1 Healthy
…
 Container notes-web-1 Healthy
notes-web-1 20.17MiB / 128MiB
notes-worker-1 22.7MiB / 128MiB
notes-api-1 2.082MiB / 64MiB
notes-db-1 29.23MiB / 512MiB

web: / read-only, /tmp beschreibbar:

docker compose exec web touch /x
docker compose exec web touch /tmp/x; echo "Exit: $?"

Erwartet:

touch: /x: Read-only file system
Exit: 0

db läuft als UID 70 mit no-new-privileges:

docker compose exec db id -u
docker compose exec db grep NoNewPrivs /proc/1/status

Erwartet:

70
NoNewPrivs: 1

worker hat init als PID 1:

docker compose exec worker cat /proc/1/cmdline | tr '\0' ' '; echo

Erwartet:

/sbin/docker-init -- notes-worker

POST über web:

curl -s -o /dev/null -w '%{http_code}\n' -X POST localhost:3000/api/notes \
  -H 'Content-Type: application/json' -d '{"text":"Kontrollpunkt 9"}'

Erwartet:

201

Challenge

Prüf von innen, ob notes-api-1 gehärtet läuft: Wurzel-Dateisystem read-only, no-new-privileges aktiv, keine Capabilities, Speicherlimit gesetzt. Beweise mit einem psql-Container, dass dieselben Befehle Ungehärtetes zeigen.

Hinweis: Der Hilfscontainer mit --pid container:<name> aus Drill 1 liest /proc/1/status und /proc/1/mountinfo jedes Containers, auch bei scratch.

Lösung

NoNewPrivs und die Capability-Maske CapBnd aus /proc/1/status:

docker run --rm --pid container:notes-api-1 alpine:3.24 \
  grep -E '^(NoNewPrivs|CapBnd)' /proc/1/status

Erwartet:

CapBnd: 0000000000000000
NoNewPrivs: 1

1 heißt aktiv, lauter Nullen heißt keine Capabilities. Die Zeile für das Wurzel-Dateisystem in /proc/1/mountinfo hat / / in der Mitte:

docker run --rm --pid container:notes-api-1 alpine:3.24 \
  grep ' / / ' /proc/1/mountinfo

Erwartet (gekürzt):

495 466 0:48 / / ro,relatime - overlay overlay rw,lowerdir=/var/lib/containerd/…

ro steht vorn in den Optionen. Das Speicherlimit zeigt docker stats:

docker stats --no-stream --format '{{.Name}} {{.MemUsage}}' notes-api-1

Erwartet (Verbrauch weicht ab):

notes-api-1 2.227MiB / 64MiB

Jetzt ein Werkzeug-Container daneben, der eine Minute schläft, und dieselben Befehle:

docker compose run -d --rm --name notes-psql-probe --entrypoint sleep psql 60
docker run --rm --pid container:notes-psql-probe alpine:3.24 \
  grep -E '^(NoNewPrivs|CapBnd)' /proc/1/status
docker run --rm --pid container:notes-psql-probe alpine:3.24 \
  grep ' / / ' /proc/1/mountinfo
docker stats --no-stream --format '{{.Name}} {{.MemUsage}}' notes-psql-probe

Erwartet (gekürzt, IDs weichen ab):

 Container notes-db-1 Healthy
9ab57f918e86…
CapBnd: 00000000a80425fb
NoNewPrivs: 0
665 630 0:63 / / rw,relatime - overlay overlay rw,lowerdir=/var/lib/containerd/…
notes-psql-probe 348KiB / 7.755GiB

NoNewPrivs: 0, eine volle Capability-Maske, rw und als Limit der ganze Speicher der VM: Die Befehle finden alle vier Lücken. Weil sie von innen nachsehen, zeigen sie, was wirklich gilt, nicht was in der YAML steht. Zum Abschluss des Tages: docker compose down (ohne -v).

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Limits ohne Messung sind geraten. Erst docker stats bzw. Metriken (Tag 12) unter Last beobachten, dann Limit = Spitze plus Reserve; OOM-Events gehören in den Alarm.
  • Kubernetes trennt requests (Planung) und limits (Grenze) sauberer; Pod Security Standards „restricted” verlangen genau das hier: Nicht-root, drop: [ALL], allowPrivilegeEscalation: false, dazu readOnlyRootFilesystem.
  • security_opt kennt außerdem Seccomp- und AppArmor-Profile. Das Docker-Standardprofil ist aktiv, solange niemand seccomp=unconfined setzt – das gehört in jede Review.
  • Docker selbst härten: Rootless-Modus oder User-Namespaces (userns-remap), kein privileged, Docker-Socket nie in Container mounten.
  • Logs mit local bleiben auf dem Host; im Betrieb schickt ein Treiber (fluentd, gelf, journald) oder ein Agent sie an ein zentrales System mit Aufbewahrungsregeln.