Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 7: Model-Serving auf Kubernetes

Ziel: Ein Mistral-Modell wird über das mandantenfähige Gateway in llm-system aus den Tenant-Namespaces erreichbar – mit Probes, HPA, PDB und Rolling Updates ohne abgerissene Streams. · Dauer: ca. 150 min · Voraussetzung: Tag 4, 5 und 6

Briefing

  • Modellserver (Ollama, später vLLM) und llm-gateway laufen im Plattform-Namespace llm-system; Mandanten sprechen nur mit dem Gateway.
  • Modelle sind groß: Cache auf PVC, langsamer Start → startupProbe, nicht initialDelaySeconds.
  • Das Gateway skaliert per HPA, der Modellserver nach GPU und Warteschlange (KEDA).
  • Rolling Updates dürfen laufende Generierungen nicht abschneiden: preStop + Graceful Shutdown + terminationGracePeriodSeconds.
tenant-acme/client ──► Service llm-gateway:8080 ──► Pods llm-gateway (HPA 2..5)
                                                       │ X-Tenant, kein API-Key
                                                       ▼
                                Service ollama:11434 ──► Ollama-Pod + PVC  (A)
                                                    └──► llm-vm / Host     (B)

Drill 1: Ollama im Cluster (Variante A)

mkdir -p ~/sre-lab/tag07 && cd ~/sre-lab/tag07
cat > ollama.yaml <<'EOF'
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: ollama-models
  namespace: llm-system
spec:
  accessModes: [ReadWriteOnce]
  resources:
    requests:
      storage: 20Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ollama
  namespace: llm-system
  labels: {app.kubernetes.io/name: ollama}
spec:
  replicas: 1
  strategy: {type: Recreate}        # RWO-PVC: alter Pod muss erst weg
  selector:
    matchLabels: {app.kubernetes.io/name: ollama}
  template:
    metadata:
      labels: {app.kubernetes.io/name: ollama}
    spec:
      automountServiceAccountToken: false
      containers:
        - name: ollama
          image: ollama/ollama:0.40.2
          env:
            - {name: OLLAMA_HOST, value: "0.0.0.0:11434"}
            - {name: OLLAMA_MODELS, value: /models}
            - {name: OLLAMA_KEEP_ALIVE, value: "24h"}   # Modell im RAM halten
          ports:
            - {name: http, containerPort: 11434}
          volumeMounts:
            - {name: models, mountPath: /models}
          resources:
            requests: {cpu: "2", memory: 6Gi}
            limits: {memory: 8Gi}
          startupProbe:                  # bis zu 10 min für Start
            httpGet: {path: /api/version, port: http}
            periodSeconds: 10
            failureThreshold: 60
          livenessProbe:
            httpGet: {path: /api/version, port: http}
            periodSeconds: 20
            timeoutSeconds: 5
            failureThreshold: 3
          readinessProbe:
            httpGet: {path: /api/tags, port: http}
            periodSeconds: 10
      volumes:
        - name: models
          persistentVolumeClaim: {claimName: ollama-models}
---
apiVersion: v1
kind: Service
metadata:
  name: ollama
  namespace: llm-system
spec:
  selector: {app.kubernetes.io/name: ollama}
  ports:
    - {name: http, port: 11434, targetPort: http}
EOF
kubectl label ns llm-system pod-security.kubernetes.io/enforce=baseline --overwrite
kubectl apply --dry-run=server -f ollama.yaml

Erwartet:

namespace/llm-system labeled
persistentvolumeclaim/ollama-models created (server dry run)
deployment.apps/ollama created (server dry run)
service/ollama created (server dry run)

Warum startupProbe? Solange sie nicht erfolgreich war, laufen Liveness und Readiness nicht – ein Modell, das 5 Minuten lädt, wird so nicht in eine Restart-Schleife getötet. Warum baseline statt restricted? Das Ollama-Image läuft als root; die Tenants bleiben restricted.

