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.limitssetzt Grenzen fürcpus,memoryundpids. Wer zu viel Speicher will, wird vom Kernel beendet (OOM-Kill, Exit 137).read_only,cap_drop: [ALL],no-new-privilegesund ein Nicht-root-usernehmen einem Angreifer im Container fast alles, was er bräuchte.- Logs rotiert der Treiber
localmitmax-size/max-file. - Ein Extension-Feld
x-hardeningmit 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-1Erwartet (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: 100Dasselbe 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: 100Ersetze 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.maxErwartet (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.statErwartet (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_limitundcpusdirekt am Dienst. Laut Doku müssen sie mitdeploy.resources.limitsübereinstimmen, wenn beide gesetzt sind – im Buch steht alles einheitlich unterdeploy.
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.jsonErwartet (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 -4Erwartet (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.eventsErwartet:
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: trueund 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"}'; echoErwartet (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/shadowgehört root – Besitzerrechte brauchen keine Capability. Deshalb bleibt ein Nicht-root-User (aus dem Dockerfile oder peruser:) Pflicht.no-new-privilegesverhindert, 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 -4Erwartet (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 -1Erwartet (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: 30sdocker 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: truedocker 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/nullErwartet (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-1Erwartet (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.yamlErwartet:
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: falseTAG=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/nullErwartet (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.tmpErwartet (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.yamlErwartet:
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/statusErwartet:
70
NoNewPrivs: 1
worker hat init als PID 1:
docker compose exec worker cat /proc/1/cmdline | tr '\0' ' '; echoErwartet:
/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/statusErwartet:
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/mountinfoErwartet (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-1Erwartet (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-probeErwartet (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 statsbzw. Metriken (Tag 12) unter Last beobachten, dann Limit = Spitze plus Reserve; OOM-Events gehören in den Alarm. - Kubernetes trennt
requests(Planung) undlimits(Grenze) sauberer; Pod Security Standards „restricted” verlangen genau das hier: Nicht-root,drop: [ALL],allowPrivilegeEscalation: false, dazureadOnlyRootFilesystem. security_optkennt außerdem Seccomp- und AppArmor-Profile. Das Docker-Standardprofil ist aktiv, solange niemandseccomp=unconfinedsetzt – das gehört in jede Review.- Docker selbst härten: Rootless-Modus oder User-Namespaces
(
userns-remap), keinprivileged, Docker-Socket nie in Container mounten. - Logs mit
localbleiben auf dem Host; im Betrieb schickt ein Treiber (fluentd,gelf,journald) oder ein Agent sie an ein zentrales System mit Aufbewahrungsregeln.