Tag 7: Model-Serving auf Kubernetes
Ziel: Ein Mistral-Modell wird über das mandantenfähige Gateway in
llm-systemaus 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-gatewaylaufen im Plattform-Namespacellm-system; Mandanten sprechen nur mit dem Gateway. - Modelle sind groß: Cache auf PVC, langsamer Start →
startupProbe, nichtinitialDelaySeconds. - 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.yamlErwartet:
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.yamlstatt 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; echoErwartet (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-externalErwartet:
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; echoErwartet:
job.batch/ollama-pull created
job.batch/ollama-pull condition met
{"status":"success"}
Achtung: Mit
http://ollama.llm-system:11434antwortet ein Ollama, das nur auf127.0.0.1lauscht, mit403 Forbidden– es prüft denHost-Header gegen DNS-Rebinding. Erlaubt sind IPs,localhostund Namen auf.local/.internal; der FQDN….svc.cluster.localpasst. Lauscht Ollama auf0.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=180sErwartet (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.yamlJetzt 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=1Erwartet (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 --nowErwartet (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,pdbErwartet (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.txtErwartet (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.txtErwartet:
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], keinfinish_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.productErwartet (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.yamlErwartet:
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,
startupProbestatt Liveness-Tricks. - Brücke aus deiner Praxis: OpenBao im StatefulSet war versiegelt =
nicht ready – derselbe Gedanke wie
/readyzmit 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
stringDataim Manifest (Tag 13). - Mehrere Modellversionen parallel (Canary): Gateway routet nach Modellname, Rollout mit Argo Rollouts oder KServe-Traffic-Split.
imagePullPolicy: IfNotPresentnur im Lab; in Produktion Images per Digest pinnen.