Achtung: Das Ollama-Image ist für arm64 ca. 2,8 GB groß (komprimiert, CUDA-Bibliotheken inklusive), dazu 3 GB Modell und mindestens 6 GB RAM. In der 8-GB-Docker-VM dieses Testlaufs passte das nicht – Variante A ist nur per Server-Dry-Run geprüft. Mit genug Platz: kubectl apply -f ollama.yaml statt Drill 2.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Ollama außerhalb des Clusters (Variante B, live getestet)

Der Modellserver läuft auf llm-vm (Tag 5) oder auf dem Laptop. Ein Service ohne Selector plus EndpointSlice macht ihn im Cluster unter demselben Namen erreichbar:

# llm-vm (Tag 5 bindet 127.0.0.1 - hier OLLAMA_HOST=0.0.0.0 plus Firewall wie Tag 12):
OLLAMA_IP=$(multipass info llm-vm --format json | jq -r '.info["llm-vm"].ipv4[0]')
# ODER Ollama auf dem Mac, kind unter colima/Docker Desktop:
OLLAMA_IP=$(docker exec sre-lab-worker getent hosts host.docker.internal \
  | awk '{print $1}')
export OLLAMA_IP
docker exec sre-lab-worker curl -s -m 5 http://$OLLAMA_IP:11434/api/version; echo

Erwartet (Testlauf mit Ollama auf dem Mac):

{"version":"0.35.1"}
cat > ollama-external.yaml <<'EOF'
apiVersion: v1
kind: Service
metadata:
  name: ollama
  namespace: llm-system
spec:
  ports:
    - {name: http, port: 11434, targetPort: 11434}
---
apiVersion: discovery.k8s.io/v1
kind: EndpointSlice
metadata:
  name: ollama-external
  namespace: llm-system
  labels:
    kubernetes.io/service-name: ollama     # verknüpft Slice mit Service
addressType: IPv4
ports:
  - {name: http, port: 11434, protocol: TCP}
endpoints:
  - addresses: ["${OLLAMA_IP}"]
EOF
envsubst '$OLLAMA_IP' < ollama-external.yaml | kubectl apply -f -
kubectl -n llm-system get endpointslice ollama-external

Erwartet:

service/ollama created
endpointslice.discovery.k8s.io/ollama-external created
NAME              ADDRESSTYPE   PORTS   ENDPOINTS     AGE
ollama-external   IPv4          11434   192.168.5.2   1s

Fortschritt speichern? Kostenlos registrieren

Drill 3: Modell per Job vorladen

export MODEL=ministral-3:3b    # Tag prüfen: ollama.com/library/ministral-3
cat > pull-job.yaml <<'EOF'
apiVersion: batch/v1
kind: Job
metadata:
  name: ollama-pull
  namespace: llm-system
spec:
  backoffLimit: 3
  ttlSecondsAfterFinished: 600
  template:
    spec:
      restartPolicy: OnFailure
      automountServiceAccountToken: false
      securityContext:
        runAsNonRoot: true
        runAsUser: 100
        seccompProfile: {type: RuntimeDefault}
      containers:
        - name: pull
          image: curlimages/curl:8.22.0
          args:
            - -sSf
            - --max-time
            - "1800"
            - http://ollama.llm-system.svc.cluster.local:11434/api/pull
            - -d
            - '{"model":"${MODEL}","stream":false}'
          securityContext:
            allowPrivilegeEscalation: false
            capabilities: {drop: [ALL]}
EOF
envsubst '$MODEL' < pull-job.yaml | kubectl apply -f -
kubectl -n llm-system wait --for=condition=Complete job/ollama-pull --timeout=1800s
kubectl -n llm-system logs job/ollama-pull; echo

Erwartet:

job.batch/ollama-pull created
job.batch/ollama-pull condition met
{"status":"success"}

Achtung: Mit http://ollama.llm-system:11434 antwortet ein Ollama, das nur auf 127.0.0.1 lauscht, mit 403 Forbidden – es prüft den Host-Header gegen DNS-Rebinding. Erlaubt sind IPs, localhost und Namen auf .local/.internal; der FQDN ….svc.cluster.local passt. Lauscht Ollama auf 0.0.0.0 (Variante A, llm-vm), entfällt die Prüfung.

