Zum Inhalt springen
Trainingslager IT-Trainingslager

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 pods

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

Fortschritt 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 promtool in 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.
  • /metrics nicht öffentlich: NetworkPolicy auf monitoring, bei Bedarf mTLS oder kube-rbac-proxy.
  • Kosten: Metrik-Budget pro Team (Serien-Limit, sample_limit im ServiceMonitor) verhindert, dass ein Deployment den Prometheus sprengt.