Tag 18: LLM-Traffic
Ziel: Du baust ein Inference Gateway mit der Gateway API Inference Extension, routest Anfragen nach Modellname auf InferencePools und machst sichtbar, wie der Endpoint Picker nach Warteschlangenlänge verteilt – mit Simulator statt GPU. · Dauer: ca. 75 min · Voraussetzung: Tag 10 (Gateway-API-CRDs)
Briefing
- CKNE: Advanced Traffic Management – „Optimizing LLM Traffic“.
- LLM-Anfragen sind lang, teuer und ungleich: Round Robin schickt die nächste Anfrage gern an den Pod mit der längsten Warteschlange.
- Die Gateway API Inference Extension (GIE) ergänzt
den
InferencePoolals Backend einer HTTPRoute. Pro Pool fragt das Gateway per ext-proc einen Endpoint Picker (EPP), welcher Pod die Anfrage bekommt – nach Queue, KV-Cache, Modell. - Stand November 2026: GIE v1.6.2 hält nur noch
InferencePool(inference.networking.k8s.io/v1); EPP,InferenceObjectiveundInferenceModelRewritesind ins Projekt llm-d gewandert (llm-d.ai).
client ──POST /v1/chat/completions {"model":"ckne/chat"}──> Gateway llm (agentgateway)
Policy: body.model → Header X-Gateway-Model-Name
HTTPRoute: Header ckne/chat ─> InferencePool chat ──ext-proc──> chat-epp
└─> chat-fast (TTFT 200 ms) | chat-slow (1500 ms)
Header ckne/code ─> InferencePool code ─> code-epp ─> code
Drill 1: Wer kann InferencePool?
Erst die CRDs: InferencePool aus GIE, die Anfrage-APIs
aus dem llm-d-Router.
mkdir -p ~/ckne/tag18 && cd ~/ckne/tag18
GIE=https://github.com/kubernetes-sigs/gateway-api-inference-extension
k apply --server-side -f $GIE/releases/download/v1.6.2/v1-manifests.yaml
k apply --server-side \
-f https://github.com/llm-d/llm-d-router/releases/download/v1.0.0/manifests.yaml
k api-resources | awk '/nference/ {print $NF, $(NF-2)}'Erwartet (gekürzt):
customresourcedefinition.apiextensions.k8s.io/inferencepools.inference.networking.k8s.io
serverside-applied
customresourcedefinition.apiextensions.k8s.io/inferencemodelrewrites.llm-d.ai ...
customresourcedefinition.apiextensions.k8s.io/inferenceobjectives.llm-d.ai ...
InferencePool inference.networking.k8s.io/v1
InferenceModelRewrite llm-d.ai/v1alpha2
InferenceObjective llm-d.ai/v1
Kann Ciliums Gateway das? Der schnellste Beweis ist eine Route mit
InferencePool als Backend an einem cilium-Gateway – den
Pool chat legst du in Drill 3 an, die Probe machst du nach
Drill 4 (die Dateien gibt es dann):
k get gatewayclass cilium -o jsonpath='{.status.supportedFeatures[*].name}' \
| tr ' ' '\n' | grep -ci inferenceErwartet: 0 – kein Inference-Feature.
Die GIE-Doku listet als Implementierungen Istio, Agentgateway und NGINX
Gateway Fabric (dazu Cloud-Gateways wie GKE). Du nimmst das leichteste:
agentgateway (Rust-Proxy, Controller ~40 MiB), in
eigenem Namespace und mit eigener GatewayClass, am Tagesende wieder weg.
Die Images von agentgateway (Controller, Proxy) und vom EPP des
llm-d-Routers gibt es wie den Simulator für amd64 und arm64.
helm install agentgateway-crds oci://cr.agentgateway.dev/charts/agentgateway-crds \
--version 1.7.0 -n tag18-agentgateway --create-namespace
helm install agentgateway oci://cr.agentgateway.dev/charts/agentgateway \
--version 1.7.0 -n tag18-agentgateway \
--set inferenceExtension.enabled=true --set gatewayClassName=tag18-agentgateway
k -n tag18-agentgateway rollout status deploy agentgateway
k get gatewayclassErwartet (gekürzt):
STATUS: deployed
STATUS: deployed
deployment "agentgateway" successfully rolled out
NAME CONTROLLER ACCEPTED AGE
cilium io.cilium/gateway-controller True 25m
tag18-agentgateway agentgateway.dev/agentgateway True 3s
Zwei Gateway-Controller nebeneinander sind normal: Jede GatewayClass
nennt ihren controllerName, jeder Controller kümmert sich
nur um seine.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Modellserver ohne GPU
llm-d-inference-sim spricht die OpenAI-API von vLLM samt
Metriken (vllm:num_requests_waiting), braucht aber weder
GPU noch Modell (amd64 und arm64). Ein Pod chat-fast, ein
Pod chat-slow mit 1,5 s bis zum ersten Token – beide tragen
app=sim-chat –, dazu ein zweites Modell
ckne/code. --max-num-seqs=2 heißt: mehr als
zwei gleichzeitige Anfragen landen in der Warteschlange.
k create namespace tag18
k config set-context --current --namespace=tag18
cat > sim.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
name: chat-fast
spec:
replicas: 1
selector:
matchLabels: {app: sim-chat, speed: fast}
template:
metadata:
labels: {app: sim-chat, speed: fast}
spec:
containers:
- name: sim
image: ghcr.io/llm-d/llm-d-inference-sim:v1.2.0
args:
- --model=ckne/chat
- --port=8000
- --max-num-seqs=2
- --time-to-first-token=200ms
- --inter-token-latency=20ms
env:
- name: POD_NAME
valueFrom: {fieldRef: {fieldPath: metadata.name}}
- name: NAMESPACE
valueFrom: {fieldRef: {fieldPath: metadata.namespace}}
ports:
- {name: http, containerPort: 8000}
resources:
requests: {cpu: 10m, memory: 32Mi}
limits: {memory: 128Mi}
EOF
sed -e 's/chat-fast/chat-slow/' -e 's/speed: fast/speed: slow/g' \
-e 's/time-to-first-token=200ms/time-to-first-token=1500ms/' sim.yaml > sim-slow.yaml
sed -e 's/chat-fast/code/' -e 's/{app: sim-chat, speed: fast}/{app: sim-code}/g' \
-e 's#ckne/chat#ckne/code#' sim.yaml > sim-code.yaml
k apply -f sim.yaml -f sim-slow.yaml -f sim-code.yaml
k run c --image=curlimages/curl:8.17.0 --command -- sleep infinity
k wait --for=condition=Available deploy --all
k get pods -o wide
P=$(k get pod -l speed=fast -o jsonpath='{.items[0].status.podIP}')
k exec c -- curl -s http://$P:8000/v1/models; echo
B='{"model":"ckne/chat","messages":[{"role":"user","content":"Hallo"}],"max_tokens":5}'
k exec c -- curl -s http://$P:8000/v1/chat/completions \
-H 'Content-Type: application/json' -d "$B"; echo
k exec c -- curl -s http://$P:8000/metrics | grep -E '^vllm:num_requests'Erwartet (gekürzt):
NAME READY STATUS RESTARTS AGE IP NODE
c 1/1 Running 0 59s 10.0.2.5 worker2
chat-fast-84d4555798-h7xxd 1/1 Running 0 71s 10.0.2.220 worker2
chat-slow-7dd4c5b4b5-tc9cc 1/1 Running 0 45s 10.0.1.20 worker1
code-7fb5f6857-pspps 1/1 Running 0 45s 10.0.1.159 worker1
{"object":"list","data":[{"id":"ckne/chat","object":"model",...,"max_model_len":1024}]}
{"id":"chatcmpl-db659833-...","model":"ckne/chat","object":"chat.completion",...,
"choices":[{"index":0,"finish_reason":"stop","message":{"role":"assistant",
"content":"Testing@, "}}]}
vllm:num_requests_running{model_name="ckne/chat"} 0
vllm:num_requests_waiting{model_name="ckne/chat"} 0
Ein Modellname, den es nicht gibt, ergibt beim Simulator wie bei vLLM einen 404 („The model … does not exist.“).
Fortschritt speichern? Kostenlos registrieren
Drill 3: InferencePool und Endpoint Picker
Pool und EPP kommen aus dem Helm-Chart des llm-d-Routers. Die Standard-Ressourcen sind für Produktion gedacht (8 CPU, 8 GiB) – im Labor drastisch kleiner:
for p in chat code; do
helm install $p oci://ghcr.io/llm-d/charts/llm-d-router-gateway --version v1.0.0 \
--set router.modelServers.matchLabels.app=sim-$p \
--set router.epp.resources.requests.cpu=10m \
--set router.epp.resources.requests.memory=64Mi \
--set router.epp.resources.limits.memory=256Mi \
--set provider.name=none
done
k rollout status deploy chat-epp
k get inferencepool
k get inferencepool chat -o yaml | sed -n '/^spec:/,/^status:/p'
k get svc chat-eppErwartet (gekürzt):
STATUS: deployed
STATUS: deployed
deployment "chat-epp" successfully rolled out
NAME AGE
chat 31s
code 29s
spec:
appProtocol: http
endpointPickerRef:
failureMode: FailOpen
group: ""
kind: Service
name: chat-epp
port:
number: 9002
selector:
matchLabels:
app: sim-chat
targetPorts:
- number: 8000
status:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
chat-epp ClusterIP 10.96.137.178 <none> 9002/TCP,9090/TCP 57s
Ein InferencePool ist ein „Service für Modellserver“: Selector und Zielport wie ein Service, dazu der Verweis auf den EPP (gRPC, Port 9002). Welche Kriterien der EPP gewichtet, steht in seiner ConfigMap:
k get configmap chat-epp -o jsonpath='{.data.default-plugins\.yaml}' \
| sed -n '/schedulingProfiles/,$p'Erwartet:
schedulingProfiles:
- name: default
plugins:
- pluginRef: queue-scorer
weight: 2
- pluginRef: kv-cache-utilization-scorer
weight: 2
- pluginRef: prefix-cache-scorer
weight: 3
Fortschritt speichern? Kostenlos registrieren
Drill 4: Gateway und Routing nach Modellname
Das Modell steht im JSON-Body, HTTPRoutes können nur Pfad, Header,
Query-Parameter und Methode matchen, nicht den Body. Früher erledigte
das ein eigener ext-proc-Dienst (Body Based Router); agentgateway kann
es selbst – eine Policy in der Phase PreRouting kopiert
body.model in einen Header, bevor die Route gewählt
wird:
cat > gw.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
name: llm
spec:
gatewayClassName: tag18-agentgateway
listeners:
- name: http
protocol: HTTP
port: 80
EOF
cat > model-header.yaml <<'EOF'
apiVersion: agentgateway.dev/v1alpha1
kind: AgentgatewayPolicy
metadata:
name: model-header
spec:
targetRefs:
- group: gateway.networking.k8s.io
kind: Gateway
name: llm
traffic:
phase: PreRouting
transformation:
request:
set:
- name: X-Gateway-Model-Name
value: string(json(request.body).model)
EOF
cat > route.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
name: llm
spec:
parentRefs:
- name: llm
rules:
- matches:
- headers:
- name: X-Gateway-Model-Name
value: ckne/chat
backendRefs:
- group: inference.networking.k8s.io
kind: InferencePool
name: chat
- matches:
- headers:
- name: X-Gateway-Model-Name
value: ckne/code
backendRefs:
- group: inference.networking.k8s.io
kind: InferencePool
name: code
EOF
k apply -f gw.yaml -f model-header.yaml -f route.yaml
k rollout status deploy llm
k get gateway llm
k get svc llm
k get inferencepool chat -o jsonpath=\
'{range .status.parents[0].conditions[*]}{.type}={.status} {.message}{"\n"}{end}'Erwartet:
gateway.gateway.networking.k8s.io/llm created
agentgatewaypolicy.agentgateway.dev/model-header created
httproute.gateway.networking.k8s.io/llm created
deployment "llm" successfully rolled out
NAME CLASS ADDRESS PROGRAMMED AGE
llm tag18-agentgateway True 15s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
llm LoadBalancer 10.99.180.92 <pending> 80:30701/TCP 4s
Accepted=True InferencePool has been accepted by controller agentgateway.dev/…
ResolvedRefs=True All InferencePool references have been resolved
agentgateway startet pro Gateway ein eigenes Proxy-Deployment
llm mit Service. Die LoadBalancer-IP bleibt leer – der
LB-IPAM-Pool aus Tag 15 ist abgebaut –, du testest von innen. Drei
Modellnamen:
for m in ckne/chat ckne/code ckne/gibtsnicht; do
k exec c -- curl -s -w ' HTTP %{http_code}\n' http://llm/v1/chat/completions \
-H 'Content-Type: application/json' \
-d "{\"model\":\"$m\",\"messages\":[{\"role\":\"user\",\"content\":\"Hi\"}]}" \
| grep -oE '"model":"[^"]*"|route not found|HTTP [0-9]+' | paste -sd' '
doneErwartet:
"model":"ckne/chat" HTTP 200
"model":"ckne/code" HTTP 200
route not found HTTP 404
Jetzt die Probe aus Drill 1 mit Cilium – dieselbe Route an einem
cilium-Gateway:
sed -e 's/name: llm$/name: cilium-test/' \
-e 's/gatewayClassName: tag18-agentgateway/gatewayClassName: cilium/' \
gw.yaml > gw-cilium.yaml
sed -e 's/name: llm$/name: cilium-test/' route.yaml > route-cilium.yaml
k apply -f gw-cilium.yaml -f route-cilium.yaml
RC='{range .status.parents[*].conditions[*]}{.type}={.status} '\
'{.reason}: {.message}{"\n"}{end}'
k get httproute cilium-test -o jsonpath="$RC"
k delete -f route-cilium.yaml -f gw-cilium.yamlErwartet:
gateway.gateway.networking.k8s.io/cilium-test created
httproute.gateway.networking.k8s.io/cilium-test created
Accepted=True Accepted: Accepted HTTPRoute
ResolvedRefs=False InvalidKind: Unsupported backend kind InferencePool
Fortschritt speichern? Kostenlos registrieren
Drill 5: Modell-Aliase mit InferenceModelRewrite
Clients sollen assistant sagen dürfen, gemeint ist
ckne/chat. Die Route muss den Alias kennen (Pool-Auswahl),
der EPP schreibt den Namen im Body um:
k explain inferencemodelrewrite.spec.rules.targets
cat > rewrite.yaml <<'EOF'
apiVersion: llm-d.ai/v1alpha2
kind: InferenceModelRewrite
metadata:
name: assistant
spec:
poolRef:
group: inference.networking.k8s.io
kind: InferencePool
name: chat
rules:
- matches:
- model:
type: Exact
value: assistant
targets:
- modelRewrite: ckne/chat
EOF
k apply -f rewrite.yaml
k patch httproute llm --type=json -p '[{"op":"add","path":"/spec/rules/0/matches/-",
"value":{"headers":[{"name":"X-Gateway-Model-Name","value":"assistant"}]}}]'
k get inferencemodelrewrite
A='{"model":"assistant","messages":[{"role":"user","content":"Hi"}],"max_tokens":3}'
k exec c -- curl -s -w ' HTTP %{http_code}\n' http://llm/v1/chat/completions \
-H 'Content-Type: application/json' -d "$A"
k logs deploy/chat-epp --tail=5 \
| grep -o '"modelName":"[^"]*","targetModelName":"[^"]*"' | tail -1
P=$(k get pod -l speed=fast -o jsonpath='{.items[0].status.podIP}')
k exec c -- curl -s http://$P:8000/v1/chat/completions \
-H 'Content-Type: application/json' -d "$A"; echoErwartet (gekürzt):
FIELDS:
modelRewrite <string> -required-
weight <integer>
inferencemodelrewrite.llm-d.ai/assistant created
httproute.gateway.networking.k8s.io/llm patched
NAME INFERENCE POOL AGE
assistant chat 5s
{"id":"chatcmpl-5049be68-...","model":"assistant",...} HTTP 200
"modelName":"assistant","targetModelName":"ckne/chat"
{"error":{"message":"The model `assistant` does not exist.","type":"NotFoundError",...}}
Der Simulator selbst kennt assistant nicht – über das
Gateway klappt es, weil der EPP vorher umschreibt. Mit mehreren
targets und weight wird daraus ein
Modell-Canary (etwa 90 % altes, 10 % neues Modell unter demselben
Namen). InferenceObjective (llm-d.ai/v1)
ergänzt pro Anfrage eine priority für das Abwerfen bei
Überlast – k explain inferenceobjective.spec.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Lastverteilung nach Warteschlange
Zum Vergleich ein normaler Service über beide Chat-Pods. 40 Anfragen, 8 parallel – erst über den Service, dann über das Gateway. Vor jeder Runde starten die Pods neu, damit die Zähler bei null beginnen (die Anfragen aus Drill 2, 4 und 5 zählen sonst mit):
k rollout restart deploy chat-fast chat-slow
k rollout status deploy chat-slow
k create service clusterip chat-svc --tcp=8000:8000 $do \
| sed 's/app: chat-svc/app: sim-chat/' | k apply -f -
L='{"model":"ckne/chat","messages":[{"role":"user","content":"Los"}],"max_tokens":20}'
time k exec c -- sh -c "seq 40 | xargs -P 8 -I{} curl -s -o /dev/null \
http://chat-svc:8000/v1/chat/completions -H 'Content-Type: application/json' -d '$L'"
for p in fast slow; do
IP=$(k get pod -l speed=$p -o jsonpath='{.items[0].status.podIP}')
echo "$p: $(k exec c -- curl -s http://$IP:8000/metrics \
| awk '/^vllm:request_success_total/ {s+=$2} END {print s}')"
doneErwartet (gekürzt, Zahlen schwanken):
deployment.apps/chat-fast restarted
deployment.apps/chat-slow restarted
service/chat-svc created
real 0m19.656s
fast: 19
slow: 21
Der Service verteilt blind (Cilium wählt zufällig) – der langsame Pod bekommt die Hälfte und staut. Jetzt das Gateway; 30 Sekunden nach dem Neustart hat der EPP frische Metriken:
k rollout restart deploy chat-fast chat-slow
k rollout status deploy chat-slow
sleep 30
time k exec c -- sh -c "seq 40 | xargs -P 8 -I{} curl -s -o /dev/null \
http://llm/v1/chat/completions -H 'Content-Type: application/json' -d '$L'"
for p in fast slow; do
IP=$(k get pod -l speed=$p -o jsonpath='{.items[0].status.podIP}')
echo "$p: $(k exec c -- curl -s http://$IP:8000/metrics \
| awk '/^vllm:request_success_total/ {s+=$2} END {print s}')"
doneErwartet (gekürzt, Zahlen schwanken):
real 0m10.851s
fast: 28
slow: 12
Fast doppelt so schnell fertig, der schnelle Pod trägt über zwei
Drittel. Die Warteschlangen selbst kannst du während einer Runde
beobachten – in einem zweiten Terminal, während im ersten die
Gateway-Runde mit mehr Last läuft (seq 60 | xargs -P 12
statt seq 40 | xargs -P 8):
for p in fast slow; do
IP=$(k get pod -l speed=$p -o jsonpath='{.items[0].status.podIP}')
echo "== $p"
k exec c -- curl -s http://$IP:8000/metrics | grep -E '^vllm:num_requests_waiting'
doneErwartet (Momentaufnahme über das Gateway, 60 Anfragen, 12 parallel):
== fast
vllm:num_requests_waiting{model_name="ckne/chat"} 2
== slow
vllm:num_requests_waiting{model_name="ckne/chat"} 4
Über den Service waren es im selben Test 0 (fast) zu 9 (slow). Genau
diese Metrik liest der queue-scorer des EPP von jedem Pod
(/metrics) und zieht volle Warteschlangen ab.
Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Zeige alle InferencePools mit Selector, Zielport und EPP in einer Tabelle. Zeitziel: 60 s
- Mache
helperzum Alias fürckne/code. Zeitziel: 3 min - Zeige die Warteschlangenlänge aller Chat-Pods. Zeitziel: 60 s
Lösung
k get inferencepool -o custom-columns='NAME:.metadata.name,'\
'SELECTOR:.spec.selector.matchLabels,PORT:.spec.targetPorts[0].number,'\
'EPP:.spec.endpointPickerRef.name'
sed -e 's/name: assistant/name: helper/' -e 's/value: assistant/value: helper/' \
-e 's/name: chat$/name: code/' -e 's#ckne/chat#ckne/code#' rewrite.yaml \
> rewrite-helper.yaml
k apply -f rewrite-helper.yaml
k patch httproute llm --type=json -p '[{"op":"add","path":"/spec/rules/1/matches/-",
"value":{"headers":[{"name":"X-Gateway-Model-Name","value":"helper"}]}}]'
k exec c -- curl -s http://llm/v1/chat/completions -H 'Content-Type: application/json' \
-d '{"model":"helper","messages":[{"role":"user","content":"Hi"}],"max_tokens":3}'
echo
k logs deploy/code-epp --tail=5 \
| grep -o '"modelName":"[^"]*","targetModelName":"[^"]*"' | tail -1
for p in $(k get pod -l app=sim-chat -o jsonpath='{.items[*].status.podIP}'); do
echo "== $p"
k exec c -- curl -s http://$p:8000/metrics | grep -E '^vllm:num_requests_waiting'
doneErwartet (gekürzt):
NAME SELECTOR PORT EPP
chat map[app:sim-chat] 8000 chat-epp
code map[app:sim-code] 8000 code-epp
inferencemodelrewrite.llm-d.ai/helper created
httproute.gateway.networking.k8s.io/llm patched
{"id":"chatcmpl-c0f08dfd-...","model":"helper",...}
"modelName":"helper","targetModelName":"ckne/code"
== 10.0.2.220
vllm:num_requests_waiting{model_name="ckne/chat"} 0
== 10.0.1.20
vllm:num_requests_waiting{model_name="ckne/chat"} 0
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
k get gatewayclass tag18-agentgatewayErwartet: ACCEPTED True, Controller
agentgateway.dev/agentgateway.
k get inferencepoolErwartet: chat und
code.
A='{"model":"assistant","messages":[{"role":"user","content":"Hi"}],"max_tokens":3}'
k exec c -- curl -s -o /dev/null -w '%{http_code}\n' http://llm/v1/chat/completions \
-H 'Content-Type: application/json' -d "$A"Erwartet: 200 (Alias
assistant über Pool chat).
k get httproute llm -o jsonpath='{.status.parents[0].conditions[1].reason}{"\n"}'Erwartet: ResolvedRefs.
Challenge
Was passiert mit dem Pool chat, wenn sein EPP ausfällt?
Prüfe beide Werte von failureMode und stelle danach den
Ausgangszustand wieder her.
Hinweis: Das Feld steht in
spec.endpointPickerRef des InferencePools; den EPP
schaltest du mit k scale ab.
Lösung
k scale deploy chat-epp --replicas=0
k wait --for=delete pod -l llm-d-router-gateway=chat-epp
k get inferencepool chat -o jsonpath='{.spec.endpointPickerRef.failureMode}{"\n"}'
for i in 1 2 3; do
k exec c -- curl -s -o /dev/null -w '%{http_code}\n' http://llm/v1/chat/completions \
-H 'Content-Type: application/json' -d "$B"
done
k patch inferencepool chat --type=merge \
-p '{"spec":{"endpointPickerRef":{"failureMode":"FailClose"}}}'
k exec c -- curl -s -w ' %{http_code}\n' http://llm/v1/chat/completions \
-H 'Content-Type: application/json' -d "$B"
k patch inferencepool chat --type=merge \
-p '{"spec":{"endpointPickerRef":{"failureMode":"FailOpen"}}}'
k scale deploy chat-epp --replicas=1
k rollout status deploy chat-eppErwartet:
deployment.apps/chat-epp scaled
pod/chat-epp-6bb6b58995-4b28b condition met
FailOpen
200
200
200
inferencepool.inference.networking.k8s.io/chat patched
external processing failed 500
inferencepool.inference.networking.k8s.io/chat patched
deployment.apps/chat-epp scaled
deployment "chat-epp" successfully rolled out
FailOpen hält den Dienst am Leben – das Gateway wählt
dann ohne EPP selbst einen Pod, die Intelligenz ist weg.
FailClose liefert lieber Fehler als falsch verteilte Last.
Ein helm upgrade des Pools setzt den Patch zurück;
dauerhaft gehört der Wert in die Helm-Werte.
Fortschritt speichern? Kostenlos registrieren
Aufräumen
Alles von Tag 18 kommt wieder weg – auch agentgateway und die Inference-CRDs:
helm uninstall chat code
k delete namespace tag18
helm uninstall agentgateway agentgateway-crds -n tag18-agentgateway
k delete namespace tag18-agentgateway
k delete --ignore-not-found gatewayclass tag18-agentgateway
GIE=https://github.com/kubernetes-sigs/gateway-api-inference-extension
k delete -f $GIE/releases/download/v1.6.2/v1-manifests.yaml
k delete \
-f https://github.com/llm-d/llm-d-router/releases/download/v1.0.0/manifests.yaml
k config set-context --current --namespace=defaultDie Gateway-API-CRDs und Ciliums Gateway-Controller aus Tag 10 bleiben.
Prüfungstipp
- Merke die Kette: HTTPRoute →
backendRefmitgroup: inference.networking.k8s.io,kind: InferencePool→ Pool mitselector,targetPorts,endpointPickerRef. - Status am InferencePool lesen
(
.status.parents[*].conditions):Acceptedsagt, ob ein Gateway-Controller den Pool überhaupt unterstützt. Ciliums Antwort an der Route:InvalidKind. - Doku: gateway-api-inference-extension.sigs.k8s.io („API Overview“,
„Implementations“), llm-d.ai für EPP und
InferenceObjective.
Enterprise-Notiz
- Echte Modellserver (vLLM, SGLang, Triton) liefern dieselben Metriken; der EPP wertet zusätzlich KV-Cache-Auslastung und Prefix-Cache-Treffer aus – das spart GPU-Zeit bei wiederkehrenden Prompts.
- EPP ist kritisch im Datenpfad: mehrere Replikas (Leader Election
oder active-active),
failureModebewusst wählen, Ressourcen nach Last bemessen. - Ein Inference Gateway ersetzt kein AI Gateway: Token-Budgets, Guardrails und API-Schlüssel für externe Anbieter sind eine Schicht darüber (agentgateway kann beides).
- Die APIs bewegen sich schnell (InferenceModel → InferenceObjective, Umzug nach llm-d): Versionen von CRDs, EPP und Gateway gemeinsam festschreiben.
- Ciliums eigenes Gateway bleibt für normalen HTTP-Verkehr zuständig; ein zweiter Controller nur für Inferenz ist üblich und über die GatewayClass sauber getrennt.