In diesem Dokument wird beschrieben, wie Sie das GKE-Inferenz-Gateway bereitstellen.
Dieses Dokument richtet sich an Netzwerkexperten, die für die Verwaltung der GKE-Infrastruktur verantwortlich sind, und an Plattformadministratoren, die KI-Arbeitslasten verwalten.
Bevor Sie diese Seite lesen, sollten Sie mit Folgendem vertraut sein:
- Informationen zum GKE Inference Gateway
- KI‑/ML-Orchestrierung in der GKE
- Glossar zu generativer KI
- Load-Balancing inCloud de Confiance, insbesondere die Interaktion von Load Balancern mit GKE.
- GKE-Service Extensions. Weitere Informationen finden Sie in der Dokumentation zum GKE-Gateway-Controller.
- GKE-Gateway-Traffic mit Service Extensions anpassen
Das GKE Inference Gateway erweitert das Google Kubernetes Engine-Gateway (GKE), um die Bereitstellung von generativen KI-Anwendungen und ‑Arbeitslasten in der GKE zu optimieren. Sie ermöglicht eine effiziente Verwaltung und Skalierung von KI-Arbeitslasten, arbeitslastspezifische Leistungsziele wie Latenz sowie eine verbesserte Ressourcenauslastung, Beobachtbarkeit und KI-Sicherheit.
Hinweis
Führen Sie die folgenden Aufgaben aus, bevor Sie beginnen:
- Aktivieren Sie die Google Kubernetes Engine API. Google Kubernetes Engine API aktivieren
- Wenn Sie die Google Cloud CLI für diese Aufgabe verwenden möchten, müssen Sie die gcloud CLI installieren und dann initialisieren. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die aktuelle Version mit dem Befehl
gcloud components updateab. Ältere gcloud CLI-Versionen unterstützen möglicherweise nicht die Ausführung der Befehle in diesem Dokument.
Aktivieren Sie die Compute Engine API, die Kubernetes Engine API, die Network Services API und die Model Armor API, falls erforderlich.
Rufen Sie Zugriff auf APIs aktivieren auf und folgen Sie der Anleitung.
Sie benötigen die folgenden Rollen für das Projekt:
roles/container.admin,roles/iam.serviceAccountAdmin.Prüfen Sie, ob Ihr Projekt ein ausreichendes Kontingent für H100-GPUs hat. Weitere Informationen finden Sie unter GPU-Kontingent planen und Zuteilungskontingente.
Erstellen Sie ein Hugging Face-Konto, falls Sie noch keines haben. Sie benötigen diese, um auf die Modellressourcen für diese Anleitung zuzugreifen.
Zugriff auf das Llama 3.1-Modell anfordern und ein Zugriffstoken generieren Für den Zugriff auf dieses Modell ist eine genehmigte Anfrage auf Hugging Face erforderlich. Die Bereitstellung schlägt fehl, wenn der Zugriff nicht gewährt wurde.
- Lizenz-Einwilligungsvereinbarung unterzeichnen: Sie müssen die Einwilligungsvereinbarung unterzeichnen, um das Llama 3.1-Modell verwenden zu können. Rufen Sie die Seite des Modells auf Hugging Face auf, bestätigen Sie Ihr Konto und akzeptieren Sie die Nutzungsbedingungen.
- Zugriffstoken generieren: Für den Zugriff auf das Modell benötigen Sie ein Hugging Face-Token. Rufen Sie in Ihrem Hugging Face-Konto Mein Profil > Einstellungen > Zugriffstokens auf, erstellen Sie ein neues Token mit mindestens Leseberechtigungen und kopieren Sie es in die Zwischenablage.
Konfigurieren Sie ein Nur-Proxy-Subnetz für Ihr VPC-Netzwerk. Der Gateway-Controller benötigt ein aktives Nur-Proxy-Subnetz in der Region, um den Application Load Balancer bereitzustellen.
Anforderungen für GKE Gateway Controller
- GKE-Version 1.32.3 oder höher.
- Google Cloud CLI-Version 407.0.0 oder höher.
- Die Gateway API wird nur in VPC-nativen Clustern unterstützt.
- Für den Cluster muss das Add-on
HttpLoadBalancingaktiviert sein. - Wenn Sie Istio verwenden, müssen Sie Istio auf eine der folgenden Versionen aktualisieren:
- 1.15.2 oder höher
- 1.14.5 oder höher
- 1.13.9 oder höher
- Wenn Sie eine freigegebene VPC verwenden, müssen Sie dem GKE-Dienstkonto für das Dienstprojekt im Hostprojekt die Rolle
Compute Network Userzuweisen.
Limits und Einschränkungen
Es gelten die folgenden Einschränkungen:
- Das GKE Inference Gateway wird nur für die GatewayClass-Ressourcen
gke-l7-regional-external-managedundgke-l7-rilbunterstützt. - Regionenübergreifende interne Application Load Balancer werden nicht unterstützt.
- Ein InferencePool kann maximal acht
targetPortshaben.
GKE Inference Gateway konfigurieren
Sehen Sie sich dieses Beispiel an, um das GKE Inference Gateway zu konfigurieren. Ein Team führt die Modelle vLLM und Llama3 aus und experimentiert aktiv mit zwei verschiedenen LoRA-feinabgestimmten Adaptern: „food-review“ und „cad-fabricator“.
Der allgemeine Workflow zum Konfigurieren des GKE Inference Gateways sieht so aus:
- Umgebung vorbereiten: Richten Sie die erforderliche Infrastruktur und die Komponenten ein.
- Inferenzpool erstellen: Definieren Sie einen Pool von Modellservern mit der benutzerdefinierten Ressource „InferencePool“.
- Inferenzziele angeben: Geben Sie Inferenzziele mit der benutzerdefinierten Ressource
InferenceObjectivean. - Gateway erstellen: Stellen Sie den Inferenzdienst über die Gateway API bereit.
HTTPRouteerstellen: Definieren Sie, wie HTTP-Traffic an den Inferenzdienst weitergeleitet wird.- Inferenzanfragen senden: Anfragen an das bereitgestellte Modell senden.
Gateway erstellen
Die Gateway-Ressource ist der Einstiegspunkt für externen Traffic in Ihren Kubernetes-Cluster. Sie definiert die Listener, die eingehende Verbindungen akzeptieren.
Das GKE Inference Gateway funktioniert mit den folgenden Gateway-Klassen:
gke-l7-rilb: für regionale interne Application Load Balancer.gke-l7-regional-external-managed: für regionale externe Application Load Balancer.
Weitere Informationen finden Sie in der Dokumentation zu Gateway-Klassen.
So erstellen Sie ein Gateway:
Speichern Sie das folgende Beispielmanifest als
gateway.yaml:apiVersion: gateway.networking.k8s.io/v1 kind: Gateway metadata: name: GATEWAY_NAME spec: gatewayClassName: GATEWAY_CLASS listeners: - protocol: HTTP port: 80 name: httpErsetzen Sie Folgendes:
GATEWAY_NAME: Ein eindeutiger Name für Ihre Gateway-Ressource. Beispiel:inference-gateway.GATEWAY_CLASS: die Gateway-Klasse, die Sie verwenden möchten. Beispiel:gke-l7-regional-external-managed.
Wenden Sie das Manifest auf Ihren Cluster an:
kubectl apply -f gateway.yaml
Hinweis: Weitere Informationen zum Konfigurieren von TLS zum Sichern Ihres Gateways mit HTTPS finden Sie in der GKE-Dokumentation zur TLS-Konfiguration.
Umgebung vorbereiten
Installieren Sie Helm.
Erstellen Sie einen GKE-Cluster.
- Erstellen Sie einen GKE Autopilot- oder Standardcluster mit Version 1.32.3 oder höher. Eine Referenzeinrichtung für die Bereitstellung mit einem Klick finden Sie im
cluster-toolkit gke-a3-highgpu-Beispiel. - Konfigurieren Sie die Knoten mit der gewünschten Computing-Familie und dem gewünschten Beschleuniger.
- Verwenden Sie die GKE Inference-Kurzanleitung für vorkonfigurierte und getestete Bereitstellungsmanifeste, die auf dem ausgewählten Beschleuniger, Modell und den Leistungsanforderungen basieren.
- Erstellen Sie einen GKE Autopilot- oder Standardcluster mit Version 1.32.3 oder höher. Eine Referenzeinrichtung für die Bereitstellung mit einem Klick finden Sie im
Installieren Sie die erforderlichen benutzerdefinierten Ressourcendefinitionen (CRDs) in Ihrem GKE-Cluster:
In GKE-Versionen ab
1.34.0-gke.1626000ist die CRDInferencePoolstandardmäßig enthalten. Installieren Sie daher nur die Alpha-CRDInferenceObjective:kubectl apply -f https://github.com/kubernetes-sigs/gateway-api-inference-extension/raw/v1.5.0/config/crd/bases/inference.networking.x-k8s.io_inferenceobjectives.yamlInstallieren Sie für GKE-Versionen vor
1.34.0-gke.1626000sowohl die v1-InferencePool- als auch die Alpha-InferenceObjective-CRDs:kubectl apply -f https://github.com/kubernetes-sigs/gateway-api-inference-extension/releases/download/v1.5.0/manifests.yamlWeitere Informationen finden Sie in der Kompatibilitätsmatrix.
Wenn Sie eine GKE-Version vor
v1.32.2-gke.1182001verwenden und Model Armor mit dem GKE Inference Gateway verwenden möchten, müssen Sie die CRDs für die Traffic- und Routing-Erweiterung installieren:kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-gateway-api/refs/heads/main/config/crd/networking.gke.io_gcptrafficextensions.yaml kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-gateway-api/refs/heads/main/config/crd/networking.gke.io_gcproutingextensions.yamlLegen Sie die folgenden Umgebungsvariablen fest:
export GAIE_VERSION=v1.5.0 export GUIDE_NAME="optimized-baseline" export NAMESPACE=llm-d-optimized-baseline export INFRA_PROVIDER=gke # gke | baseInstallieren Sie die benutzerdefinierten Ressourcendefinitionen (CRDs) für die Gateway API Inference Extension, die für den llm-d-Endpunktauswahl (EPP) erforderlich sind:
kubectl apply -k \ "https://github.com/kubernetes-sigs/gateway-api-inference-extension/config/crd?ref=${GAIE_VERSION}"Erstellen Sie den Ziel-Namespace:
kubectl create namespace ${NAMESPACE}
Modellserver und Modellbereitstellung erstellen
In diesem Abschnitt wird beschrieben, wie Sie einen Modellserver und ein Modell bereitstellen. Im Beispiel wird ein vLLM-Modellserver mit einem Llama3-Modell verwendet. Das Deployment ist mit app:vllm-llama3-8b-instruct gekennzeichnet. In diesem Deployment werden auch zwei LoRA-Adapter namens food-review und cad-fabricator von Hugging Face verwendet.
Sie können dieses Beispiel mit Ihrem eigenen Modell-Server-Container und Modell, Bereitstellungsport und Bereitstellungsnamen anpassen. Sie können auch LoRA-Adapter in der Bereitstellung konfigurieren oder das Basismodell bereitstellen. In den folgenden Schritten wird beschrieben, wie Sie die erforderlichen Kubernetes-Ressourcen erstellen.
Erstellen Sie ein Kubernetes-Secret, um Ihr Hugging Face-Token zu speichern. Dieses Token wird für den Zugriff auf das Basismodell und die LoRA-Adapter verwendet:
kubectl create secret generic hf-token --from-literal=token=HF_TOKENErsetzen Sie
HF_TOKENdurch Ihr Hugging Face-Token.Stellen Sie den vLLM-Modellserver mit dem GKE-spezifischen Kustomize-Overlay aus dem Leitfaden „llm-d optimized-baseline“ bereit. Mit der Einstellung
INFRA_PROVIDER=gkewerden GKE-spezifische Konfigurationen angewendet, einschließlich der Cloud Monitoring-Integration:kubectl apply -n ${NAMESPACE} \ -k guides/${GUIDE_NAME}/modelserver/gpu/vllm/${INFRA_PROVIDER}/
Hinweis: GKE bietet standardmäßig ein automatisches Anwendungsmonitoring. Der llm-d-Monitoring-Stack ist für GKE nicht erforderlich, kann aber verwendet werden, wenn Sie ihn bevorzugen.
Wenn Ihr Modellserver mehrere Ports benötigt, müssen Sie dafür sorgen, dass die Container-Spezifikation jeden Port verfügbar macht. Im folgenden Beispiel wird ein Deployment definiert, bei dem der Container drei Ports verfügbar macht:
Beispiel für ein Deployment mit mehreren Ports
apiVersion: apps/v1
kind: Deployment
metadata:
name: multiport-model-server
spec:
replicas: 3
selector:
matchLabels:
app: multiport-model-server
template:
metadata:
labels:
app: multiport-model-server
spec:
containers:
- name: model-server
image: your-model-server-image
ports:
- containerPort: 8080
- containerPort: 8081
- containerPort: 9000
Inferenzpool erstellen
Die benutzerdefinierte Kubernetes-Ressource „InferencePool“ definiert eine Gruppe von Pods mit einem gemeinsamen Large Language Model (LLM) und einer gemeinsamen Rechenkonfiguration. Das Feld selector gibt an, welche Pods zu diesem Pool gehören. Die Labels in diesem Selektor müssen genau mit den Labels übereinstimmen, die auf die Pods Ihres Modellservers angewendet wurden. Das Feld targetPorts definiert die Ports, die der Modellserver in den Pods verwendet. Sie können bis zu acht Ports angeben. Das Feld extensionRef verweist auf einen Erweiterungsdienst, der zusätzliche Funktionen für den Inferenzpool bietet. Der InferencePool ermöglicht es dem GKE Inference Gateway, Traffic an Ihre Modellserver-Pods weiterzuleiten.
Das folgende InferencePool-Manifest gibt mehrere targetPorts an, die den vom Modellserver-Deployment bereitgestellten Ports entsprechen:
Beispiel für einen InferencePool mit mehreren Ports
apiVersion: inference.networking.k8s.io/v1
kind: InferencePool
metadata:
name: my-multiport-pool
namespace: default
spec:
selector:
matchLabels:
app: multiport-model-server
targetPorts:
- number: 8080
- number: 8081
- number: 9000
Bevor Sie den InferencePool erstellen, müssen Sie dafür sorgen, dass die Modellserver-Pods, die der InferencePool auswählt, bereits ausgeführt werden.
Klonen Sie die Rezepte und Empfehlungen für den InferencePool aus dem llm-d-GitHub-Repository. Dieser Schritt ist erforderlich:
git clone https://github.com/llm-d/llm-d -b v0.7.0 && cd llm-d
So erstellen Sie einen InferencePool und einen Endpoint Picker mit Helm:
helm install ${GUIDE_NAME} \
-f guides/recipes/scheduler/base.values.yaml \
-f guides/${GUIDE_NAME}/scheduler/${GUIDE_NAME}.values.yaml \
--set provider.name=gke \
--set inferenceExtension.monitoring.gke.enabled=true \
-n ${NAMESPACE} \
--version ${GAIE_VERSION} \
oci://LLM_D_REGISTRY_PATH
Ersetzen Sie Folgendes:
GAIE_VERSION: die Version des Helm-Diagramms. Beispiel:v1.5.0.LLM_D_REGISTRY_PATH: der OCI-Registry-Pfad für das Helm-Diagramm. Beispiel:registry.k8s.io/gateway-api-inference-extension/charts/inferencepool.
Ändern Sie in der Datei guides/recipes/scheduler/base.values.yaml das folgende Feld so, dass es dem Label des Bereitstellungs-Pods Ihres Modells entspricht:
inferencePool.modelServers.matchLabels: Der Schlüssel und der Wert des Labels, mit dem die Pods des Modellservers ausgewählt werden.Hinweis: Der Schlüssel und der Wert entsprechen dem Beispiel im
optimized-baseline-Leitfaden. Wir ersetzen sie daher, damit sie mit den Labels Ihres Bereitstellungs-Pods übereinstimmen.
Für das Monitoring ist das Scraping von Messwerten für Google Cloud Managed Service for Prometheus standardmäßig aktiviert.
- Wenn Sie diese Funktion deaktivieren möchten, fügen Sie dem Befehl das Flag
--set inferenceExtension.monitoring.prometheus.enabled=falsehinzu. - Wenn Sie das Standardmonitoring für einen GKE Autopilot-Cluster verwenden, müssen Sie auch das Flag
--set provider.gke.autopilot=truehinzufügen.
Bei der Helm-Installation werden die erforderliche Zeitüberschreitungsrichtlinie, die Endpunktauswahl und die für die Beobachtbarkeit erforderlichen Pods automatisch installiert.
Dadurch wird ein InferencePool-Objekt erstellt: vllm-llama3-8b-instruct, das auf die Modellendpunktdienste in den Pods verweist. Außerdem wird für diesen erstellten InferencePool ein Deployment des Endpoint Pickers mit dem Namen app:vllm-llama3-8b-instruct-epp erstellt.
Endpunktauswahl mit Hochverfügbarkeit bereitstellen
Wenn Sie Endpoint Picker (EPP) mit bevorzugten Backends bereitstellen, wird eine Aktiv/Passiv-Routingtopologie ermöglicht, die von Cloud Load Balancing unterstützt wird.
Die Verwendung der Endpunktauswahl mit bevorzugten Back-Ends bietet folgende Vorteile:
- Zustandskonsistenz: Cloud Load Balancing leitet 100 % des stabilen
ext_proc-Traffics an das primäre Endpoint Picker-Replikat (epp-0) weiter, wodurch der Zustand des Schlüssel/Wert-Caches (KV-Cache) und der Kontext der Anfrageplanung erhalten bleiben. - Failover ohne Ausfallzeiten: Wenn der primäre Endpoint Picker-Pod abstürzt oder gewartet wird, erkennt Cloud Load Balancing den Fehler mithilfe aktiver gRPC-Systemdiagnosen und leitet den Traffic sofort an das Standby-Replikat (
epp-1) weiter. - Fail-Open-Resilienz: In Kombination mit
failureMode: FailOpenumgehen vorübergehende Routingfehler den Endpoint Picker und ermöglichen die direkte Weiterleitung von Anfragen an Modellserver, ohne dass Nutzeranfragen verworfen werden.
Wenn Sie bevorzugte Back-Ends aktivieren, ändert GKE die Architektur und das Routing folgendermaßen:
- StatefulSet-Architektur für die Endpunktauswahl: Die Endpunktauswahl wird als StatefulSet anstelle eines Deployments bereitgestellt. Pod-Ordnungszahlen geben die Replikatrollen an: Die Ordnungszahl
epp-0dient als primäres Replikat, das an die Backend-StufePREFERREDangehängt ist, und die Ordnungszahlepp-1dient als Standby-Replikat, das an die StufeDEFAULTangehängt ist. - Routingstatus bleibt zentralisiert: Der
ext_proc-Traffic im stabilen Zustand wird ausschließlich an das primäre Endpoint Picker-Replikat (epp-0) weitergeleitet, um das KV-Cache-Tracking (Schlüssel/Wert-Cache) und den Status der Anfrageplanung zentralisiert zu halten. Wennepp-0fehlerhaft wird, verlagert Cloud Load Balancing den Traffic auf das Stand-by-Replikat (epp-1). - Dual-Service-Architektur: Das Helm-Diagramm erstellt einen primären Dienst (
Service/${GUIDE_NAME}-epp) und einen Standby-Backup-Dienst (Service/${GUIDE_NAME}-epp-backup). Die RessourceInferencePoolzielt deklarativ auf den Standby-Backup-Dienst ab. Durch die Verankerung der deklarativen Gateway-Inhaberschaft am Standby-Dienst wird sichergestellt, dass die Abgleichschleifen des GKE-Gateway-Controllers die primären Netzwerk-Endpunktgruppen (NEGs), die Sie an den Backend-Dienst anhängen, nicht trennen.
Führen Sie die folgenden Schritte aus, um einen InferencePool und einen Endpoint Picker mit Hochverfügbarkeit mithilfe von Helm zu erstellen:
Stellen Sie den InferencePool und die Endpunktauswahl mit bevorzugten Backends mithilfe von Helm bereit:
helm install ${GUIDE_NAME} \ -f guides/recipes/scheduler/base.values.yaml \ -f guides/${GUIDE_NAME}/scheduler/${GUIDE_NAME}.values.yaml \ --set provider.name=gke \ --set inferenceExtension.monitoring.gke.enabled=true \ --set provider.gke.preferredBackends.enabled=true \ --set provider.gke.preferredBackends.preferredReplicas=1 \ --set provider.gke.preferredBackends.defaultReplicas=1 \ -n ${NAMESPACE} \ --version ${GAIE_VERSION} \ oci://LLM_D_REGISTRY_PATHErsetzen Sie Folgendes:
GAIE_VERSION: die Version der Gateway API Inference Extension (GAIE) des Helm-Diagramms. Beispiel:v1.5.0Für bevorzugte Backends ist die Helm-Diagrammversionv1.5.0oder höher erforderlich.LLM_D_REGISTRY_PATH: der OCI-Registry-Pfad für das Helm-Diagramm. Beispiel:registry.k8s.io/gateway-api-inference-extension/charts/inferencepool
Eine vollständige Liste der Parameter finden Sie unter
values.yaml.Hängen Sie die primäre NEG an
BackendServicean:export PROJECT_ID=PROJECT_ID export REGION=REGION export BACKEND_SERVICE=$(gcloud compute backend-services list --project=${PROJECT_ID} --format="value(name)" | grep "${GUIDE_NAME}-epp") export PRIMARY_NEG=$(kubectl get svc ${GUIDE_NAME}-epp -n ${NAMESPACE} -o jsonpath='{.metadata.annotations.cloud\.google\.com/neg-status}' | jq -r '.network_endpoint_groups["9002"]') for ZONE in $(kubectl get svc ${GUIDE_NAME}-epp -n ${NAMESPACE} -o jsonpath='{.metadata.annotations.cloud\.google\.com/neg-status}' | jq -r '.zones[]'); do gcloud compute backend-services add-backend ${BACKEND_SERVICE} \ --network-endpoint-group=${PRIMARY_NEG} \ --network-endpoint-group-zone=${ZONE} \ --region=${REGION} \ --project=${PROJECT_ID} \ --balancing-mode=RATE \ --max-rate-per-endpoint=100 \ --preference=PREFERRED sleep 15 doneErsetzen Sie Folgendes:
PROJECT_ID: Projekt-ID in Cloud de Confiance by S3NS .REGION: die Cloud de Confiance Region Ihres Clusters und Backend-Dienstes.
Nachdem zonale NEGs an den Cloud de Confiance by S3NS BackendServiceangehängt wurden, müssen Sie zum Skalieren der Replikatanzahl (preferredReplicas oder defaultReplicas) oder zum Neustarten von Pods keine gcloud-Befehle mehr ausführen. Der GKE-NEG-Controller synchronisiert automatisch einzelne Pod-IP-Adressen in die registrierten zonalen NEGs.
Wenn Sie die übergeordnete Gateway- oder InferencePool-Ressource löschen und neu erstellen, erstellt der GKE-Gateway-Controller die zugrunde liegende Cloud de Confiance by S3NS-BackendService mit einer neuen Cloud-ID neu. Führen Sie in diesem Fall den vorherigen Anhangsworkflow aus, um primäre zonale NEGs an die neu erstellte BackendService anzuhängen.
HTTPRoute erstellen
Die Ressource HTTPRoute definiert, wie das GKE-Gateway eingehende HTTP-Anfragen an Backend-Dienste wie Ihren InferencePool weiterleitet. Die Ressource HTTPRoute gibt Abgleichsregeln (z. B. Header oder Pfade) und das Backend an, an das der Traffic weitergeleitet werden soll.
Speichern Sie zum Erstellen eines
HTTPRoutedas folgende Beispielmanifest alshttproute.yaml:apiVersion: gateway.networking.k8s.io/v1 kind: HTTPRoute metadata: name: HTTPROUTE_NAME spec: parentRefs: - name: GATEWAY_NAME rules: - matches: - path: type: PathPrefix value: PATH_PREFIX backendRefs: - name: INFERENCE_POOL_NAME group: "inference.networking.k8s.io" kind: InferencePoolErsetzen Sie Folgendes:
HTTPROUTE_NAME: ein eindeutiger Name für IhreHTTPRoute-Ressource. Beispiel:my-routeGATEWAY_NAME: der Name der von Ihnen erstelltenGateway-Ressource. Beispiel:inference-gatewayPATH_PREFIX: das Pfadpräfix, das Sie zum Abgleichen eingehender Anfragen verwenden. Beispiel:/, um alle abzugleichen.INFERENCE_POOL_NAME: der Name der InferencePool-Ressource, an die Sie Traffic weiterleiten möchten. Beispiel:vllm-llama3-8b-instruct.
Wenden Sie das Manifest auf Ihren Cluster an:
kubectl apply -f httproute.yaml
Inferenzziele angeben
Mit der benutzerdefinierten Ressource InferenceObjective können Sie die Priorität von Anfragen angeben.
Das Feld metadata.name der Ressource InferenceObjective gibt den Namen des Inferenzziels an, das Feld Priority die Kritikalität der Bereitstellung und das Feld poolRef den Inferenzpool, in dem das Modell bereitgestellt wird.
apiVersion: inference.networking.x-k8s.io/v1alpha2
kind: InferenceObjective
metadata:
name: NAME
spec:
priority: VALUE
poolRef:
name: INFERENCE_POOL_NAME
group: "inference.networking.k8s.io"
Ersetzen Sie Folgendes:
NAME: der Name Ihres Inferenzziels. Beispiel:food-review.VALUE: die Priorität für das Inferenzziel. Dies ist eine Ganzzahl, wobei ein höherer Wert auf eine kritischere Anfrage hinweist. Beispiel: 10.INFERENCE_POOL_NAME: Der Name des InferencePool, den Sie im vorherigen Schritt erstellt haben. Beispiel:vllm-llama3-8b-instruct
So erstellen Sie ein InferenceObjective:
Speichern Sie das folgende Manifest als
inference-objectives.yaml. Mit diesem Manifest werden zweiInferenceObjective-Ressourcen erstellt. Die erste konfiguriert das Inferenzzielfood-reviewim InferencePoolvllm-llama3-8b-instructmit der Priorität 10. Die zweite konfiguriert das Inferenzzielllama3-base-modelso, dass es mit einer höheren Priorität von 20 bereitgestellt wird.apiVersion: inference.networking.x-k8s.io/v1alpha2 kind: InferenceObjective metadata: name: food-review spec: priority: 10 poolRef: name: vllm-llama3-8b-instruct group: "inference.networking.k8s.io" --- apiVersion: inference.networking.x-k8s.io/v1alpha2 kind: InferenceObjective metadata: name: llama3-base-model spec: priority: 20 # Higher priority poolRef: name: vllm-llama3-8b-instructWenden Sie das Beispielmanifest auf Ihren Cluster an:
kubectl apply -f inference-objectives.yaml
Deployment prüfen
Führen Sie die folgenden Befehle aus, um zu prüfen, ob alle Komponenten ausgeführt werden:
kubectl get inferencepool
kubectl get inferenceobjective
kubectl get pods -l app=vllm-llama3-8b-instruct-epp
Inferenzanfrage senden
Nachdem Sie das GKE Inference Gateway konfiguriert haben, können Sie Inferenzanfragen an Ihr bereitgestelltes Modell senden. So können Sie Text basierend auf Ihrem Eingabe-Prompt und den angegebenen Parametern generieren.
Führen Sie die folgenden Schritte aus, um Inferenzanfragen zu senden:
Legen Sie die folgenden Umgebungsvariablen fest:
export GATEWAY_NAME=GATEWAY_NAME export PORT_NUMBER=PORT_NUMBER # Use 80 for HTTPErsetzen Sie Folgendes:
GATEWAY_NAME: der Name Ihrer Gateway-Ressource.PORT_NUMBER: die Portnummer, die Sie im Gateway konfiguriert haben.
Führen Sie den folgenden Befehl aus, um den Gateway-Endpunkt abzurufen:
echo "Waiting for the Gateway IP address..." IP="" while [ -z "$IP" ]; do IP=$(kubectl get gateway/${GATEWAY_NAME} -o jsonpath='{.status.addresses[0].value}' 2>/dev/null) if [ -z "$IP" ]; then echo "Gateway IP not found, waiting 5 seconds..." sleep 5 fi done echo "Gateway IP address is: $IP" PORT=${PORT_NUMBER}Führen Sie den folgenden Befehl aus, um mit
curleine Anfrage an den Endpunkt/v1/completionszu senden:curl -i -X POST ${IP}:${PORT}/v1/completions \ -H 'Content-Type: application/json' \ -H 'Authorization: Bearer $(gcloud auth application-default print-access-token)' \ -d '{ "model": "MODEL_NAME", "prompt": "PROMPT_TEXT", "max_tokens": MAX_TOKENS, "temperature": "TEMPERATURE" }'Ersetzen Sie Folgendes:
MODEL_NAME: der Name des Modells oder LoRA-Adapters, der verwendet werden soll.PROMPT_TEXT: der Eingabe-Prompt für das Modell.MAX_TOKENS: die maximale Anzahl von Tokens, die in der Antwort generiert werden sollen.TEMPERATURE: Steuert die Zufälligkeit der Ausgabe. Verwenden Sie den Wert0für eine deterministische Ausgabe oder eine höhere Zahl für eine kreativere Ausgabe.
Im folgenden Beispiel wird gezeigt, wie Sie eine Beispielanfrage an das GKE Inference Gateway senden:
curl -i -X POST ${IP}:${PORT}/v1/completions -H 'Content-Type: application/json' -H 'Authorization: Bearer $(gcloud auth application-default print-access-token)' -d '{
"model": "food-review-1",
"prompt": "What is the best pizza in the world?",
"max_tokens": 2048,
"temperature": 0
}'
Beachten Sie Folgendes:
- Anfragetext: Der Anfragetext kann zusätzliche Parameter wie
stopundtop_penthalten. Eine vollständige Liste der Optionen finden Sie in der OpenAI API-Spezifikation. - Fehlerbehandlung: Implementieren Sie eine ordnungsgemäße Fehlerbehandlung in Ihrem Clientcode, um potenzielle Fehler in der Antwort zu beheben. Prüfen Sie beispielsweise den HTTP-Statuscode in der
curl-Antwort. Ein Statuscode, der nicht200ist, weist im Allgemeinen auf einen Fehler hin. - Authentifizierung und Autorisierung: Sichern Sie Ihren API-Endpunkt für Produktionsbereitstellungen mit Authentifizierungs- und Autorisierungsmechanismen. Fügen Sie die entsprechenden Header (z. B.
Authorization) in Ihre Anfragen ein.
Kompatibilitätsmatrix
In der Tabelle finden Sie die Kompatibilitäts- und Supportmatrix für die benutzerdefinierten Ressourcendefinitionen (CRDs) der Gateway API Inference Extension. Es wird beschrieben, welche CustomResourceDefinition-Versionen von GKE im Vergleich zum Open-Source-Projekt (OSS) der Gateway API Inference Extension unterstützt werden, einschließlich spezifischer Versionsanforderungen und Installationshinweise.
| CustomResourceDefinition-Name | CustomResourceDefinition-API-Version | Von GKE verwalteter Support | OSS-Unterstützung (Gateway API Inference Extension) |
|---|---|---|---|
| V1 InferencePool | inference.networking.k8s.io/v1 | Unterstützt ab GKE 1.32.3 und CustomResourceDefinition standardmäßig ab GKE 1.34.0-gke.1626000 installiert | Unterstützt ab Gateway API Inference Extension v1.0.0 |
| Alpha InferencePool (Wir empfehlen Nutzern, mit v1 InferencePool zu beginnen, da die Alpha-InferencePool-Version eingestellt wurde) | inference.networking.x-k8s.io/v1alpha2 | Unterstützt ab GKE 1.32.3. CustomResourceDefinition wird jedoch nicht standardmäßig in GKE installiert. Nutzer müssen die CustomResourceDefinition aus der Gateway API Inference Extension manuell installieren. | Unterstützt ab Gateway API Inference Extension v0.2.0 |
| Alpha InferenceObjective | inference.networking.x-k8s.io/v1alpha2 | InferenceObjective wird nicht von der GKE verwaltet | Unterstützt ab Gateway API Inference Extension v1.0.0 |
| Alpha InferenceModel (InferenceObjective wird empfohlen, da InferenceModel eingestellt wurde) | inference.networking.x-k8s.io/v1alpha2 | GKE verwaltet „InferenceModel“ nicht | Wird ab Gateway API Inference Extension v0.2.0 unterstützt. |
Inferenz-Backend mit Backend-TLS sichern
Mit Backend-TLS kann der GKE-Gateway-Load-Balancer die Identität der Inferenz-Backends überprüfen, mit denen er eine Verbindung herstellt. Backend-TLS fügt während des TLS-Handshakes zwischen dem Gateway und dem Backend-Pod einen expliziten Bestätigungsschritt hinzu. Diese Überprüfung trägt dazu bei, dass das Gateway nur mit vertrauenswürdigen Modell-Servern und Endpoint Picker-Erweiterungen kommuniziert.
Wenn Sie Backend-TLS für Ihre Inferenzarbeitslasten konfigurieren möchten, hängen Sie eine BackendTLSPolicy an eine InferencePool- oder GCPInferencePoolImport-Ressource an. Wenn Sie das Gateway so konfigurieren möchten, dass es das Endpoint Picker-Zertifikat verifizieren kann, hängen Sie eine BackendTLSPolicy an den Endpoint Picker-Dienst an, auf den im Feld spec.endpointPickerRef des InferencePool verwiesen wird.
Weitere Informationen finden Sie unter Backend-TLS konfigurieren.
Nächste Schritte
- GKE Inference Gateway-Konfiguration anpassen
- Textkörperbasiertes Routing konfigurieren
- LLM mit GKE Inference Gateway bereitstellen
- Vorhergesagtes latenzbasiertes Routing mit GKE Inference Gateway verwenden