Zum Inhalt springen
Trainingslager IT-Trainingslager

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 InferencePool als 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, InferenceObjective und InferenceModelRewrite sind 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 inference

Erwartet: 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 gatewayclass

Erwartet (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-epp

Erwartet (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' '
done

Erwartet:

"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.yaml

Erwartet:

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"; echo

Erwartet (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}')"
done

Erwartet (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}')"
done

Erwartet (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'
done

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

  1. Zeige alle InferencePools mit Selector, Zielport und EPP in einer Tabelle. Zeitziel: 60 s
  2. Mache helper zum Alias für ckne/code. Zeitziel: 3 min
  3. 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'
done

Erwartet (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-agentgateway

Erwartet: ACCEPTED True, Controller agentgateway.dev/agentgateway.

k get inferencepool

Erwartet: 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-epp

Erwartet:

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=default

Die Gateway-API-CRDs und Ciliums Gateway-Controller aus Tag 10 bleiben.

Prüfungstipp

  • Merke die Kette: HTTPRoute → backendRef mit group: inference.networking.k8s.io, kind: InferencePool → Pool mit selector, targetPorts, endpointPickerRef.
  • Status am InferencePool lesen (.status.parents[*].conditions): Accepted sagt, 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), failureMode bewusst 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.