Tag 1: Linux-Internals
Ziel: Einen Modellserver-Prozess über /proc, Signale, strace, cgroups v2, Namespaces und systemd vollständig durchleuchten und begrenzen · Dauer: ca. 120 min · Voraussetzung: Tag 0
Briefing
- Ein LLM-Server ist für Linux nur ein Prozess: PID, Dateideskriptoren, Speicher, Signale.
- cgroups v2 begrenzen Ressourcen
(
memory.max,cpu.max) und zählen Ereignisse (memory.events). - Namespaces isolieren die Sicht (PID, Netz, Hostname, Mounts). Container = Namespaces + cgroups.
- systemd schreibt deine Limits in cgroup-Dateien und protokolliert OOM-Kills im Journal.
- PSI (
/proc/pressure/*) zeigt, wie lange Prozesse auf CPU, RAM oder I/O warten.
systemd ── fake-llm.service ── cgroup /system.slice/fake-llm.service
memory.max = 300M cpu.max = 50000 100000
└── PID 132 python3 (ns: pid, net, mnt, uts)
Alle Drills laufen auf der VM (multipass shell llm-vm).
Als Stellvertreter für Ollama dient ein Python-HTTP-Server auf Port
11434 – ab Tag 5 ersetzt du ihn durch den echten Modellserver.
Drill 1: Ein Prozess unter der Lupe
mkdir -p ~/tag01 && cd ~/tag01
python3 -m http.server 11434 >/dev/null 2>&1 &
PID=$!; sleep 2
grep -E '^(Name|State|PPid|Threads|VmRSS)' /proc/$PID/status
ls -l /proc/$PID/fd
ss -tlnp | grep 11434Erwartet (PIDs und Inodes variieren):
Name: python3
State: S (sleeping)
PPid: 5019
VmRSS: 18520 kB
Threads: 1
lr-x------ 1 root root 64 Oct 9 16:50 0 -> /dev/null
l-wx------ 1 root root 64 Oct 9 16:50 1 -> /dev/null
l-wx------ 1 root root 64 Oct 9 16:50 2 -> /dev/null
lrwx------ 1 root root 64 Oct 9 16:50 3 -> socket:[812183]
LISTEN 0 5 0.0.0.0:11434 0.0.0.0:* users:(("python3",pid=5025,fd=3))
Warum? fd 3 ist der Listen-Socket. Send-Q 5 bei
LISTEN ist die Backlog-Länge – Pythons Default ist winzig,
echte Server nutzen 4096 und mehr.
Limits lesen und zur Laufzeit ändern:
grep -E 'open files|processes' /proc/$PID/limits
sudo prlimit --pid $PID --nofile=4096:4096
grep 'open files' /proc/$PID/limits
tr '\0' ' ' < /proc/$PID/cmdline; echo
readlink /proc/$PID/exeErwartet (gekürzt, Werte können abweichen):
Max processes 31398 31398 processes
Max open files 1024 524288 files
Max open files 4096 4096 files
python3 -m http.server 11434
/usr/bin/python3.12
Tipp:
Too many open filesbei vielen gleichzeitigen Streams? Erst/proc/<pid>/limitsprüfen, dannls /proc/<pid>/fd | wc -l– die Ursache ist fast immer ein zu kleines Soft-Limit.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Signale
kill -STOP $PID
grep State /proc/$PID/status
for i in 1 2 3; do curl -s -m 1 localhost:11434 >/dev/null & done; sleep 0.5
ss -tln sport = :11434Erwartet:
State: T (stopped)
State Recv-Q Send-Q Local Address:Port Peer Address:PortProcess
LISTEN 3 5 0.0.0.0:11434 0.0.0.0:*
Warum? Den TCP-Handshake erledigt der Kernel. Die drei Verbindungen
stehen in der Accept-Queue (Recv-Q 3), aber niemand holt
sie ab. Port offen heißt nicht Dienst gesund – darum
prüfen Health-Checks eine echte Antwort (Tag 4:
/readyz).
kill -CONT $PID; kill -TERM $PID; wait $PID; echo "exit=$?"Erwartet:
exit=143
Exit-Code 128 + Signalnummer: 143 = SIGTERM (15), 137 = SIGKILL (9).
Diese Zahlen siehst du später als exitCode in Kubernetes
wieder.
Ein Server, der SIGTERM sauber behandelt:
cat > server.sh <<'EOF'
#!/usr/bin/env bash
graceful() {
echo "SIGTERM: laufende Requests beenden ..."
sleep 1
echo "sauber beendet"
exit 0
}
trap graceful TERM
echo "Server läuft als PID $$"
while true; do sleep 1; done
EOF
chmod +x server.sh
./server.sh & P=$!; sleep 1.5; kill -TERM $P; wait $P; echo "exit=$?"
./server.sh & P=$!; sleep 1.5; kill -KILL $P; wait $P; echo "exit=$?"Erwartet:
Server läuft als PID 5075
SIGTERM: laufende Requests beenden ...
sauber beendet
exit=0
Server läuft als PID 5080
bash: line 12: 5080 Killed ./server.sh
exit=137
Warum? SIGKILL kann kein Prozess abfangen. Ein LLM-Server braucht bei SIGTERM Zeit, laufende Streams zu beenden (Drain) – sonst bricht jede Antwort mitten im Satz ab.
Fortschritt speichern? Kostenlos registrieren
Drill 3: strace – was macht der Prozess wirklich?
python3 -m http.server 11434 >/dev/null 2>&1 &
PID=$!; sleep 2
(sleep 1; curl -s localhost:11434/ >/dev/null) &
sudo timeout 3 strace -f -p $PID -e trace=accept4,recvfrom,sendto,openat
kill $PIDErwartet (gekürzt):
strace: Process 5127 attached
accept4(3, {sa_family=AF_INET, sin_port=htons(60510), ...}, [16], SOCK_CLOEXEC) = 4
strace: Process 5137 attached
[pid 5137] recvfrom(4, "GET / HTTP/1.1\r\nHost: localhost:"..., 8192, ...) = 78
[pid 5137] openat(AT_FDCWD, "//", O_RDONLY|O_NONBLOCK|O_CLOEXEC|O_DIRECTORY) = 5
[pid 5137] sendto(4, "HTTP/1.0 200 OK\r\nServer: SimpleH"..., 156, 0, NULL, 0) = 156
[pid 5137] +++ exited with 0 +++
Warum -f? Der Server startet pro Request einen Thread
(Process 5137 attached). Ohne -f siehst du nur
das accept4.
Wo hängt ein Client? -T zeigt die Dauer jedes
Syscalls:
strace -T -e trace=connect curl -s -m 2 http://10.255.255.1:80Erwartet (gekürzt):
connect(5, {sa_family=AF_INET, sin_port=htons(80), ...}, 16) = -1 EINPROGRESS
(Operation now in progress) <0.000452>
+++ exited with 28 +++
Nicht-blockierendes connect, danach Timeout (curl-Exit
28). Zusammenfassung aller Syscalls:
strace -c -f <befehl>.
Achtung: strace bremst den Prozess massiv. In Produktion nur kurz und gezielt (
-e trace=...), nie dauerhaft an einem Modellserver unter Last.
Fortschritt speichern? Kostenlos registrieren
Drill 4: cgroups v2 – Speicherlimit und OOM-Kill
Der Speicherfresser simuliert ein Modell, das beim Laden mehr RAM braucht als erlaubt:
cat > hog.py <<'EOF'
import sys
import time
step = int(sys.argv[1]) if len(sys.argv) > 1 else 50
buf = []
while True:
buf.append(bytearray(step * 1024 * 1024))
print(f"{len(buf) * step} MB belegt", flush=True)
time.sleep(0.2)
EOF
cat /sys/fs/cgroup/cgroup.subtree_control
sudo mkdir /sys/fs/cgroup/llm-demo
echo 200M | sudo tee /sys/fs/cgroup/llm-demo/memory.max
echo 0 | sudo tee /sys/fs/cgroup/llm-demo/memory.swap.max
sudo bash -c 'echo $$ > /sys/fs/cgroup/llm-demo/cgroup.procs; exec python3 hog.py 50'
echo "exit=$?"Erwartet (gekürzt, Controller-Liste variiert):
cpu memory pids
200M
0
50 MB belegt
100 MB belegt
150 MB belegt
Killed
exit=137
Warum echo $$ > cgroup.procs? Ein Prozess landet in
einer cgroup, indem man seine PID in cgroup.procs schreibt;
per exec erbt Python sie.
cat /sys/fs/cgroup/llm-demo/memory.events
sudo dmesg | grep -i 'memory cgroup out of memory' | tail -1Erwartet (gekürzt):
low 0
high 0
max 35
oom 1
oom_kill 1
oom_group_kill 0
Memory cgroup out of memory: Killed process 60519 (python3) total-vm:219196kB,
anon-rss:204160kB, file-rss:5632kB, shmem-rss:0kB, UID:0 pgtables:464kB
Warum? oom_kill zählt Kills in genau dieser cgroup,
max zählt, wie oft das Limit erreicht wurde. Diese Zähler
exportiert später cAdvisor nach Prometheus (Tag 8).
Fortschritt speichern? Kostenlos registrieren
Drill 5: cgroups v2 – CPU-Limit und Throttling
sudo mkdir /sys/fs/cgroup/llm-cpu
echo "50000 100000" | sudo tee /sys/fs/cgroup/llm-cpu/cpu.max
sudo bash -c 'echo $$ > /sys/fs/cgroup/llm-cpu/cgroup.procs; \
exec stress-ng --cpu 2 --timeout 10s'
grep -E 'usage_usec|nr_periods|nr_throttled|throttled_usec' \
/sys/fs/cgroup/llm-cpu/cpu.statErwartet (gekürzt, Werte variieren):
50000 100000
stress-ng: info: [5200] successful run completed in 10.35 secs
usage_usec 5222961
nr_periods 104
nr_throttled 104
throttled_usec 14699286
Warum? cpu.max = 50 ms Quota pro 100 ms Periode = 0,5
CPU. 10 s Laufzeit ergeben 5,2 s CPU-Zeit, in jeder Periode wurde
gedrosselt. Bei einem Modellserver äußert sich das als langsame Tokens,
nicht als Fehler – darum nr_throttled überwachen.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Namespaces – und warum Container nur Prozesse sind
sudo unshare --pid --fork --mount-proc --uts --net \
bash -c 'hostname llm-box; hostname; ps -e -o pid,comm; ip -br link'Erwartet:
llm-box
PID COMMAND
1 bash
4 ps
lo DOWN 00:00:00:00:00:00 <LOOPBACK>
Eigener Hostname, PID 1, nur ein Loopback ohne Verbindung nach außen. Jetzt einen langlebigen Prozess isolieren und von außen betreten:
sudo unshare --pid --fork --mount-proc --uts --net \
bash -c 'hostname llm-box; exec sleep 300' &
sleep 1
sudo lsns -t net -t uts | tail -2
P=$(pgrep -n -x sleep)
sudo nsenter -t $P --uts --net bash -c 'hostname; ip -br link'
sudo readlink /proc/1/ns/net /proc/$P/ns/netErwartet (Inode-Nummern variieren):
4026534205 uts 2 5218 root unshare --pid --fork --mount-proc ...
4026534267 net 2 5218 root unassigned unshare --pid --fork --mount-proc ...
llm-box
lo DOWN 00:00:00:00:00:00 <LOOPBACK>
net:[4026533204]
net:[4026534267]
Warum? nsenter ist das Werkzeug, mit dem du in
Kubernetes-Knoten das Netz eines Pods debuggst, wenn das Image keine
Tools enthält.
Jetzt beides kombiniert – ein Container ohne Docker:
sudo mkdir /sys/fs/cgroup/mini-ctr
echo 100M | sudo tee /sys/fs/cgroup/mini-ctr/memory.max
echo 0 | sudo tee /sys/fs/cgroup/mini-ctr/memory.swap.max
cat > mini-ctr.sh <<'EOF'
#!/usr/bin/env bash
# läuft bereits in der cgroup mini-ctr – jetzt mit eigenen Namespaces
hostname mini-ctr
echo "Hostname: $(hostname), meine PID: $$"
cat /proc/self/cgroup
ip -br link
exec python3 hog.py 20
EOF
sudo bash -c 'echo $$ > /sys/fs/cgroup/mini-ctr/cgroup.procs; \
exec unshare --pid --fork --mount-proc --uts --net bash ./mini-ctr.sh'Erwartet:
100M
0
Hostname: mini-ctr, meine PID: 1
0::/mini-ctr
lo DOWN 00:00:00:00:00:00 <LOOPBACK>
20 MB belegt
40 MB belegt
60 MB belegt
80 MB belegt
unshare: sigprocmask unblock failed: Invalid argument
Gegenprobe auf dem Laptop – Docker schreibt dieselben Dateien:
docker run --rm --memory 100m --cpus 0.5 ubuntu:24.04 \
cat /sys/fs/cgroup/memory.max /sys/fs/cgroup/cpu.maxErwartet:
104857600
50000 100000
Fortschritt speichern? Kostenlos registrieren
Drill 7: systemd-Unit mit Ressourcenlimits
sudo mkdir -p /opt/fake-llm && sudo cp ~/tag01/hog.py /opt/fake-llm/
sudo tee /etc/systemd/system/fake-llm.service >/dev/null <<'EOF'
[Unit]
Description=Fake-LLM-Server (Labor Tag 1)
After=network-online.target
[Service]
ExecStart=/usr/bin/python3 -m http.server 11434 --bind 127.0.0.1
DynamicUser=yes
MemoryMax=300M
MemoryHigh=250M
CPUQuota=50%
TasksMax=64
LimitNOFILE=65536
Restart=on-failure
RestartSec=2s
[Install]
WantedBy=multi-user.target
EOF
sudo systemctl daemon-reload
sudo systemctl enable --now fake-llm.service
systemctl status fake-llm --no-pager | head -9Erwartet (gekürzt):
● fake-llm.service - Fake-LLM-Server (Labor Tag 1)
Loaded: loaded (/etc/systemd/system/fake-llm.service; enabled; ...)
Active: active (running) since Fri 2026-10-09 17:00:29 UTC; 2s ago
Main PID: 132 (python3)
Tasks: 1 (limit: 64)
Memory: 3.6M (high: 250.0M max: 300.0M available: 246.3M peak: 3.9M)
CPU: 1.370s
CGroup: /system.slice/fake-llm.service
└─132 /usr/bin/python3 -m http.server 11434 --bind 127.0.0.1
Die Brücke zu Drill 4 und 5:
CG=$(systemctl show -p ControlGroup --value fake-llm)
cat /sys/fs/cgroup$CG/memory.max /sys/fs/cgroup$CG/cpu.maxErwartet:
314572800
50000 100000
MemoryHigh drosselt (Reclaim, langsamer),
MemoryMax tötet. DynamicUser=yes startet den
Dienst unter einer flüchtigen UID ohne Root-Rechte.
Jetzt ein Dienst, der sein Limit sprengt:
sudo tee /etc/systemd/system/llm-leak.service >/dev/null <<'EOF'
[Unit]
Description=Speicherleck-Simulation (Labor Tag 1)
[Service]
ExecStart=/usr/bin/python3 /opt/fake-llm/hog.py 50
DynamicUser=yes
MemoryMax=200M
MemorySwapMax=0
Restart=on-failure
RestartSec=5s
EOF
sudo systemctl daemon-reload
sudo systemctl start llm-leak; sleep 8
sudo journalctl -u llm-leak --no-pager -o cat | head -11
systemctl show llm-leak -p NRestarts
sudo systemctl stop llm-leakErwartet:
Started llm-leak.service - Speicherleck-Simulation (Labor Tag 1).
50 MB belegt
100 MB belegt
150 MB belegt
llm-leak.service: A process of this unit has been killed by the OOM killer.
llm-leak.service: Main process exited, code=killed, status=9/KILL
llm-leak.service: Failed with result 'oom-kill'.
llm-leak.service: Consumed 1.506s CPU time.
llm-leak.service: Scheduled restart job, restart counter is at 1.
Started llm-leak.service - Speicherleck-Simulation (Labor Tag 1).
50 MB belegt
NRestarts=1
Warum? Genau dieses Muster – Start, Laden, OOM-Kill, Neustart – zeigt
ein Modellserver, dessen Modell nicht in den erlaubten RAM passt. In
Kubernetes heißt es OOMKilled und
CrashLoopBackOff (Tag 7).
Tipp: Ad hoc ohne Unit-Datei:
sudo systemd-run --unit=adhoc -p MemoryMax=200M python3 hog.py(nicht live getestet, braucht D-Bus).
Fortschritt speichern? Kostenlos registrieren
Drill 8: Last, PSI und Top-Verbraucher
cat /proc/loadavg
for r in cpu memory io; do echo "$r: $(head -1 /proc/pressure/$r)"; done
stress-ng --cpu 8 --timeout 20s >/dev/null &
sleep 15
cat /proc/loadavg
head -1 /proc/pressure/cpu
vmstat 1 3Erwartet (gekürzt, Beispielwerte, kann abweichen):
0.08 0.03 0.01 1/180 2210
cpu: some avg10=0.00 avg60=0.00 avg300=0.00 total=1998352
memory: some avg10=0.00 avg60=0.00 avg300=0.00 total=35116
io: some avg10=0.00 avg60=0.00 avg300=0.00 total=352737
6.38 2.59 1.11 9/190 2238
some avg10=46.78 avg60=16.83 avg300=4.66 total=2006413580
procs -----------memory---------- ---swap-- -----io---- -system-- -------cpu-------
r b swpd free buff cache si so bi bo in cs us sy id wa st gu
9 0 0 1327512 103800 2185652 0 0 136 735 4180 18 5 3 92 0 0 0
6 0 0 1327512 103808 2185712 0 0 0 72 7616 10237 98 2 0 0 0 0
Warum PSI statt Load? Load 6 auf 4 CPUs sagt nur „Warteschlange”.
cpu some avg10=46 heißt: in 46 % der letzten 10 s wartete
mindestens ein Task auf CPU – direkt als Latenz-Signal nutzbar. Pro
cgroup gibt es dieselben Dateien (cpu.pressure,
memory.pressure).
Wer frisst die CPU?
top -b -n 1 -o %CPU | head -12
sudo perf top -p $(pgrep -n stress-ng) --stdio 2>/dev/null | head -15Erwartet (gekürzt, kann je nach Version abweichen; perf
nicht live getestet):
top - 17:01:17 up 9:36, 0 user, load average: 6.38, 2.59, 1.11
Tasks: 25 total, 9 running, 16 sleeping, 0 stopped, 0 zombie
%Cpu(s): 95.8 us, 4.2 sy, 0.0 ni, 0.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
2234 ubuntu 20 0 47380 5512 2428 R 90.9 0.1 0:07.19 stress-ng-cpu
Tipp:
perfbraucht auf Ubuntu das zum Kernel passende Paket:sudo apt-get install linux-tools-$(uname -r). Für Python-Prozesse liefertpy-spy top --pid <pid>lesbarere Stacks.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
cat > ~/tag01/check.sh <<'EOF'
#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
check "strace vorhanden" "command -v strace"
check "cgroup v2 aktiv" "[ -f /sys/fs/cgroup/cgroup.controllers ]"
check "OOM-Kill in llm-demo gezählt" \
"grep -Eq '^oom_kill [1-9]' /sys/fs/cgroup/llm-demo/memory.events"
check "llm-cpu wurde gedrosselt" \
"grep -Eq '^nr_throttled [1-9]' /sys/fs/cgroup/llm-cpu/cpu.stat"
check "fake-llm aktiv" "systemctl is-active --quiet fake-llm"
check "MemoryMax = 300M" \
"[ \$(systemctl show -p MemoryMax --value fake-llm) = 314572800 ]"
check "Port 11434 lauscht" "ss -tln | grep -q '127.0.0.1:11434 '"
check "OOM im Journal von llm-leak" \
"sudo journalctl -u llm-leak | grep -q oom-kill"
check "PSI verfügbar" "[ -r /proc/pressure/memory ]"
EOF
bash ~/tag01/check.shErwartet:
✔ strace vorhanden
✔ cgroup v2 aktiv
✔ OOM-Kill in llm-demo gezählt
✔ llm-cpu wurde gedrosselt
✔ fake-llm aktiv
✔ MemoryMax = 300M
✔ Port 11434 lauscht
✔ OOM im Journal von llm-leak
✔ PSI verfügbar
Challenge
Ändere llm-leak.service so, dass der Dienst bei 150 MB
gedrosselt statt bei 200 MB getötet wird, und weise das
mit memory.events und memory.pressure
nach.
Hinweis: Ein Drop-in mit systemctl edit
überschreibt einzelne Werte, ohne die Unit-Datei anzufassen.
Lösung
sudo mkdir -p /etc/systemd/system/llm-leak.service.d
sudo tee /etc/systemd/system/llm-leak.service.d/throttle.conf >/dev/null <<'EOF'
[Service]
ExecStart=
ExecStart=/usr/bin/python3 /opt/fake-llm/hog.py 10
MemoryHigh=150M
MemoryMax=400M
EOF
sudo systemctl daemon-reload
sudo systemctl restart llm-leak; sleep 20
CG=/sys/fs/cgroup/system.slice/llm-leak.service
grep -E '^(high|oom_kill) ' $CG/memory.events
head -1 $CG/memory.pressure
sudo systemctl stop llm-leakErwartet (Werte variieren):
high 9832
oom_kill 0
some avg10=24.36 avg60=7.23 avg300=1.66 total=5068050
high steigt, oom_kill bleibt 0. Statt nach
20 s bei 1000 MB zu stehen, hängt der Prozess bei rund 150 MB fest: Ohne
Swap kann der Kernel anonymen Speicher nicht zurückholen und bremst jede
weitere Allokation aus. ExecStart= (leer) löscht den alten
Wert, bevor der neue gesetzt wird.
Fortschritt speichern? Kostenlos registrieren
Interview-Notiz
- „Ein Modellserver wird immer wieder neu gestartet – wie gehst du
vor?” –
journalctl -u/kubectl describeaufoom-killprüfen,memory.eventsundmemory.peaklesen, dann Modellgröße plus KV-Cache gegen das Limit rechnen (Tag 5). - Container sind keine VMs: Namespaces für die Sicht, cgroups für die Grenzen, ein gemeinsamer Kernel.
- CPU-Limits erzeugen Throttling, das als Latenz sichtbar wird – PSI
und
nr_throttledsind die Belege. - Brücke: Bei OpenShift-Kunden mit Vault-Agent-Sidecars war
OOMKilleddurch zu knapp gesetzte Limits ein Klassiker – die Diagnose lief genau über diese cgroup-Zähler.
Enterprise-Notiz
- Echte Modellserver brauchen RAM für Gewichte plus
KV-Cache, der mit Kontextlänge und Parallelität wächst – Limits mit
Lasttest (Tag 3,
llmctl load) ermitteln. - GPU-Speicher steht nicht in cgroups: VRAM-OOM zeigt sich als Fehler im Serverlog (CUDA out of memory), nicht als Kernel-OOM.
LimitNOFILE,TasksMaxund Kernel-Parameter (net.core.somaxconn) per Konfigurationsmanagement setzen (Ansible, Tag 12).- On-prem beim Kunden: oft cgroup v1 auf älteren RHEL-Systemen – Pfade
und Dateinamen unterscheiden sich
(
memory.limit_in_bytes). - strace und perf brauchen Root und erzeugen Last; in regulierten Umgebungen vorher freigeben lassen.