Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 2: Netzwerk-Debugging

Ziel: Langsame oder abbrechende LLM-Anfragen Schicht für Schicht zerlegen: Sockets, DNS, TCP, TLS, MTU, Firewall und Streaming · Dauer: ca. 120 min · Voraussetzung: Tag 1

Briefing

  • Bei LLM-APIs zählen zwei Latenzen: TTFT (Zeit bis zum ersten Token) und die Zeit pro Token. Netzwerkprobleme treffen vor allem die TTFT.
  • curl -w zerlegt eine Anfrage in DNS, Connect, TLS und erstes Byte.
  • Streaming läuft per Server-Sent Events (data: ...-Zeilen). Puffert irgendwer dazwischen, kommt alles auf einmal.
  • Werkzeugkette von unten nach oben: ip/ss → dig → tcpdump → nft/conntrack → openssl → curl.
Client ─DNS─► ─TCP-Handshake─► ─TLS─► ─HTTP-Request─► Header ─► data: ... ─► [DONE]
         dns    connect          tls                   ttfb      TTFT        total

Alle Drills laufen auf der VM. Als Ziel dient ein Mini-Server, der wie ein LLM Tokens streamt.

Drill 1: Labor, Sockets und Routen

mkdir -p ~/tag02 && cd ~/tag02
cat > sse_server.py <<'EOF'
"""Mini-Server, der wie ein LLM Tokens per Server-Sent Events streamt."""
import json
import sys
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

PORT = int(sys.argv[1]) if len(sys.argv) > 1 else 8081
TOKENS = ["Bonjour", ",", " je", " suis", " un", " modèle", " de", " test", "."]