Warum ein Job statt postStart? Ein postStart-Hook blockiert den Containerstart und wiederholt sich bei jedem Neustart; der Job ist einmalig, hat eigene Retries und taucht im Monitoring auf.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Gateway deployen

cd ~/sre-lab/code/llm-gateway
docker build -t llm-gateway:dev .
kind load docker-image llm-gateway:dev --name sre-lab
cd ~/sre-lab/tag07
cat > gateway.yaml <<'EOF'
apiVersion: v1
kind: Secret
metadata:
  name: llm-gateway-keys
  namespace: llm-system
type: Opaque
stringData:
  TENANT_KEYS: "acme:lab-key-acme,globex:lab-key-globex"   # Lab-Werte!
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: llm-gateway
  namespace: llm-system
  labels: {app.kubernetes.io/name: llm-gateway}
spec:
  replicas: 2
  strategy:
    type: RollingUpdate
    rollingUpdate: {maxUnavailable: 0, maxSurge: 1}
  selector:
    matchLabels: {app.kubernetes.io/name: llm-gateway}
  template:
    metadata:
      labels: {app.kubernetes.io/name: llm-gateway}
    spec:
      automountServiceAccountToken: false
      terminationGracePeriodSeconds: 45   # > preStop 5 s + Shutdown 30 s
      securityContext:
        runAsNonRoot: true
        runAsUser: 65532                 # distroless nonroot (numerisch!)
        seccompProfile: {type: RuntimeDefault}
      containers:
        - name: gateway
          image: llm-gateway:dev
          imagePullPolicy: IfNotPresent    # Image kommt per kind load
          env:
            - name: UPSTREAM_URL               # FQDN, siehe Drill 3
              value: http://ollama.llm-system.svc.cluster.local:11434
            - {name: RATE_LIMIT_RPS, value: "5"}
            - {name: RATE_LIMIT_BURST, value: "10"}
            - name: TENANT_KEYS
              valueFrom:
                secretKeyRef: {name: llm-gateway-keys, key: TENANT_KEYS}
          ports:
            - {name: http, containerPort: 8080}
          readinessProbe:
            httpGet: {path: /readyz, port: http}
            periodSeconds: 5
            failureThreshold: 2
          livenessProbe:
            httpGet: {path: /healthz, port: http}
            periodSeconds: 10
          lifecycle:
            preStop:
              sleep: {seconds: 5}          # Endpoints zuerst austragen
          resources:
            requests: {cpu: 50m, memory: 32Mi}
            limits: {cpu: 500m, memory: 128Mi}
          securityContext:
            allowPrivilegeEscalation: false
            readOnlyRootFilesystem: true
            capabilities: {drop: [ALL]}
---
apiVersion: v1
kind: Service
metadata:
  name: llm-gateway
  namespace: llm-system
  labels: {app.kubernetes.io/name: llm-gateway}
spec:
  selector: {app.kubernetes.io/name: llm-gateway}
  ports:
    - {name: http, port: 8080, targetPort: http}
EOF
kubectl apply -f gateway.yaml
kubectl -n llm-system rollout status deploy/llm-gateway --timeout=180s

Erwartet (gekürzt):

secret/llm-gateway-keys created
deployment.apps/llm-gateway created
service/llm-gateway created
deployment "llm-gateway" successfully rolled out

Warum runAsUser: 65532? Das distroless-Image setzt USER nonroot:nonroot – einen Namen. Mit runAsNonRoot: true kann das Kubelet einen Namen nicht prüfen und meldet CreateContainerConfigError. Warum /readyz als Readiness? Es fragt Ollama ab – ein Gateway ohne Modellserver bekommt keinen Traffic.

Fortschritt speichern? Kostenlos registrieren

Drill 5: NetworkPolicy für llm-system und Aufruf aus dem Tenant

cat > netpol-llm-system.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-ingress
  namespace: llm-system
spec:
  podSelector: {}
  policyTypes: [Ingress]
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: gateway-from-tenants
  namespace: llm-system
spec:
  podSelector:
    matchLabels: {app.kubernetes.io/name: llm-gateway}
  policyTypes: [Ingress]
  ingress:
    - from:
        - namespaceSelector:
            matchLabels: {sre-lab.io/role: tenant}
      ports:
        - {protocol: TCP, port: 8080}
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: ollama-from-gateway
  namespace: llm-system
