Questo documento descrive come eseguire il deployment di GKE Inference Gateway.
Questo documento è rivolto agli specialisti di networking responsabili della gestione dell'infrastruttura GKE e agli amministratori della piattaforma che gestiscono i workload AI.
Prima di leggere questa pagina, assicurati di avere familiarità con quanto segue:
- Informazioni su GKE Inference Gateway.
- Orchestrazione di AI/ML su GKE.
- Glossario sull'AI generativa.
- Bilanciamento del carico inCloud de Confiance, in particolare il modo in cui i bilanciatori del carico interagiscono con GKE.
- Estensioni dei servizi GKE. Per saperne di più, consulta la documentazione del controller GKE Gateway.
- Personalizza il traffico del gateway GKE utilizzando Service Extensions.
GKE Inference Gateway migliora il gateway Google Kubernetes Engine (GKE) per ottimizzare la distribuzione di applicazioni e workload di AI generativa su GKE. Fornisce una gestione e una scalabilità efficienti dei workload AI, consente di raggiungere obiettivi di rendimento specifici per i workload, come la latenza, e migliora l'utilizzo delle risorse, l'osservabilità e la sicurezza dell'AI.
Prima di iniziare
Prima di iniziare, assicurati di aver eseguito le seguenti attività:
- Abilita l'API Google Kubernetes Engine. Abilita l'API Google Kubernetes Engine
- Per utilizzare Google Cloud CLI per questa attività,
installala e poi
inizializza
gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima
versione eseguendo il comando
gcloud components update. Le versioni precedenti di gcloud CLI potrebbero non supportare l'esecuzione dei comandi in questo documento.
Abilita l'API Compute Engine, l'API Kubernetes Engine, l'API Network Services e l'API Model Armor, se necessario.
Vai ad Abilita l'accesso alle API e segui le istruzioni.
Assicurati di disporre dei seguenti ruoli nel progetto:
roles/container.admin,roles/iam.serviceAccountAdmin.Assicurati che il tuo progetto disponga di una quota sufficiente per le GPU H100. Per saperne di più, consulta Pianifica la quota di GPU e Quote di allocazione.
Crea un account Hugging Face se non ne hai già uno. Ti servirà per accedere alle risorse del modello per questo tutorial.
Richiedi l'accesso al modello Llama 3.1 e genera un token di accesso. L'accesso a questo modello richiede una richiesta di approvazione su Hugging Face e il deployment non andrà a buon fine se l'accesso non è stato concesso.
- Firma il contratto di consenso alla licenza: devi firmare il contratto di consenso per utilizzare il modello Llama 3.1. Vai alla pagina del modello su Hugging Face, verifica il tuo account e accetta i termini.
- Genera un token di accesso: per accedere al modello, devi avere un token Hugging Face. Nel tuo account Hugging Face, vai a Il tuo profilo > Impostazioni > Token di accesso, crea un nuovo token con almeno le autorizzazioni in lettura e copialo negli appunti.
Configura una subnet solo proxy per la tua rete VPC. Il controller Gateway richiede una subnet solo proxy attiva nella regione per eseguire il provisioning del bilanciatore del carico delle applicazioni.
Requisiti del GKE Gateway Controller
- GKE versione 1.32.3 o successive.
- Google Cloud CLI versione 407.0.0 o successive.
- L'API Gateway è supportata solo sui cluster nativi di VPC.
- Il cluster deve avere il componente aggiuntivo
HttpLoadBalancingabilitato. - Se utilizzi Istio, devi eseguire l'upgrade a una delle seguenti versioni:
- 1.15.2 o versioni successive
- 1.14.5 o versioni successive
- 1.13.9 o versioni successive
- Se utilizzi un VPC condiviso, nel progetto host devi assegnare il ruolo
Compute Network Useral service account GKE per il progetto di servizio.
Restrizioni e limitazioni
Si applicano le seguenti limitazioni:
- GKE Inference Gateway è supportato solo sulle risorse GatewayClass
gke-l7-regional-external-managedegke-l7-rilb. - I bilanciatori del carico delle applicazioni interni tra regioni non sono supportati.
- Un InferencePool può avere un massimo di otto
targetPorts.
Configura GKE Inference Gateway
Per configurare GKE Inference Gateway, considera questo esempio. Un team esegue i modelli vLLM e Llama3 e sperimenta attivamente con due adattatori distinti ottimizzati con LoRA: "food-review" e "cad-fabricator".
Il workflow di alto livello per la configurazione di GKE Inference Gateway è il seguente:
- Prepara l'ambiente: configura l'infrastruttura e i componenti necessari.
- Crea un pool di inferenza: definisci un pool di server di modelli utilizzando la risorsa personalizzata InferencePool.
- Specifica gli obiettivi di inferenza: specifica gli obiettivi di inferenza utilizzando la risorsa personalizzata
InferenceObjective - Crea il gateway: esponi il servizio di inferenza utilizzando l'API Gateway.
- Crea
HTTPRoute: definisci il modo in cui il traffico HTTP viene indirizzato al servizio di inferenza. - Invia richieste di inferenza: effettua richieste al modello di cui è stato eseguito il deployment.
Crea il gateway
La risorsa Gateway è il punto di ingresso del traffico esterno nel tuo cluster Kubernetes. Definisce i listener che accettano le connessioni in entrata.
GKE Inference Gateway funziona con le seguenti classi di gateway:
gke-l7-rilb: per i bilanciatori del carico delle applicazioni interni regionali.gke-l7-regional-external-managed: per i bilanciatori del carico delle applicazioni esterni regionali.
Per saperne di più, consulta la documentazione relativa alle classi di gateway.
Per creare un gateway, segui questi passaggi:
Salva il seguente manifest di esempio come
gateway.yaml:apiVersion: gateway.networking.k8s.io/v1 kind: Gateway metadata: name: GATEWAY_NAME spec: gatewayClassName: GATEWAY_CLASS listeners: - protocol: HTTP port: 80 name: httpSostituisci quanto segue:
GATEWAY_NAME: un nome univoco per la risorsa Gateway. Ad esempio,inference-gateway.GATEWAY_CLASS: la classe gateway che vuoi utilizzare. Ad esempio,gke-l7-regional-external-managed.
Applica il manifest al tuo cluster:
kubectl apply -f gateway.yaml
Nota: Per ulteriori informazioni sulla configurazione di TLS per proteggere il Gateway con HTTPS, consultare la documentazione GKE sulla configurazione TLS.
prepara l'ambiente
Installa Helm.
Crea un cluster GKE:
- Crea un cluster GKE Autopilot o Standard con la versione 1.32.3 o successive. Per una configurazione di riferimento del deployment con un solo clic, consulta l'esempio
cluster-toolkit gke-a3-highgpu. - Configura i nodi con la famiglia di computing e l'acceleratore che preferisci.
- Utilizza la guida rapida all'inferenza di GKE per i manifest di deployment preconfigurati e testati, in base all'acceleratore, al modello e alle esigenze di prestazioni selezionati.
- Crea un cluster GKE Autopilot o Standard con la versione 1.32.3 o successive. Per una configurazione di riferimento del deployment con un solo clic, consulta l'esempio
Installa le definizioni di risorse personalizzate (CRD) necessarie nel tuo cluster GKE:
Per le versioni GKE
1.34.0-gke.1626000o successive, la CRDInferencePoolè inclusa per impostazione predefinita. Pertanto, installa solo la CRD alphaInferenceObjective: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.yamlPer le versioni di GKE precedenti alla
1.34.0-gke.1626000, installa sia le CRD InferencePool v1 sia le CRDInferenceObjectivealpha:kubectl apply -f https://github.com/kubernetes-sigs/gateway-api-inference-extension/releases/download/v1.5.0/manifests.yamlPer saperne di più, consulta la matrice di compatibilità.
Se utilizzi una versione di GKE precedente alla
v1.32.2-gke.1182001e vuoi utilizzare Model Armor con il gateway di inferenza GKE, devi installare le CRD dell'estensione di traffico e routing: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.yamlImposta le seguenti variabili di ambiente:
export GAIE_VERSION=v1.5.0 export GUIDE_NAME="optimized-baseline" export NAMESPACE=llm-d-optimized-baseline export INFRA_PROVIDER=gke # gke | baseInstalla le definizioni di risorse personalizzate (CRD) dell'estensione di inferenza dell'API Gateway richieste dal selettore di endpoint (EPP) llm-d:
kubectl apply -k \ "https://github.com/kubernetes-sigs/gateway-api-inference-extension/config/crd?ref=${GAIE_VERSION}"Crea lo spazio dei nomi di destinazione:
kubectl create namespace ${NAMESPACE}
Crea un server di modelli e un deployment di modelli
Questa sezione mostra come eseguire il deployment di un server di modelli e di un modello. L'esempio utilizza un server di modelli vLLM con un modello Llama3. Il deployment è etichettato come app:vllm-llama3-8b-instruct. Questo deployment utilizza anche due adattatori LoRA denominati food-review e cad-fabricator di Hugging Face.
Puoi adattare questo esempio con il tuo container del server di modelli e il tuo modello, la tua porta di distribuzione e il tuo nome del deployment. Puoi anche configurare gli adattatori LoRA nel deployment o eseguire il deployment del modello di base. I passaggi seguenti descrivono come creare le risorse Kubernetes necessarie.
Crea un secret di Kubernetes per archiviare il token Hugging Face. Questo token viene utilizzato per accedere al modello di base e agli adattatori LoRA:
kubectl create secret generic hf-token --from-literal=token=HF_TOKENSostituisci
HF_TOKENcon il tuo token Hugging Face.Esegui il deployment del server di modelli vLLM utilizzando l'overlay Kustomize specifico per GKE dalla guida alla baseline ottimizzata di llm-d. L'impostazione
INFRA_PROVIDER=gkeapplica configurazioni specifiche di GKE, inclusa l'integrazione di Cloud Monitoring:kubectl apply -n ${NAMESPACE} \ -k guides/${GUIDE_NAME}/modelserver/gpu/vllm/${INFRA_PROVIDER}/
Nota: GKE fornisce il monitoraggio automatico delle applicazioni per impostazione predefinita. Lo stack di monitoraggio llm-d non è obbligatorio per GKE, ma è disponibile se preferisci utilizzarlo.
Se il server di modelli richiede più porte, assicurati che la specifica del container esponga ogni porta. L'esempio seguente definisce un deployment in cui il container espone tre porte:
Esempio di deployment multiporta
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
Crea un pool di inferenza
La risorsa personalizzata Kubernetes InferencePool definisce un gruppo di pod con un modello linguistico di grandi dimensioni (LLM) di base e una configurazione di computing comuni. Il campo selector specifica i pod che appartengono a questo pool. Le etichette in questo selettore devono corrispondere esattamente alle etichette applicate ai pod del server di modelli. Il campo targetPorts definisce le porte utilizzate dal server di modelli all'interno dei pod. Puoi specificare fino a otto porte. Il campo extensionRef fa riferimento a un servizio di estensione che fornisce funzionalità aggiuntive per il pool di inferenza. InferencePool consente a GKE Inference Gateway di instradare il traffico ai pod del server di modelli.
Il seguente manifest InferencePool specifica più targetPort che corrispondono alle porte esposte dal deployment del server di modelli:
Esempio di InferencePool multiporta
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
Prima di creare l'InferencePool, assicurati che i pod del server di modelli selezionati dall'InferencePool siano già in esecuzione.
Clona le ricette e i suggerimenti per InferencePool dal repository GitHub llm-d. Questo passaggio è obbligatorio:
git clone https://github.com/llm-d/llm-d -b v0.7.0 && cd llm-d
Per creare un InferencePool e un selettore di endpoint utilizzando Helm, segui questi passaggi:
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
Sostituisci quanto segue:
GAIE_VERSION: la versione del chart Helm. Ad esempio,v1.5.0.LLM_D_REGISTRY_PATH: il percorso del registry OCI per il chart Helm. Ad esempio,registry.k8s.io/gateway-api-inference-extension/charts/inferencepool.
Nel file guides/recipes/scheduler/base.values.yaml, modifica il seguente campo in modo che corrisponda all'etichetta del pod di deployment del modello:
inferencePool.modelServers.matchLabels: la chiave e il valore dell'etichetta utilizzati per selezionare i pod del server di modelli.Nota: la chiave e il valore sono in linea con l'esempio della guida di
optimized-baseline, quindi li sostituiamo in modo che corrispondano alle etichette del pod di deployment.
Per il monitoraggio, lo scraping delle metriche per Google Cloud Managed Service per Prometheus è abilitato per impostazione predefinita.
- Per disattivare questa funzionalità, aggiungi il flag
--set inferenceExtension.monitoring.prometheus.enabled=falseal comando. - Se utilizzi il monitoraggio predefinito su un cluster GKE Autopilot, devi aggiungere anche il flag
--set provider.gke.autopilot=true.
L'installazione di Helm installa automaticamente la policy di timeout necessaria, il selettore di endpoint e i pod necessari per l'osservabilità.
Viene creato un oggetto InferencePool: vllm-llama3-8b-instruct che fa riferimento ai servizi degli endpoint del modello all'interno dei pod. Crea anche un deployment del selettore di endpoint denominato app:vllm-llama3-8b-instruct-epp per questo InferencePool creato.
Esegui il deployment di Endpoint Picker con alta affidabilità
Il deployment di Endpoint Picker (EPP) con backend preferiti consente una topologia di routing attivo-passivo supportata da Cloud Load Balancing.
L'utilizzo del selettore di endpoint con i backend preferiti ti aiuta a ottenere quanto segue:
- Coerenza dello stato: Cloud Load Balancing indirizza il 100% del traffico
ext_procin stato stabile alla replica principale del selettore di endpoint (epp-0), preservando lo stato della cache coppia chiave-valore (KV) e il contesto di pianificazione delle richieste. - Failover senza tempi di inattività: se il pod Endpoint Picker principale si arresta in modo anomalo o viene sottoposto a manutenzione, Cloud Load Balancing rileva l'errore utilizzando i controlli di integrità gRPC attivi e instrada immediatamente il traffico alla replica in standby (
epp-1). - Resilienza fail-open: se abbinato a
failureMode: FailOpen, gli errori di routing temporanei bypassano il selettore di endpoint e consentono di inoltrare le richieste direttamente ai server di modelli senza ignorare le richieste degli utenti.
Quando attivi i backend preferiti, GKE modifica l'architettura e il routing nei seguenti modi:
- Architettura StatefulSet del selettore di endpoint: il selettore di endpoint viene distribuito come StatefulSet anziché come deployment. I numeri ordinali dei pod designano i ruoli delle repliche: il numero ordinale
epp-0funge da replica principale assegnata al livello di backendPREFERRED, mentre il numero ordinaleepp-1funge da replica in standby assegnata al livelloDEFAULT. - Lo stato del routing rimane centralizzato: il traffico
ext_procin stato stabile viene instradato esclusivamente alla replica principale del selettore di endpoint (epp-0) per mantenere centralizzati il monitoraggio della cache coppia chiave-valore (KV) e lo stato della pianificazione delle richieste. Seepp-0diventa non integro, Cloud Load Balancing sposta il traffico alla replica in standby (epp-1). - Architettura a doppio servizio: il grafico Helm crea un servizio principale (
Service/${GUIDE_NAME}-epp) e un servizio di backup in standby (Service/${GUIDE_NAME}-epp-backup). La risorsaInferencePoolha come target in modo dichiarativo il servizio di backup in standby. L'ancoraggio della proprietà dichiarativa del gateway al servizio di standby garantisce che i loop di riconciliazione del controller GKE Gateway non scolleghino i gruppi di endpoint di rete (NEG) principali che colleghi al servizio di backend.
Per creare un InferencePool e un selettore di endpoint con alta affidabilità utilizzando Helm, segui questi passaggi:
Esegui il deployment di InferencePool e del selettore di endpoint con i backend preferiti utilizzando 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 \ --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_PATHSostituisci quanto segue:
GAIE_VERSION: la versione dell'estensione di inferenza dell'API Gateway (GAIE) del chart Helm. Ad esempio,v1.5.0. I backend preferiti richiedono la versionev1.5.0o successiva del grafico Helm.LLM_D_REGISTRY_PATH: il percorso del registry OCI per il chart Helm. Ad esempio,registry.k8s.io/gateway-api-inference-extension/charts/inferencepool.
Per un elenco completo dei parametri, consulta
values.yaml.Collega il NEG principale a
BackendService: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 doneSostituisci quanto segue:
PROJECT_ID: il tuo ID progetto Cloud de Confiance by S3NS .REGION: la regione Cloud de Confiance del tuo cluster e del tuo servizio di backend.
Dopo aver collegato i NEG di zona al Cloud de Confiance by S3NS BackendService, la scalabilità
del numero di repliche (preferredReplicas o defaultReplicas) o il riavvio dei pod
non richiede di eseguire nuovamente i comandi gcloud. Il controller NEG di GKE sincronizza automaticamente i singoli indirizzi IP dei pod nei NEG a livello di zona registrati.
Se elimini e ricrei la risorsa Gateway o InferencePool principale,
il GKE Gateway Controller ricrea Cloud de Confiance by S3NS
BackendService sottostante con un nuovo identificatore cloud. In questo caso, esegui il workflow di collegamento precedente per collegare i NEG di zona principali al BackendService appena creato.
Crea il HTTPRoute
La risorsa HTTPRoute definisce il modo in cui il gateway GKE instrada le richieste HTTP in entrata ai servizi di backend, come InferencePool. La risorsa HTTPRoute specifica le regole di corrispondenza (ad esempio intestazioni o percorsi) e il backend a cui deve essere inoltrato il traffico.
Per creare un
HTTPRoute, salva il seguente manifest di esempio comehttproute.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: InferencePoolSostituisci quanto segue:
HTTPROUTE_NAME: un nome univoco per la risorsaHTTPRoute. Ad esempio:my-route.GATEWAY_NAME: il nome della risorsaGatewayche hai creato. Ad esempio:inference-gateway.PATH_PREFIX: il prefisso del percorso utilizzato per trovare corrispondenze con le richieste in entrata. Ad esempio,/per trovare tutte le corrispondenze.INFERENCE_POOL_NAME: il nome della risorsa InferencePool a cui vuoi instradare il traffico. Ad esempio,vllm-llama3-8b-instruct.
Applica il manifest al tuo cluster:
kubectl apply -f httproute.yaml
Specifica gli obiettivi di inferenza
La risorsa personalizzata InferenceObjective consente di specificare la priorità delle richieste.
Il campo metadata.name della risorsa InferenceObjective specifica il nome dell'obiettivo di inferenza, il campo Priority specifica la criticità di gestione e il campo poolRef specifica l'InferencePool su cui viene gestito il modello.
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"
Sostituisci quanto segue:
NAME: il nome dell'obiettivo di inferenza. Ad esempio,food-review.VALUE: la priorità dell'obiettivo di inferenza. Si tratta di un numero intero in cui un valore più elevato indica una richiesta più critica. Ad esempio: 10.INFERENCE_POOL_NAME: il nome dell'InferencePool che hai creato nel passaggio precedente. Ad esempio,vllm-llama3-8b-instruct.
Per creare un InferenceObjective, segui questi passaggi:
Salva il seguente manifest come
inference-objectives.yaml. Questo manifest crea due risorseInferenceObjective. La prima configura l'obiettivo di inferenzafood-reviewsuvllm-llama3-8b-instructInferencePool con una priorità pari a 10. La seconda configura l'obiettivo di inferenzallama3-base-modelin modo che venga pubblicato con una priorità più alta, pari a 20.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-instructApplica il manifest di esempio al tuo cluster:
kubectl apply -f inference-objectives.yaml
Verifica il deployment
Per verificare che tutti i componenti siano in esecuzione, esegui questi comandi:
kubectl get inferencepool
kubectl get inferenceobjective
kubectl get pods -l app=vllm-llama3-8b-instruct-epp
Invia richiesta di inferenza
Dopo aver configurato GKE Inference Gateway, puoi inviare richieste di inferenza al modello di cui hai eseguito il deployment. In questo modo puoi generare testo in base al prompt di input e ai parametri specificati.
Per inviare richieste di inferenza, segui questi passaggi:
Imposta le seguenti variabili di ambiente:
export GATEWAY_NAME=GATEWAY_NAME export PORT_NUMBER=PORT_NUMBER # Use 80 for HTTPSostituisci quanto segue:
GATEWAY_NAME: il nome della risorsa Gateway.PORT_NUMBER: il numero di porta configurato nel gateway.
Per ottenere l'endpoint del gateway, esegui questo comando:
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}Per inviare una richiesta all'endpoint
/v1/completionsutilizzandocurl, esegui il seguente comando: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" }'Sostituisci quanto segue:
MODEL_NAME: il nome del modello o dell'adattatore LoRA da utilizzare.PROMPT_TEXT: il prompt di input per il modello.MAX_TOKENS: il numero massimo di token da generare nella risposta.TEMPERATURE: controlla la casualità dell'output. Utilizza il valore0per un output deterministico o un numero più alto per un output più creativo.
L'esempio seguente mostra come inviare una richiesta di esempio a GKE Inference Gateway:
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
}'
Tieni presente i seguenti comportamenti:
- Corpo della richiesta: il corpo della richiesta può includere parametri aggiuntivi come
stopetop_p. Per un elenco completo delle opzioni, consulta la specifica dell'API OpenAI. - Gestione degli errori: implementa una gestione degli errori adeguata nel codice client per gestire potenziali errori nella risposta. Ad esempio, controlla il codice di stato HTTP nella risposta
curl. Un codice di stato diverso da200indica in genere un errore. - Autenticazione e autorizzazione: per i deployment di produzione, proteggi l'endpoint API con meccanismi di autenticazione e autorizzazione. Includi le intestazioni appropriate (ad esempio
Authorization) nelle tue richieste.
Matrice di compatibilità
La tabella illustra la matrice di compatibilità e supporto per le definizioni di risorse personalizzate (CRD) dell'estensione di inferenza dell'API Gateway. Descrive in dettaglio le versioni di CustomResourceDefinition supportate da GKE rispetto al progetto open source (OSS) Gateway API Inference Extension, inclusi i requisiti di versione specifici e le note di installazione.
| Nome CustomResourceDefinition | Versione API CustomResourceDefinition | Assistenza gestita di GKE | Supporto OSS (Gateway API Inference Extension) |
|---|---|---|---|
| V1 InferencePool | inference.networking.k8s.io/v1 | Supportato su GKE 1.32.3 o versioni successive e CustomResourceDefinition installato per impostazione predefinita su GKE 1.34.0-gke.1626000 o versioni successive | Supportato a partire dalla versione 1.0.0 dell'estensione di inferenza dell'API Gateway |
| InferencePool alpha (consigliamo agli utenti di iniziare con la versione v1 di InferencePool, poiché la versione alpha di InferencePool è stata ritirata) | inference.networking.x-k8s.io/v1alpha2 | Supportato su GKE 1.32.3 o versioni successive. Tuttavia, CustomResourceDefinition non è installato per impostazione predefinita su GKE. Gli utenti devono installare manualmente la CustomResourceDefinition dall'estensione di inferenza dell'API Gateway. | Supportato a partire dalla versione 0.2.0 dell'estensione di inferenza dell'API Gateway |
| Alpha InferenceObjective | inference.networking.x-k8s.io/v1alpha2 | GKE non gestisce InferenceObjective | Supportato a partire dalla versione 1.0.0 dell'estensione di inferenza dell'API Gateway |
| Alpha InferenceModel (consigliamo agli utenti di iniziare con InferenceObjective, poiché InferenceModel è stato ritirato) | inference.networking.x-k8s.io/v1alpha2 | GKE non gestisce InferenceModel | Supportato a partire dalla versione 0.2.0 dell'estensione di inferenza dell'API Gateway. |
Proteggi il backend di inferenza con TLS del backend
TLS di backend consente al bilanciatore del carico del gateway GKE di verificare l'identità dei backend di inferenza a cui si connette. Il TLS del backend aggiunge un passaggio di verifica esplicito durante il TLS handshake tra il gateway e il pod del backend. Questa verifica contribuisce a garantire che il gateway comunichi solo con server di modelli e con estensioni Endpoint Picker attendibili.
Per configurare TLS di backend per i workload di inferenza, collega una risorsa BackendTLSPolicy a una risorsa InferencePool o GCPInferencePoolImport. Per configurare il gateway in modo che possa verificare il certificato del selettore di endpoint, collega un criterio BackendTLSPolicy al servizio del selettore di endpoint a cui fa riferimento il campo spec.endpointPickerRef di InferencePool.
Per saperne di più, consulta Configura TLS di backend.
Passaggi successivi
- Personalizza la configurazione di GKE Inference Gateway
- Configura il routing basato sul corpo
- Pubblica un LLM con GKE Inference Gateway
- Utilizza il routing basato sulla latenza prevista con GKE Inference Gateway