class Handler(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"

    def do_GET(self):
        if self.path == "/healthz":
            self.send_response(200)
            self.send_header("Content-Length", "3")
            self.end_headers()
            self.wfile.write(b"ok\n")
            return
        self.send_response(200)
        self.send_header("Content-Type", "text/event-stream")
        self.send_header("Connection", "close")
        self.end_headers()  # Header gehen sofort raus
        time.sleep(0.8)  # "Prefill": Zeit bis zum ersten Token
        try:
            for tok in TOKENS:
                chunk = {"choices": [{"delta": {"content": tok}}]}
                line = "data: " + json.dumps(chunk, ensure_ascii=False) + "\n\n"
                self.wfile.write(line.encode())
                time.sleep(0.2)  # "Decode": Zeit pro Token
            self.wfile.write(b"data: [DONE]\n\n")
        except (BrokenPipeError, ConnectionResetError):
            pass  # Client hat abgebrochen
        self.close_connection = True


if __name__ == "__main__":
    ThreadingHTTPServer(("0.0.0.0", PORT), Handler).serve_forever()
EOF
python3 sse_server.py 8081 2>sse.log &
python3 -m http.server 8080 >/dev/null 2>&1 &
sleep 1
ss -tlnp

Erwartet (PIDs variieren):

State  Recv-Q Send-Q Local Address:Port Peer Address:PortProcess
LISTEN 0      5      0.0.0.0:8081   0.0.0.0:*   users:(("python3",pid=5402,fd=3))
LISTEN 0      5      0.0.0.0:8080   0.0.0.0:*   users:(("python3",pid=5403,fd=3))

Tipp: ss -tlnp heißt TCP, Listen, numerisch, Prozess. Ohne sudo siehst du den Prozess nur bei eigenen Sockets.

Aktive Verbindungen und der Weg nach draußen:

curl -sN localhost:8081/v1/stream >/dev/null &
sleep 0.3
ss -tnp state established '( sport = :8081 or dport = :8081 )'
ip -br addr
ip route get 1.1.1.1

Erwartet (gekürzt, Adressen und Interface-Namen variieren):

Recv-Q Send-Q Local Address:Port  Peer Address:Port Process
0      0          127.0.0.1:8081     127.0.0.1:51482 users:(("python3",pid=5402,fd=4))
0      0          127.0.0.1:51482    127.0.0.1:8081  users:(("curl",pid=5412,fd=5))
lo               UNKNOWN        127.0.0.1/8 ::1/128
enp0s1           UP             192.168.64.5/24 ...
1.1.1.1 via 192.168.64.1 dev enp0s1 src 192.168.64.5 uid 1000
    cache

Warum? ip route get zeigt, welche Route, welches Interface und welche Quell-IP der Kernel für ein Ziel wirklich wählt – die erste Frage bei „vom Server aus nicht erreichbar”.

Fortschritt speichern? Kostenlos registrieren

Drill 2: DNS und die ndots-Falle

grep -v '^#' /etc/resolv.conf
dig +short api.mistral.ai
dig api.mistral.ai | grep -E 'status|Query time|SERVER'
getent hosts api.mistral.ai

Erwartet (Adressen und Resolver variieren, kann je nach Version abweichen):

nameserver 127.0.0.53
options edns0 trust-ad
172.66.2.203
162.159.142.207
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 3224
;; Query time: 3 msec
;; SERVER: 127.0.0.53#53(127.0.0.53) (UDP)
172.66.2.203    api.mistral.ai
162.159.142.207 api.mistral.ai

Warum getent? dig fragt DNS direkt; getent nutzt wie jede Anwendung die libc samt /etc/hosts und Suchdomains. Weichen beide ab, liegt das Problem in der Resolver-Konfiguration.

Jetzt die Kubernetes-Falle nachbauen: Pods haben ndots:5 und drei Suchdomains. Ein eigener Mount-Namespace (Tag 1) tauscht resolv.conf nur für einen Befehl aus:

cat > resolv-k8s.conf <<'EOF'
nameserver 1.1.1.1
search llm-system.svc.cluster.local svc.cluster.local cluster.local
options ndots:5
EOF
sudo unshare --mount bash -c '
  mount --bind resolv-k8s.conf /etc/resolv.conf
  dig +search +showsearch api.mistral.ai | grep -E "^;api|status:"
  time getent hosts api.mistral.ai
  time getent hosts api.mistral.ai.'

Erwartet (gekürzt, Zeiten variieren):

;; ->>HEADER<<- opcode: QUERY, status: NXDOMAIN, id: 36298
;api.mistral.ai.llm-system.svc.cluster.local. IN    A
;; ->>HEADER<<- opcode: QUERY, status: NXDOMAIN, id: 4130
;api.mistral.ai.svc.cluster.local. IN   A
;; ->>HEADER<<- opcode: QUERY, status: NXDOMAIN, id: 3477
;api.mistral.ai.cluster.local.  IN  A
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 49482
;api.mistral.ai.            IN  A
2a06:98c1:58::2c3 api.mistral.ai
real    0m0.046s
2606:4700:7::2c3 api.mistral.ai
real    0m0.012s

Warum? api.mistral.ai hat nur zwei Punkte (< 5), also probiert die libc erst alle Suchdomains – für A und AAAA. Vier Runden statt einer. Antwortet ein Upstream-Resolver auf .local-Namen gar nicht, wird daraus 3 × 5 s Timeout: In einem Testlauf für dieses Buch dauerte genau dieser Lookup 15 s. Abhilfe: FQDN mit Punkt am Ende oder dnsConfig.options ndots: 2 im Pod.

Fortschritt speichern? Kostenlos registrieren

Drill 3: curl-Timings zerlegen

cat > curl-timing.txt <<'EOF'
     dns: %{time_namelookup}s\n
 connect: %{time_connect}s\n
     tls: %{time_appconnect}s\n
    ttfb: %{time_starttransfer}s\n
   total: %{time_total}s\n
    code: %{http_code}  ip: %{remote_ip}  http: %{http_version}\n
EOF
curl -s -o /dev/null -w @curl-timing.txt http://localhost:8080/
curl -s -o /dev/null -w @curl-timing.txt https://api.mistral.ai/v1/models

Erwartet (Zeiten variieren):

     dns: 0.000112s
 connect: 0.002777s
     tls: 0.000000s
    ttfb: 0.020348s
   total: 0.020554s
    code: 200  ip: 127.0.0.1  http: 1
     dns: 0.010194s
 connect: 0.033784s
     tls: 0.150215s
    ttfb: 0.213559s
   total: 0.213683s
    code: 401  ip: 162.159.142.207  http: 2

Warum 401? Ohne MISTRAL_API_KEY lehnt die API ab – für die Netzwerkanalyse reicht das. Die Werte sind kumulativ: TLS-Handshake = tls − connect ≈ 116 ms, Serverzeit = ttfb − tls ≈ 63 ms.

Feld hoch Typische Ursache
dns ndots, langsamer Resolver, kein Cache
connect Entfernung, SYN-Verlust, volle Accept-Queue
tls weite Strecke (mehrere RTTs), OCSP, große Zertifikatskette
ttfb − tls Server: Warteschlange, Prefill, Proxy

Fortschritt speichern? Kostenlos registrieren

Drill 4: Streaming, TTFB und TTFT

curl -s -o /dev/null -w 'ttfb: %{time_starttransfer}s  total: %{time_total}s\n' \
  localhost:8081/v1/stream

Erwartet (Zeiten variieren):

ttfb: 0.045885s  total: 2.657053s

TTFB ist winzig – aber der Nutzer sieht in dieser Zeit noch kein Wort. Zeitstempel pro Event zeigen die Wahrheit:

t0=${EPOCHREALTIME/./}
curl -sN localhost:8081/v1/stream | while IFS= read -r line; do
  [ -n "$line" ] && echo "$(( (${EPOCHREALTIME/./} - t0) / 1000 )) ms  $line"
done

Erwartet (Zeiten variieren):

851 ms  data: {"choices": [{"delta": {"content": "Bonjour"}}]}
1051 ms  data: {"choices": [{"delta": {"content": ","}}]}
1251 ms  data: {"choices": [{"delta": {"content": " je"}}]}
...
2455 ms  data: {"choices": [{"delta": {"content": "."}}]}
2660 ms  data: [DONE]

Warum? Viele Server schicken die Header sofort und rechnen danach den Prefill. TTFB ≠ TTFT – TTFT misst man am ersten data:-Event. EPOCHREALTIME liefert in bash Mikrosekunden.

Jetzt ohne -N:

t0=${EPOCHREALTIME/./}
curl -s localhost:8081/v1/stream | while IFS= read -r line; do
  [ -n "$line" ] && echo "$(( (${EPOCHREALTIME/./} - t0) / 1000 )) ms  ${line:0:40}"
done

Erwartet (Zeiten variieren):

3066 ms  data: {"choices": [{"delta": {"content":
3068 ms  data: {"choices": [{"delta": {"content":
3068 ms  data: {"choices": [{"delta": {"content":
...
3071 ms  data: [DONE]

Warum? Ohne -N puffert curl die Ausgabe in eine Pipe – alle Tokens kommen am Ende. Genau so sieht es aus, wenn ein Reverse Proxy (nginx proxy_buffering on) oder ein Ingress zwischen Client und Modellserver puffert.

Fortschritt speichern? Kostenlos registrieren

Drill 5: tcpdump – Pakete sehen

Terminal 2 (zweites multipass shell llm-vm):

sudo tcpdump -i lo -nn 'tcp port 8081'

Terminal 1:

curl -s localhost:8081/healthz >/dev/null

Erwartet in Terminal 2 (gekürzt, Optionen weggelassen):

IP6 ::1.50252 > ::1.8081: Flags [S], seq 1423346825, win 65476, length 0
IP6 ::1.8081 > ::1.50252: Flags [R.], seq 0, ack 1423346826, win 0, length 0
IP 127.0.0.1.59594 > 127.0.0.1.8081: Flags [S], seq 2858746014, win 65495, length 0
IP 127.0.0.1.8081 > 127.0.0.1.59594: Flags [S.], seq 2650071215, ack 2858746015, ...
IP 127.0.0.1.59594 > 127.0.0.1.8081: Flags [.], ack 1, win 512, length 0
IP 127.0.0.1.59594 > 127.0.0.1.8081: Flags [P.], seq 1:85, ack 1, win 512, length 84
IP 127.0.0.1.8081 > 127.0.0.1.59594: Flags [P.], seq 1:112, ack 85, win 512, length 111

Warum zuerst IPv6? localhost löst auch auf ::1 auf; der Server lauscht nur auf IPv4 und antwortet mit Reset (R). curl fällt still auf IPv4 zurück. Bei „manchmal langsam” mit Happy-Eyeballs-Problemen ist genau das die Spur. S = SYN, S. = SYN-ACK, . = ACK, P. = Daten.

Mitschnitt in Datei, später auswerten (Ctrl+C in Terminal 2 vorher):

sudo tcpdump -i lo -nn -w sse.pcap 'tcp port 8081' 2>/dev/null &
sleep 1
curl -sN 127.0.0.1:8081/v1/stream >/dev/null
sudo pkill tcpdump; sleep 0.5
tcpdump -r sse.pcap -nn -A 2>/dev/null | grep -oE '(GET |data: ).{0,40}' | head -3
tcpdump -r sse.pcap -nn -tt 2>/dev/null | grep 'length [1-9]' \
  | awk '{print $1, $3, $4, $5, $NF}' | head -4

Erwartet (Zeitstempel variieren):

GET /v1/stream HTTP/1.1
data: {"choices": [{"delta": {"content": "Bonj
data: {"choices": [{"delta": {"content": ","}}
1791565637.349106 127.0.0.1.35896 > 127.0.0.1.8081: 86
1791565637.349559 127.0.0.1.8081 > 127.0.0.1.35896: 144
1791565638.150762 127.0.0.1.8081 > 127.0.0.1.35896: 56
1791565638.350948 127.0.0.1.8081 > 127.0.0.1.35896: 50

Request (86 Byte), Header (144 Byte) nach 0,5 ms, erstes Token 0,8 s später: TTFT direkt auf Paketebene. Die .pcap-Datei öffnest du auf dem Laptop in Wireshark.

Sicherheit: Mitschnitte enthalten Prompts, Antworten und ggf. API-Keys im Klartext (bei HTTP). Beim Kunden nur mit Freigabe, gefiltert und mit Löschfrist.

Fortschritt speichern? Kostenlos registrieren

Drill 6: nftables und conntrack

sudo nft add table inet lab
sudo nft add chain inet lab input \
  '{ type filter hook input priority 0; policy accept; }'
sudo nft add rule inet lab input tcp dport 8081 counter drop
curl -s -m 3 127.0.0.1:8081/healthz; echo "curl exit=$?"
sudo nft flush chain inet lab input
sudo nft add rule inet lab input tcp dport 8081 counter reject with tcp reset
curl -s -m 3 127.0.0.1:8081/healthz; echo "curl exit=$?"
sudo nft list chain inet lab input | grep counter

Erwartet:

curl exit=28
curl exit=7
        tcp dport 8081 counter packets 1 bytes 60 reject with tcp reset

Warum? drop = Timeout (Exit 28, Client wartet), reject = sofort „Connection refused” (Exit 7). Ein Timeout kostet bei einem LLM-Client die volle Wartezeit plus Retries – ein schnelles Reject ist für Fehlerdiagnose und Failover besser.

Der Kernel merkt sich jede Verbindung in der Conntrack-Tabelle:

sudo nft flush chain inet lab input
sudo nft add rule inet lab input ct state established,related counter accept
curl -sN 127.0.0.1:8081/v1/stream >/dev/null &
sleep 0.5
sudo conntrack -L -p tcp --dport 8081
cat /proc/sys/net/netfilter/nf_conntrack_count /proc/sys/net/netfilter/nf_conntrack_max
sudo nft delete table inet lab

Erwartet (gekürzt, Werte variieren):

tcp      6 431999 ESTABLISHED src=127.0.0.1 dst=127.0.0.1 sport=35364 dport=8081
  src=127.0.0.1 dst=127.0.0.1 sport=8081 dport=35364 [ASSURED] mark=0 use=1
conntrack v1.4.8 (conntrack-tools): 1 flow entries have been shown.
1
262144

Warum? Lange Streams und viele kurze Verbindungen füllen die Tabelle. Ist nf_conntrack_count am Maximum, verwirft der Kernel neue Verbindungen (nf_conntrack: table full, dropping packet in dmesg).

Fortschritt speichern? Kostenlos registrieren

Drill 7: Latenz, Verlust und MTU

Latenz einschleusen mit tc netem:

F='connect=%{time_connect} ttfb=%{time_starttransfer} total=%{time_total}\n'
curl -s -o /dev/null -w "$F" 127.0.0.1:8081/healthz
sudo tc qdisc add dev lo root netem delay 100ms
tc qdisc show dev lo
curl -s -o /dev/null -w "$F" 127.0.0.1:8081/healthz
ping -c 2 -q 127.0.0.1 | tail -1

Erwartet:

connect=0.000219 ttfb=0.003968 total=0.004029
qdisc netem 8001: root refcnt 2 limit 1000 delay 100ms
connect=0.200498 ttfb=0.402358 total=0.602564
rtt min/avg/max/mdev = 200.081/200.121/200.162/0.040 ms

Auf lo trifft die Verzögerung beide Richtungen: 100 ms Delay = 200 ms RTT. Connect kostet 1 RTT, die Anfrage eine weitere. Jetzt Jitter und Paketverlust:

sudo tc qdisc change dev lo root netem delay 50ms 20ms loss 10%
for i in 1 2 3 4 5; do curl -s -o /dev/null -w "$F" 127.0.0.1:8081/healthz; done
sudo tc qdisc del dev lo root

Erwartet (zufällig, Werte variieren):

connect=0.123407 ttfb=0.223478 total=0.605717
connect=1.102311 ttfb=1.211517 total=1.314222
connect=0.111328 ttfb=0.191800 total=0.268595
connect=0.098215 ttfb=0.198379 total=0.287373
connect=0.112495 ttfb=0.710311 total=0.710376

Warum connect=1.1? Ein verlorenes SYN wird erst nach 1 s erneut gesendet. 10 % Verlust erzeugen so Ausreißer im p99 – nicht im Mittelwert.

MTU-Problem nachbauen mit zwei Netz-Namespaces und einem veth-Kabel:

sudo ip netns add mtu-a; sudo ip netns add mtu-b
sudo ip link add va type veth peer name vb
sudo ip link set va netns mtu-a; sudo ip link set vb netns mtu-b
sudo ip -n mtu-a addr add 10.99.0.1/24 dev va
sudo ip -n mtu-b addr add 10.99.0.2/24 dev vb
sudo ip -n mtu-a link set va up; sudo ip -n mtu-b link set vb up
sudo ip -n mtu-b link set vb mtu 1400
sudo ip netns exec mtu-a ping -c1 -W1 -M do -s 1372 10.99.0.2 | grep loss
sudo ip netns exec mtu-a ping -c1 -W1 -M do -s 1472 10.99.0.2 | grep loss

Erwartet:

1 packets transmitted, 1 received, 0% packet loss, time 0ms
ping: sendmsg: No buffer space available
1 packets transmitted, 0 received, 100% packet loss, time 1005ms

Warum 1372 und 1472? 20 Byte IP- plus 8 Byte ICMP-Header: -s 1372 ergibt ein 1400-Byte-Paket. -M do verbietet Fragmentierung. So findest du die Path-MTU per Bisektion. Typischer Fall beim Kunden: VPN oder Overlay-Netz (VXLAN, -50 Byte) und blockiertes ICMP – kleine Requests klappen, große Prompts oder Antworten hängen.

sudo ip netns del mtu-a; sudo ip netns del mtu-b

Fortschritt speichern? Kostenlos registrieren

Drill 8: TLS und Zertifikate

openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:P-256 -nodes \
  -keyout llm.key -out llm.crt -days 30 -subj "/CN=llm-vm.lab" \
  -addext "subjectAltName=DNS:llm-vm.lab,DNS:localhost,IP:127.0.0.1"
openssl x509 -in llm.crt -noout -subject -dates -ext subjectAltName
openssl x509 -in llm.crt -noout -checkend $((60*86400)); echo "checkend=$?"

Erwartet (Daten variieren):

subject=CN = llm-vm.lab
notBefore=Oct  9 17:08:30 2026 GMT
notAfter=Nov  8 17:08:30 2026 GMT
X509v3 Subject Alternative Name:
    DNS:llm-vm.lab, DNS:localhost, IP Address:127.0.0.1
Certificate will expire
checkend=1

-checkend mit Exit-Code eignet sich direkt für Monitoring-Skripte: Läuft das Zertifikat in 60 Tagen ab? Ja (30 Tage gültig).

TLS-Server starten und prüfen:

openssl s_server -accept 8443 -cert llm.crt -key llm.key -www -quiet \
  >/dev/null 2>&1 &
sleep 1
echo | openssl s_client -brief -connect 127.0.0.1:8443 -servername llm-vm.lab 2>&1 \
  | head -5
echo | openssl s_client -brief -connect 127.0.0.1:8443 -CAfile llm.crt \
  -verify_hostname api.lab 2>&1 | grep 'verify error'
curl -s https://localhost:8443/ -o /dev/null; echo "curl exit=$?"
curl -s --cacert llm.crt https://localhost:8443/ -o /dev/null -w '%{http_code}\n'

Erwartet:

depth=0 CN = llm-vm.lab
verify error:num=18:self-signed certificate
CONNECTION ESTABLISHED
Protocol version: TLSv1.3
Ciphersuite: TLS_AES_256_GCM_SHA384
verify error:num=62:hostname mismatch
curl exit=60
200

Warum? Exit 60 = curl vertraut der CA nicht. Mit --cacert klappt es. hostname mismatch heißt: Der Name steht nicht im SAN – der CN allein zählt bei modernen Clients nicht mehr.

Ein echtes Zertifikat ansehen:

echo | openssl s_client -connect api.mistral.ai:443 -servername api.mistral.ai \
  2>/dev/null | openssl x509 -noout -subject -issuer -enddate

Erwartet (Aussteller und Datum ändern sich):

subject=CN = api.mistral.ai
issuer=C = US, O = Google Trust Services, CN = WE1
notAfter=Nov 21 01:57:54 2026 GMT

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

cat > ~/tag02/check.sh <<'EOF'
#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
cd ~/tag02

check "SSE-Server lauscht auf 8081" "ss -tln | grep -q ':8081 '"
check "Stream endet mit [DONE]" \
  "curl -sN -m 5 localhost:8081/v1/stream | grep -q 'DONE'"
check "DNS löst api.mistral.ai auf" "[ -n \"\$(dig +short api.mistral.ai)\" ]"
check "kein netem mehr auf lo" "! tc qdisc show dev lo | grep -q netem"
check "nft-Tabelle lab entfernt" "! sudo nft list tables | grep -q 'inet lab'"
check "Netns aufgeräumt" "[ -z \"\$(ip netns list)\" ]"
check "pcap vorhanden" "[ -s sse.pcap ]"
check "Zertifikat noch 1 Tag gültig" "openssl x509 -in llm.crt -noout -checkend 86400"
check "TLS mit eigener CA ok" "curl -sf --cacert llm.crt https://localhost:8443/"
EOF
bash ~/tag02/check.sh

Erwartet:

✔ SSE-Server lauscht auf 8081
✔ Stream endet mit [DONE]
✔ DNS löst api.mistral.ai auf
✔ kein netem mehr auf lo
✔ nft-Tabelle lab entfernt
✔ Netns aufgeräumt
✔ pcap vorhanden
✔ Zertifikat noch 1 Tag gültig
✔ TLS mit eigener CA ok

Challenge

Schreibe ttft.sh URL, das für einen SSE-Stream TTFB, TTFT, Gesamtdauer und Anzahl der Tokens in einer Anfrage ausgibt. Miss dann mit und ohne 100 ms netem-Delay auf lo.

Hinweis: curl -w schreibt seine Ausgabe nach dem Body – also als letzte Zeile in denselben Stream.

Lösung

cat > ~/tag02/ttft.sh <<'EOF'
#!/usr/bin/env bash
# Misst TTFB (Header), TTFT (erstes data:-Event) und Dauer eines SSE-Streams
set -euo pipefail
url=${1:?Usage: ttft.sh URL}
ms() { echo $(( (${EPOCHREALTIME/./} - t0) / 1000 )); }

t0=${EPOCHREALTIME/./}
ttft=""; n=0; ttfb=""
while IFS= read -r line; do
  case $line in
    "data: [DONE]") ;;
    data:*) n=$((n + 1)); [ -z "$ttft" ] && ttft=$(ms) ;;
    TTFB=*) ttfb=${line#TTFB=} ;;
  esac
done < <(curl -sN -w "\nTTFB=%{time_starttransfer}\n" "$url")
echo "ttfb=${ttfb}s ttft=${ttft}ms total=$(ms)ms tokens=${n}"
EOF
chmod +x ~/tag02/ttft.sh
~/tag02/ttft.sh http://127.0.0.1:8081/v1/stream
sudo tc qdisc add dev lo root netem delay 100ms
~/tag02/ttft.sh http://127.0.0.1:8081/v1/stream
sudo tc qdisc del dev lo root

Erwartet (Zeiten variieren):

ttfb=0.005822s ttft=828ms total=2784ms tokens=9
ttfb=0.410900s ttft=1253ms total=3113ms tokens=9

Die Netzlatenz addiert sich auf TTFB und TTFT (2 RTT = 400 ms), die Zeit pro Token bleibt gleich – sie entsteht im Modell, nicht im Netz. Das Skript ist die Keimzelle für llmctl load (Tag 3).

Fortschritt speichern? Kostenlos registrieren

Interview-Notiz

  • „Kunde meldet: Antworten kommen langsam” – erst klären: TTFT oder Tokens/s? TTFT → Netz, DNS, TLS, Warteschlange, Prefill. Tokens/s → Modell, GPU, Batching.
  • „Streaming kommt beim Kunden in einem Block an” – fast immer Pufferung in Proxy, Ingress oder WAF; mit curl -N direkt am Modellserver und hinter jedem Hop vergleichen.
  • Vorgehen von unten nach oben: Route und Socket, DNS, TCP (tcpdump), Firewall/conntrack, TLS, HTTP – jede Schicht mit einem Befehl belegen statt raten.
  • Brücke: Bei Vault-Rollouts in regulierten Netzen waren TLS-Inspection-Proxies und abgelaufene interne CAs die häufigsten Störungen – openssl s_client war das erste Werkzeug.

Enterprise-Notiz

  • Kunden-Netze haben Proxies, TLS-Inspection und eigene CAs: CA-Bundle in Container-Images und Clients verteilen (SSL_CERT_FILE, REQUESTS_CA_BUNDLE).
  • Für SSE: proxy_buffering off und lange Read-Timeouts (Minuten) auf allen Proxies, Load Balancern und Ingress-Controllern.
  • ndots und CoreDNS-Caching in Kubernetes anpassen; externe Endpunkte als FQDN mit Punkt konfigurieren.
  • conntrack- und Socket-Limits (nf_conntrack_max, somaxconn) bei Gateways mit vielen langen Streams per Ansible setzen (Tag 12).
  • Paketmitschnitte nur mit schriftlicher Freigabe; bevorzugt Metriken (Tag 8) und Traces (Tag 9) statt pcap.