spec:
  podSelector:
    matchLabels: {app.kubernetes.io/name: ollama}
  policyTypes: [Ingress]
  ingress:
    - from:
        - podSelector:
            matchLabels: {app.kubernetes.io/name: llm-gateway}
        - podSelector:
            matchLabels: {job-name: ollama-pull}
      ports:
        - {protocol: TCP, port: 11434}
EOF
kubectl apply -f netpol-llm-system.yaml

Jetzt der Aufruf aus tenant-acme (die Egress-Policy aus Tag 6 erlaubt genau das):

chat() { kubectl -n "$1" exec client -- curl -s -m 120 \
  http://llm-gateway.llm-system:8080/v1/chat/completions \
  -H "Authorization: Bearer $2" -H 'Content-Type: application/json' \
  -d '{"model":"'"$MODEL"'","messages":[{"role":"user",
       "content":"Antworte mit genau einem Wort: Hauptstadt von Frankreich?"}]}'; }
chat tenant-acme lab-key-acme | jq -c '{model, answer: .choices[0].message.content}'
chat tenant-acme lab-key-falsch; echo
kubectl -n llm-system logs deploy/llm-gateway --tail=1

Erwartet (gekürzt):

{"model":"ministral-3:3b","answer":"Paris."}
{"error":"invalid api key"}
{"time":"…","level":"INFO","msg":"request","tenant":"acme","method":"POST",
 "path":"/v1/chat/completions","status":200,"duration_ms":264}

Gegenprobe aus einem Namespace ohne Tenant-Label:

kubectl run outsider --image=curlimages/curl:8.22.0 --restart=Never \
  --command -- sleep 600
kubectl wait --for=condition=Ready pod/outsider --timeout=90s
kubectl exec outsider -- curl -s -m 3 http://llm-gateway.llm-system:8080/healthz \
  || echo "✘ blockiert (exit $?)"
kubectl delete pod outsider --now

Erwartet (gekürzt):

command terminated with exit code 28
✘ blockiert (exit 28)

Fortschritt speichern? Kostenlos registrieren

Drill 6: HPA und PodDisruptionBudget

helm repo add metrics-server https://kubernetes-sigs.github.io/metrics-server/
helm upgrade --install metrics-server metrics-server/metrics-server \
  --version 3.14.0 -n kube-system --set 'args[0]=--kubelet-insecure-tls' --wait
cat > scaling.yaml <<'EOF'
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: llm-gateway
  namespace: llm-system
spec:
  scaleTargetRef: {apiVersion: apps/v1, kind: Deployment, name: llm-gateway}
  minReplicas: 2
  maxReplicas: 5
  metrics:
    - type: Resource
      resource:
        name: cpu
        target: {type: Utilization, averageUtilization: 70}
---
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: llm-gateway
  namespace: llm-system
spec:
  minAvailable: 1
  selector:
    matchLabels: {app.kubernetes.io/name: llm-gateway}
EOF
kubectl apply -f scaling.yaml
kubectl -n llm-system get hpa,pdb

Erwartet (nach ca. 1 min):

NAME          REFERENCE                TARGETS       MINPODS   MAXPODS   REPLICAS
llm-gateway   Deployment/llm-gateway   cpu: 4%/70%   2         5         2
NAME          MIN AVAILABLE   MAX UNAVAILABLE   ALLOWED DISRUPTIONS   AGE
llm-gateway   1               N/A               1                     1m

Last erzeugen – mit absichtlich gesenktem Ziel (20 %), damit es im Lab sichtbar wird:

kubectl -n llm-system patch hpa llm-gateway --type=merge -p '{"spec":{"metrics":
  [{"type":"Resource","resource":{"name":"cpu",
  "target":{"type":"Utilization","averageUtilization":20}}}]}}'
