Zum Inhalt springen
Trainingslager IT-Trainingslager

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 11434

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

Erwartet (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 files bei vielen gleichzeitigen Streams? Erst /proc/<pid>/limits prüfen, dann ls /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 = :11434

Erwartet:

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 $PID

Erwartet (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:80

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

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

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

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

Erwartet:

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 -9

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

Erwartet:

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-leak

Erwartet:

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 3

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

Erwartet (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: perf braucht auf Ubuntu das zum Kernel passende Paket: sudo apt-get install linux-tools-$(uname -r). Für Python-Prozesse liefert py-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.sh

Erwartet:

✔ 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-leak

Erwartet (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 describe auf oom-kill prüfen, memory.events und memory.peak lesen, 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_throttled sind die Belege.
  • Brücke: Bei OpenShift-Kunden mit Vault-Agent-Sidecars war OOMKilled durch 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, TasksMax und 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.