Tag 8: Observability I – Metriken
Ziel: Prometheus scrapt das llm-gateway, du beantwortest die wichtigsten Betriebsfragen per PromQL und lieferst Regeln und Dashboard als Code aus. · Dauer: ca. 150 min · Voraussetzung: Tag 7
Briefing
- kube-prometheus-stack (kps) bringt Prometheus Operator, Prometheus, Alertmanager, Grafana, node-exporter und kube-state-metrics mit.
- Der Operator liest CRDs:
ServiceMonitor(was scrapen),PrometheusRule(Regeln),ScrapeConfig(Ziele außerhalb des Clusters). - Vier Fragen beim LLM-Serving: Wie viel Last pro Mandant? Wie viele Fehler? Wie langsam? Wie viele Tokens?
- Labels kosten Speicher: jede neue Label-Kombination ist eine neue Zeitreihe.
llm-system monitoring
┌───────────────────┐ scrape ┌──────────────┐ query ┌─────────┐
│ llm-gateway:8080 │◄──────────│ Prometheus │◄────────│ Grafana │
│ /metrics │ Service- │ + Rules │ └─────────┘
└───────────────────┘ Monitor └──────┬───────┘
llm-vm:9100 (node-exporter) ◄──────────┘ ScrapeConfig
Drill 1: kube-prometheus-stack schlank installieren
Die Values liegen in
~/sre-lab/code/observability/helm/kps-values.yaml:
prometheus:
prometheusSpec:
retention: 2d
retentionSize: 2GB
scrapeInterval: 15s
evaluationInterval: 15s
# auch ServiceMonitors/Regeln ohne Label release=kps auswählen
serviceMonitorSelectorNilUsesHelmValues: false
podMonitorSelectorNilUsesHelmValues: false
ruleSelectorNilUsesHelmValues: false
scrapeConfigSelectorNilUsesHelmValues: false
resources:
requests: { cpu: 100m, memory: 400Mi }
limits: { memory: 1Gi }
alertmanager:
alertmanagerSpec:
retention: 24h
grafana:
adminPassword: lab-admin # Lab-Wert, nie in Produktion
sidecar:
dashboards: { enabled: true, label: grafana_dashboard, searchNamespace: ALL }
# kind betreibt diese Komponenten nur auf localhost -> Targets wären "down"
kubeEtcd: { enabled: false }
kubeControllerManager: { enabled: false }
kubeScheduler: { enabled: false }
kubeProxy: { enabled: false }(Gekürzt – die Datei enthält zusätzlich Requests und die passenden
defaultRules-Schalter.)
mkdir -p ~/sre-lab/tag08 && cd ~/sre-lab/tag08
OBS=~/sre-lab/code/observability
helm repo add prometheus-community \
https://prometheus-community.github.io/helm-charts
helm repo update prometheus-community
helm template kps prometheus-community/kube-prometheus-stack --version 92.2.0 \
-n monitoring -f $OBS/helm/kps-values.yaml | grep '^kind:' | sort | uniq -c \
| sort -rn | head -5
helm upgrade --install kps prometheus-community/kube-prometheus-stack \
--version 92.2.0 -n monitoring --create-namespace \
-f $OBS/helm/kps-values.yaml --wait --timeout 10m
kubectl -n monitoring get podsErwartet (helm template live geprüft, Pod-Liste gekürzt,
kann je nach Version abweichen):
30 kind: PrometheusRule
29 kind: ConfigMap
9 kind: ServiceMonitor
8 kind: ServiceAccount
7 kind: Service
Release "kps" does not exist. Installing it now.
NAME READY STATUS RESTARTS AGE
alertmanager-kps-kube-prometheus-stack-alertmanager-0 2/2 Running 0 60s
kps-grafana-6d8f9c7b5d-x7k2p 3/3 Running 0 70s
kps-kube-prometheus-stack-operator-5b7c9d-qx2mz 1/1 Running 0 70s
kps-kube-state-metrics-7f6d5c8b9-l4m8n 1/1 Running 0 70s
kps-prometheus-node-exporter-4xk9p 1/1 Running 0 70s
prometheus-kps-kube-prometheus-stack-prometheus-0 2/2 Running 0 60s
Warum *SelectorNilUsesHelmValues: false? Sonst wählt
Prometheus nur Objekte mit dem Label release: kps – dein
ServiceMonitor in llm-system würde stillschweigend
ignoriert.
Fortschritt speichern? Kostenlos registrieren
Drill 2: ServiceMonitor für das Gateway
cat $OBS/k8s/servicemonitor-llm-gateway.yaml
kubectl apply -f $OBS/k8s/servicemonitor-llm-gateway.yaml
kubectl -n llm-system get svc -l app.kubernetes.io/name=llm-gateway \
-o jsonpath='{.items[0].spec.ports[0].name}{"\n"}'Erwartet (Datei gekürzt):
spec:
selector:
matchLabels:
app.kubernetes.io/name: llm-gateway
namespaceSelector:
matchNames: [llm-system]
endpoints:
- port: http # Name des Service-Ports, nicht die Nummer
path: /metrics
interval: 15s
servicemonitor.monitoring.coreos.com/llm-gateway created
http
Hat llm-system eine Default-Deny-Policy (Tag 6/7),
braucht Prometheus eine Ingress-Erlaubnis:
kubectl apply -f - <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-scrape-from-monitoring
namespace: llm-system
spec:
podSelector:
matchLabels: {app.kubernetes.io/name: llm-gateway}
policyTypes: [Ingress]
ingress:
- from:
- namespaceSelector:
matchLabels: {kubernetes.io/metadata.name: monitoring}
ports:
- {protocol: TCP, port: 8080}
EOF
kubectl -n monitoring port-forward svc/kps-kube-prometheus-stack-prometheus \
9090:9090 >/dev/null 2>&1 &
sleep 30
curl -s localhost:9090/api/v1/targets | jq -r '.data.activeTargets[]
| select(.labels.job=="llm-gateway") | "\(.scrapeUrl) \(.health)"'Erwartet (gekürzt, kann je nach Version abweichen):
networkpolicy.networking.k8s.io/allow-scrape-from-monitoring created
http://10.244.1.7:8080/metrics up
Warum port: http statt 8080? Der
ServiceMonitor wählt Endpoints über den Port-Namen des
Service. Ändert sich die Nummer, bleibt das Monitoring intakt.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Last erzeugen und Anfragen pro Mandant zählen
kubectl -n llm-system port-forward svc/llm-gateway 8080:8080 >/dev/null 2>&1 &
export LLMCTL_URL=http://127.0.0.1:8080
LLMCTL_API_KEY=lab-key-acme llmctl load -n 200 -c 2 >/dev/null &
LLMCTL_API_KEY=lab-key-globex llmctl load -n 200 -c 20 >/dev/null &
curl -s -o /dev/null -w '%{http_code}\n' -H 'Authorization: Bearer falsch' \
$LLMCTL_URL/v1/models
pq() { # PromQL-Instant-Query, Ergebnis kompakt und auf 3 Stellen gerundet
curl -s localhost:9090/api/v1/query --data-urlencode "query=$1" | jq -r \
'.data.result[] | "\(.metric | del(.__name__) | tostring) \(.value[1]
| tonumber * 1000 | round / 1000)"'
}
sleep 120
pq 'sum by (tenant) (rate(gateway_requests_total[5m]))'
pq 'sum by (tenant, code) (increase(gateway_requests_total[5m]))'Erwartet (Beispielwerte, hängen von deiner Last ab):
401
{"tenant":"acme"} 1.6
{"tenant":"globex"} 2.741
{"tenant":"unknown"} 0.166
{"code":"200","tenant":"acme"} 286.829
{"code":"502","tenant":"acme"} 42.784
{"code":"200","tenant":"globex"} 503.43
{"code":"401","tenant":"unknown"} 42.543
{"code":"429","tenant":"globex"} 186.381
Warum rate() und nie den rohen Counter? Counter steigen
nur und springen beim Pod-Neustart auf 0. rate() rechnet
Resets heraus und liefert „pro Sekunde”. increase() ist
rate() mal Fensterlänge – deshalb die krummen Zahlen.
Für 5xx kurz den Modellserver wegnehmen (Variante A aus Tag 7; bei
Variante B stattdessen Ollama auf llm-vm bzw. dem Laptop
kurz stoppen):
kubectl -n llm-system scale deploy/ollama --replicas=0
LLMCTL_API_KEY=lab-key-acme llmctl load -n 30 -c 2 >/dev/null
kubectl -n llm-system scale deploy/ollama --replicas=1Fortschritt speichern? Kostenlos registrieren
Drill 4: Fehlerquote, Latenz, Tokens, Rate-Limit
pq 'sum by (tenant) (rate(gateway_requests_total{code=~"5.."}[5m]))
/ sum by (tenant) (rate(gateway_requests_total[5m]))'
pq 'histogram_quantile(0.95,
sum by (tenant, le) (rate(gateway_request_duration_seconds_bucket[5m])))'
pq 'sum by (tenant) (rate(gateway_request_duration_seconds_sum[5m]))
/ sum by (tenant) (rate(gateway_request_duration_seconds_count[5m]))'
pq 'sum by (tenant, type) (rate(gateway_tokens_total[5m]))'
pq 'sum by (tenant) (rate(gateway_ratelimited_total[5m]))
/ sum by (tenant) (rate(gateway_requests_total[5m]))'Erwartet (Beispielwerte):
{"tenant":"acme"} 0.104
{"tenant":"acme"} 1.023
{"tenant":"globex"} 0.948
{"tenant":"acme"} 0.546
{"tenant":"globex"} 0.308
{"tenant":"acme","type":"completion"} 16.872
{"tenant":"acme","type":"prompt"} 55.905
{"tenant":"globex","type":"completion"} 3.176
{"tenant":"globex","type":"prompt"} 9.141
{"tenant":"globex"} 0.27
| Frage | Ausdruck (Kern) | Falle |
|---|---|---|
| Fehlerquote | 5xx / alle |
globex fehlt: kein 5xx-Counter → kein Ergebnis statt 0 (Tag 10) |
| p95-Latenz | histogram_quantile(0.95, … by (le)) |
le muss im by bleiben, Genauigkeit =
Bucket-Grenzen |
| Mittelwert | _sum / _count |
versteckt Ausreißer, nie fürs SLO |
| Tokens/s | rate(gateway_tokens_total) |
Streams (stream=true) zählt das Gateway nicht |
Warum ist p95 (1,02 s) so viel höher als der Mittelwert (0,55 s)? Antwortlänge variiert stark – bei LLMs ist die Latenzverteilung breit. 401 und 429 landen nicht im Histogramm, weil das Gateway sie vor der Zeitmessung abweist.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Recording Rules als PrometheusRule
cat $OBS/rules/llm-gateway-recording.rules.yaml | sed -n '3,12p'
docker run --rm -v $OBS/rules:/r -w /r --entrypoint promtool \
prom/prometheus:v3.15.0 check rules llm-gateway-recording.rules.yaml
mk_rule() { # Regeldatei -> PrometheusRule-Objekt
printf 'apiVersion: monitoring.coreos.com/v1\nkind: PrometheusRule\n'
printf 'metadata:\n name: %s\n namespace: monitoring\nspec:\n' "$1"
sed -e '/^#/d' -e 's/^/ /' "$2"
}
mk_rule llm-gateway-recording $OBS/rules/llm-gateway-recording.rules.yaml \
| kubectl apply -f -
sleep 60
pq 'tenant:gateway_request_errors:ratio_rate5m'Erwartet (Ausgabe von promtool live, Rest
Beispielwerte):
groups:
- name: llm-gateway.recording
interval: 30s
rules:
- record: tenant:gateway_requests:rate5m
expr: sum by (tenant) (rate(gateway_requests_total[5m]))
- record: tenant:gateway_request_errors:ratio_rate5m
expr: |
sum by (tenant) (rate(gateway_requests_total{code=~"5.."}[5m]))
/
Checking llm-gateway-recording.rules.yaml
SUCCESS: 5 rules found
prometheusrule.monitoring.coreos.com/llm-gateway-recording created
{"tenant":"acme"} 0.119
Warum Recording Rules? Dashboards und Alerts fragen dieselbe teure
Aggregation alle 15–30 s ab. Vorberechnet kostet sie einmal.
Namensschema level:metric:operations – an
tenant:…:rate5m siehst du Aggregation und Fenster.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Kardinalität prüfen
curl -s localhost:9090/api/v1/query \
--data-urlencode 'query=sort_desc(count by (__name__) ({__name__=~"gateway_.*"}))' \
| jq -r '.data.result[] | "\(.metric.__name__) \(.value[1])"'
pq 'count by (tenant) (gateway_request_duration_seconds_bucket)'
curl -s localhost:9090/api/v1/status/tsdb | jq '.data.headStats.numSeries'Erwartet (Beispielwerte; die Gesamtzahl der letzten Zeile hängt stark vom Cluster ab):
gateway_request_duration_seconds_bucket 33
gateway_requests_total 5
gateway_tokens_total 4
gateway_request_duration_seconds_sum 3
gateway_request_duration_seconds_count 3
gateway_ratelimited_total 1
{"tenant":"acme"} 22
{"tenant":"globex"} 11
48213
Die letzte Zahl ist die Gesamtzahl aktiver Serien im ganzen
Prometheus. Rechnung fürs Histogramm: 11 Buckets × Mandanten × Pods
(acme lief hier über zwei Pods). Mit 50 Mandanten und 4 Pods sind es 2
200 Serien – okay. Ein Label prompt_id oder
user multipliziert mit jeder Anfrage: Speicher und Abfragen
laufen aus dem Ruder.
Achtung: Nie Prompt, Prompt-Hash, User-ID, Request-ID oder freie Fehlertexte als Label. Die gehören in Logs und Traces (Tag 9). Labels nur für Dimensionen mit kleiner, fester Menge:
tenant,code,model.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Dashboard als Code
Der Grafana-Sidecar lädt jede ConfigMap mit Label
grafana_dashboard: "1" – aus allen Namespaces.
sed -n '1,9p' $OBS/k8s/dashboard-llm-gateway.yaml
kubectl apply -f $OBS/k8s/dashboard-llm-gateway.yaml
kubectl -n monitoring port-forward svc/kps-grafana 3000:80 >/dev/null 2>&1 &
sleep 20
curl -s -u admin:lab-admin 'localhost:3000/api/search?query=LLM' \
| jq -r '.[] | "\(.uid) \(.title)"'Erwartet (Suche gekürzt, kann je nach Version abweichen):
apiVersion: v1
kind: ConfigMap
metadata:
name: dashboard-llm-gateway
namespace: monitoring
labels:
grafana_dashboard: "1" # der Grafana-Sidecar sucht genau dieses Label
data:
llm-gateway.json: |
configmap/dashboard-llm-gateway created
llm-gateway LLM Gateway
Das Dashboard nutzt nur Recording Rules, hat eine Mandanten-Variable
und markiert Deployments in llm-system als Annotation
(changes(kube_deployment_metadata_generation[2m]) > 0).
In der UI geänderte Panels überschreibt der Sidecar beim nächsten Sync –
Änderungen gehören ins Git.
Fortschritt speichern? Kostenlos registrieren
Drill 8: Modellserver-VM und GPU-Metriken
Auf der VM (multipass shell llm-vm):
sudo apt-get install -y prometheus-node-exporter
systemctl is-active prometheus-node-exporter
curl -s localhost:9100/metrics | grep -E '^node_(load1|memory_MemAvailable_bytes) 'Erwartet (gekürzt, kann je nach Version abweichen):
active
node_load1 0.42
node_memory_MemAvailable_bytes 6.12345856e+09
Zurück auf dem Laptop:
VM_IP=$(multipass info llm-vm --format json | jq -r '.info["llm-vm"].ipv4[0]')
sed "s/LLM_VM_IP/$VM_IP/" $OBS/k8s/scrapeconfig-llm-vm.yaml | kubectl apply -f -
sleep 45
pq 'sum by (job, instance) (up{host="llm-vm"})'Erwartet (gekürzt, kann je nach Version abweichen):
scrapeconfig.monitoring.coreos.com/llm-vm created
{"instance":"192.168.64.10:9100","job":"scrapeConfig/monitoring/llm-vm"} 1
Ist up leer, erreicht der kind-Node die VM nicht – prüfe
mit
docker exec sre-lab-worker curl -s $VM_IP:9100/metrics | head -1.
Ollama liefert keine Prometheus-Metriken. Für Ollama
misst du am Gateway (Drill 3–4) und an der VM (node-exporter). vLLM
exportiert /metrics auf Port 8000, auf GPU-Nodes kommt der
NVIDIA DCGM Exporter dazu (Helm-Repo
https://nvidia.github.io/dcgm-exporter/helm-charts, Port
9400, bringt einen ServiceMonitor mit):
| Metrik | Bedeutung | Typische Abfrage |
|---|---|---|
vllm:time_to_first_token_seconds |
TTFT (Histogramm) | histogram_quantile(0.95, sum by (le) (rate(…_bucket[5m]))) |
vllm:e2e_request_latency_seconds |
Gesamtdauer (Histogramm) | wie TTFT |
vllm:num_requests_running / _waiting |
laufend / Warteschlange | _waiting > 0 über Minuten = Kapazität fehlt |
vllm:kv_cache_usage_perc |
KV-Cache-Füllgrad 0–1 | nahe 1 → Preemption, Latenz steigt |
vllm:inter_token_latency_seconds |
Zeit zwischen Tokens | Streaming-Gefühl beim Nutzer |
DCGM_FI_DEV_GPU_UTIL |
GPU-Auslastung in % | pro gpu, Hostname |
DCGM_FI_DEV_FB_USED |
belegter VRAM (MiB) | mit _FB_FREE → Füllgrad |
DCGM_FI_DEV_XID_ERRORS |
letzter XID-Fehler | > 0 = Hardware/Treiber prüfen |
Ältere vLLM-Versionen heißen vllm:gpu_cache_usage_perc
und vllm:time_per_output_token_seconds. Prüfe die Namen mit
curl -s <vllm>:8000/metrics | grep '^# HELP vllm'
(Quelle: docs.vllm.ai, Abschnitt Metrics, Stand Okt. 2026).
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
Q() { curl -s localhost:9090/api/v1/query --data-urlencode "query=$1" \
| jq -e '.data.result | length > 0'; }
check "Prometheus läuft" "curl -sf localhost:9090/-/ready"
check "Gateway-Target up" "Q 'up{job=\"llm-gateway\"} == 1'"
check "Recording Rule liefert" "Q 'tenant:gateway_requests:rate5m'"
check "p95 je Mandant" "Q 'tenant:gateway_request_duration_seconds:p95_5m'"
check "Dashboard geladen" \
"curl -sf -u admin:lab-admin localhost:3000/api/dashboards/uid/llm-gateway"
check "llm-vm gescrapt" "Q 'up{host=\"llm-vm\"} == 1'"Challenge
Ergänze eine Recording Rule
tenant:gateway_completion_tokens_per_request:ratio_rate5m
(durchschnittliche Completion-Tokens pro erfolgreicher Anfrage) und
prüfe sie mit promtool.
Hinweis: Teile die Token-Rate durch die Rate der
2xx-Anfragen, beide sum by (tenant).
Lösung
cp $OBS/rules/llm-gateway-recording.rules.yaml ~/sre-lab/tag08/recording.yaml
cat >> ~/sre-lab/tag08/recording.yaml <<'EOF'
- record: tenant:gateway_completion_tokens_per_request:ratio_rate5m
expr: |
sum by (tenant) (rate(gateway_tokens_total{type="completion"}[5m]))
/
sum by (tenant) (rate(gateway_requests_total{code=~"2.."}[5m]))
EOF
docker run --rm -v ~/sre-lab/tag08:/r -w /r --entrypoint promtool \
prom/prometheus:v3.15.0 check rules recording.yaml
mk_rule llm-gateway-recording ~/sre-lab/tag08/recording.yaml | kubectl apply -f -Fortschritt speichern? Kostenlos registrieren
Interview-Notiz
- Typische Frage: „Welche Metriken überwachst du bei einem LLM-Endpunkt?” – Antwort: RED pro Mandant (Rate, Errors, Duration) plus LLM-spezifisch TTFT, Tokens/s, Queue-Länge, KV-Cache-Füllgrad und GPU-Speicher.
- Knackig: „Mittelwerte lügen bei LLMs – ich alarmiere auf Perzentile aus Histogrammen, und die Bucket-Grenzen wähle ich nach dem SLO.”
- Kardinalität ist die häufigste Prometheus-Störung: „Mandant ja, User nein – User-Kontext gehört in Traces.”
- Brücke aus deiner Praxis: Bei Vault/OpenBao hast du
vault_core_unsealed, Raft-Health und Lease-Zahlen überwacht – gleiche Denkweise: wenige, aussagekräftige Signale statt alles scrapen. - Zeig, dass du Monitoring als Code lieferst: Regeln mit
promtoolin CI, Dashboards als ConfigMap im Git, keine Klick-Dashboards.
Enterprise-Notiz
- Langzeit und HA: zwei Prometheus-Replikas plus Thanos, Mimir oder VictoriaMetrics für Retention über Monate und Multi-Cluster-Sicht.
- Beim Kunden on-prem: oft existiert schon ein Monitoring (OpenShift User Workload Monitoring, Dynatrace, Datadog). Liefere ServiceMonitor und Regeln als optionale Chart-Teile.
- GPU-Knoten: DCGM Exporter meist über den NVIDIA GPU Operator; XID-Fehler und ECC-Remaps sind Hardware-Tickets, keine Software-Bugs.
/metricsnicht öffentlich: NetworkPolicy aufmonitoring, bei Bedarf mTLS oderkube-rbac-proxy.- Kosten: Metrik-Budget pro Team (Serien-Limit,
sample_limitim ServiceMonitor) verhindert, dass ein Deployment den Prometheus sprengt.