kubectl -n tenant-acme exec client -- sh -c 'end=$(($(date +%s)+100))
  for i in 1 2 3 4 5 6 7 8; do
    (while [ $(date +%s) -lt $end ]; do curl -s -o /dev/null \
      http://llm-gateway.llm-system:8080/v1/models -H "Authorization: Bearer x"
    done) &
  done; wait'
kubectl -n llm-system get hpa llm-gateway
kubectl -n llm-system get events --field-selector reason=SuccessfulRescale \
  -o custom-columns=MSG:.message
kubectl -n llm-system patch hpa llm-gateway --type=merge -p '{"spec":{"metrics":
  [{"type":"Resource","resource":{"name":"cpu",
  "target":{"type":"Utilization","averageUtilization":70}}}]}}'

Erwartet (gekürzt):

NAME          REFERENCE                TARGETS        MINPODS   MAXPODS   REPLICAS
llm-gateway   Deployment/llm-gateway   cpu: 22%/20%   2         5         4
MSG
New size: 4; reason: cpu resource utilization (percentage of request) above target

Warum CPU nur fürs Gateway? Das Gateway ist I/O-gebunden und billig. Der Engpass ist der Modellserver – dort skaliert man nach Warteschlange (Drill 8), nicht nach CPU.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Rolling Update ohne abgerissene Streams

stream() { kubectl -n tenant-acme exec client -- curl -sN -m 300 \
  http://llm-gateway.llm-system:8080/v1/chat/completions \
  -H "Authorization: Bearer lab-key-acme" -H 'Content-Type: application/json' \
  -d '{"model":"'"$MODEL"'","stream":true,"messages":[{"role":"user",
       "content":"Erkläre Kubernetes in '"$1"' Wörtern."}]}'; }
stream 100 > stream.txt 2>&1 & PID=$!
sleep 2
kubectl -n llm-system rollout restart deploy/llm-gateway
kubectl -n llm-system rollout status deploy/llm-gateway --timeout=180s | tail -1
wait $PID; echo "Exit: $?"
grep -c '^data:' stream.txt; grep '\[DONE\]' stream.txt

Erwartet (Anzahl Chunks variiert):

deployment.apps/llm-gateway restarted
deployment "llm-gateway" successfully rolled out
Exit: 0
172
data: [DONE]

Was passiert beim Beenden eines Pods? Kubernetes trägt ihn aus den Endpoints aus und startet parallel preStop (5 s Puffer, bis kube-proxy überall nachgezogen hat). Dann kommt SIGTERM; das Gateway nimmt keine neuen Verbindungen an und lässt laufende bis zu 30 s fertig laufen (srv.Shutdown, Tag 4). terminationGracePeriodSeconds: 45 deckt beides ab – erst danach folgt SIGKILL.

Jetzt eine Generierung, die länger als 30 s dauert (im Testlauf ca. 50 s):

stream 600 > long.txt 2>&1 & PID=$!
sleep 2
kubectl -n llm-system rollout restart deploy/llm-gateway >/dev/null
wait $PID; echo "Exit: $?"
grep -c '\[DONE\]' long.txt; tail -1 long.txt

Erwartet:

Exit: 18
0
command terminated with exit code 18

Exit 18 = curl „partial file”: Das Shutdown-Timeout im Gateway (30 s, hart codiert) ist abgelaufen, der Stream wurde mitten im Satz gekappt. Die Grace Period allein hilft nicht – Prozess-Timeout und terminationGracePeriodSeconds müssen über der längsten erlaubten Generierung liegen (z. B. max_tokens begrenzen und Timeout per Env konfigurierbar machen).

Tipp: Clients sollten abgebrochene Streams erkennen (kein [DONE], kein finish_reason) und neu anfragen – ein Rollout ist nie der einzige Grund für einen Abbruch.

Fortschritt speichern? Kostenlos registrieren

Drill 8: GPU-Serving mit vLLM (nur gegen Doku geprüft)

Ohne GPU im Lab – hier der Weg in einem echten Cluster:

# 1. NVIDIA GPU Operator: Treiber, Container Toolkit, Device Plugin, GFD, DCGM
helm repo add nvidia https://helm.ngc.nvidia.com/nvidia && helm repo update
helm install gpu-operator nvidia/gpu-operator -n gpu-operator \
  --create-namespace --version v26.7.1 --wait
# 2. GPU-Nodes reservieren: nur Pods mit Toleration landen dort
kubectl taint nodes gpu-node-1 nvidia.com/gpu=present:NoSchedule
kubectl get nodes -L nvidia.com/gpu.present,nvidia.com/gpu.product

Erwartet (gekürzt, kann je nach Version abweichen):

NAME         STATUS   ROLES    AGE   VERSION   GPU.PRESENT   GPU.PRODUCT
gpu-node-1   Ready    <none>   3d    v1.37.0   true          NVIDIA-L40S
cat > vllm.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-ministral
  namespace: llm-system
  labels: {app.kubernetes.io/name: vllm-ministral}
spec:
  replicas: 1
  selector:
    matchLabels: {app.kubernetes.io/name: vllm-ministral}
  template:
    metadata:
      labels: {app.kubernetes.io/name: vllm-ministral}
    spec:
      nodeSelector:
        nvidia.com/gpu.present: "true"     # Label von GPU Feature Discovery
      tolerations:
        - {key: nvidia.com/gpu, operator: Exists, effect: NoSchedule}
      containers:
        - name: vllm
          image: vllm/vllm-openai:v0.31.0
          args:
            - --model=mistralai/Ministral-3-8B-Instruct-2512
            - --tokenizer-mode=mistral
            - --config-format=mistral
            - --load-format=mistral
            - --max-model-len=32768
            - --gpu-memory-utilization=0.90
          env:
            - name: HF_TOKEN
              valueFrom:
                secretKeyRef: {name: hf-token, key: token, optional: true}
          ports:
            - {name: http, containerPort: 8000}
          resources:
            requests: {cpu: "4", memory: 32Gi, nvidia.com/gpu: "1"}
            limits: {memory: 48Gi, nvidia.com/gpu: "1"}
          startupProbe:                    # Download + Laden: bis 30 min
            httpGet: {path: /health, port: http}
            periodSeconds: 15
            failureThreshold: 120
          readinessProbe:
            httpGet: {path: /health, port: http}
            periodSeconds: 10
          volumeMounts:
            - {name: hf-cache, mountPath: /root/.cache/huggingface}
            - {name: shm, mountPath: /dev/shm}
      volumes:
        - name: hf-cache
          persistentVolumeClaim: {claimName: hf-cache}
        - name: shm
          emptyDir: {medium: Memory, sizeLimit: 8Gi}
EOF
kubectl apply --dry-run=server -f vllm.yaml

Erwartet:

deployment.apps/vllm-ministral created (server dry run)

Warum --max-model-len? Die Modellkarte nennt 262 144 Token als Default – der KV-Cache dafür passt nicht auf eine GPU. nvidia.com/gpu ist eine Extended Resource: ganze Zahlen, Request = Limit, kein Overcommit. /dev/shm als RAM-Disk braucht vLLM für Tensor-Parallelismus.

Autoscaling nach Warteschlange statt CPU – mit KEDA und der vLLM-Metrik vllm:num_requests_waiting (Prometheus aus Tag 8):

apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: vllm-ministral
  namespace: llm-system
spec:
  scaleTargetRef: {name: vllm-ministral}
  minReplicaCount: 1
  maxReplicaCount: 4
  cooldownPeriod: 600               # GPU-Pods starten langsam: nicht flattern
  triggers:
    - type: prometheus
      metadata:
        serverAddress: http://kps-kube-prometheus-stack-prometheus.monitoring:9090
        query: sum(vllm:num_requests_waiting{namespace="llm-system"})
        threshold: "5"

Ausblick für Produktion: KServe (InferenceService mit vLLM-Runtime, Scale-to-Zero via Knative), llm-d (KV-Cache- und Prefix-bewusstes Routing, Prefill/Decode getrennt) und der vLLM production-stack (Helm-Chart mit Router, Observability, LMCache).

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
check "Gateway 2+ Pods ready" \
  '[ "$(kubectl -n llm-system get deploy llm-gateway \
     -o jsonpath="{.status.readyReplicas}")" -ge 2 ]'
check "Modelle über Gateway sichtbar" \
  'kubectl -n tenant-acme exec client -- curl -sf -m 5 \
     -H "Authorization: Bearer lab-key-acme" \
     http://llm-gateway.llm-system:8080/v1/models'
check "acme bekommt Antwort" \
  '[ "$(chat tenant-acme lab-key-acme | jq -r .object)" = chat.completion ]'
check "falscher Key -> 401" \
  'chat tenant-acme nope | grep -q "invalid api key"'
check "HPA vorhanden" 'kubectl -n llm-system get hpa llm-gateway'
check "PDB erlaubt Disruption" \
  '[ "$(kubectl -n llm-system get pdb llm-gateway \
     -o jsonpath="{.status.disruptionsAllowed}")" -ge 1 ]'
check "preStop gesetzt" \
  'kubectl -n llm-system get deploy llm-gateway -o yaml | grep -q "seconds: 5"'

Challenge

Schicke aus tenant-acme 40 schnelle Anfragen an /v1/models und zähle die Statuscodes. Erkläre, warum bei RATE_LIMIT_BURST=10 weit mehr als 10 Anfragen durchkommen – und was das für die Zusage „5 Requests/s pro Mandant” bedeutet.

Hinweis: Zähle die Gateway-Replicas.

Lösung

kubectl -n llm-system get deploy llm-gateway -o jsonpath='{.status.readyReplicas}'
echo
kubectl -n tenant-acme exec client -- sh -c 'for i in $(seq 1 40); do
  curl -s -o /dev/null -w "%{http_code}\n" \
    http://llm-gateway.llm-system:8080/v1/models \
    -H "Authorization: Bearer lab-key-acme"; done | sort | uniq -c'

Erwartet (bei 4 Replicas, Zahlen variieren):

4
     38 200
      2 429

Der Token-Bucket lebt im Speicher jedes Pods: effektives Limit = Replicas × Burst bzw. × RPS, und es ändert sich mit jedem HPA-Schritt. Abhilfe: globales Rate-Limit (Redis, Envoy Rate Limit Service) oder das Limit pro Pod durch die Replica-Zahl teilen – und das Limit in Tokens statt Requests messen.

Fortschritt speichern? Kostenlos registrieren

Interview-Notiz

  • Typische Frage: „Ein Kunde meldet abgebrochene Antworten bei jedem Deployment.” – Antwort: Endpoint-Propagation (preStop), Graceful Shutdown im Prozess, terminationGracePeriodSeconds > längste Generierung, maxUnavailable: 0, PDB.
  • Knackig: „GPU-Pods skaliere ich nach Warteschlange und KV-Cache-Auslastung, nicht nach CPU – und mit langem Cooldown, weil ein Modell-Start Minuten dauert.”
  • Sizing-Frage: Startup dominieren Download und Laden der Gewichte → Modell-Cache auf PVC oder lokaler NVMe, Images vorab pullen, startupProbe statt Liveness-Tricks.
  • Brücke aus deiner Praxis: OpenBao im StatefulSet war versiegelt = nicht ready – derselbe Gedanke wie /readyz mit Upstream-Check: Ready heißt „kann Anfragen bedienen”, nicht „Prozess läuft”.
  • Gegenfrage an Mistral: Läuft Serving bei Kunden über vLLM direkt, KServe oder llm-d – und wer besitzt das Rate-Limiting?

Enterprise-Notiz

  • Modellgewichte nicht zur Laufzeit aus dem Internet: internes Registry/S3-Mirror, OCI-Artefakte oder vorab befüllte PVCs (Tag 14).
  • GPU-Nodes in eigene Node-Pools mit Taints, MIG/Time-Slicing bewusst wählen, DCGM-Exporter für GPU-Metriken (Tag 8).
  • Gateway-Secrets aus OpenBao/External Secrets statt stringData im Manifest (Tag 13).
  • Mehrere Modellversionen parallel (Canary): Gateway routet nach Modellname, Rollout mit Argo Rollouts oder KServe-Traffic-Split.
  • imagePullPolicy: IfNotPresent nur im Lab; in Produktion Images per Digest pinnen.