Esegui il deployment di GKE Inference Gateway

Questa pagina descrive come eseguire il deployment di GKE Inference Gateway.

Questa pagina è destinata agli specialisti di networking responsabili della gestione dell'infrastruttura GKE e agli amministratori della piattaforma che gestiscono i carichi di lavoro 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 dell'AI generativa.
• Bilanciamento del carico in Trusted Cloud, in particolare come i bilanciatori del carico interagiscono con GKE.
• Service Extensions di GKE. Per saperne di più, leggi la documentazione relativa al controller GKE Gateway.
• Personalizza il traffico del gateway GKE utilizzando le estensioni di servizio.

GKE Inference Gateway migliora GKE (Google Kubernetes Engine) Gateway per ottimizzare la pubblicazione di applicazioni e workload di AI generativa su GKE. Fornisce una gestione e uno scaling efficienti dei carichi di lavoro di AI, consente obiettivi di prestazioni specifici per il carico di lavoro, 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 operazioni:

• Attiva l'API Google Kubernetes Engine.
Attiva l'API Google Kubernetes Engine
• Se vuoi utilizzare Google Cloud CLI per questa attività, installala e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo gcloud components update.

• Se necessario, abilita l'API Compute Engine, l'API Network Services e l'API Model Armor.

  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 Pianificare 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 approvata 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 disporre di un token Hugging Face. Nel tuo account Hugging Face, vai a Il tuo profilo > Impostazioni > Token di accesso, crea un nuovo token con almeno autorizzazioni di lettura e copialo negli appunti.

Requisiti del controller GKE Gateway

• GKE 1.32.3 o versioni successive.
• Google Cloud CLI versione 407.0.0 o successive.
• L'API Gateway è supportata solo sui cluster VPC nativi.
• Devi abilitare una subnet solo proxy.
• Il cluster deve avere il componente aggiuntivo HttpLoadBalancing abilitato.
• 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 il VPC condiviso, nel progetto host devi assegnare il ruolo Compute Network User al service account GKE per il progetto di servizio.

Limitazioni e restrizioni

Si applicano le seguenti limitazioni:

• I gateway multicluster non sono supportati.
• GKE Inference Gateway è supportato solo sulle risorse GatewayClass gke-l7-regional-external-managed e gke-l7-rilb.
• I bilanciatori del carico delle applicazioni interni tra regioni non sono supportati.

Matrice di compatibilità

La tabella descrive la matrice di compatibilità e supporto per le definizioni di risorse personalizzate (CRD) dell'estensione di inferenza dell'API Gateway. Specifica le versioni CRD supportate da GKE rispetto al progetto di estensione dell'inferenza dell'API Gateway open source (OSS), inclusi requisiti di versione specifici e note di installazione.

Configura GKE Inference Gateway

Per configurare GKE Inference Gateway, considera questo esempio. Un team esegue i modelli vLLM e Llama3 e sperimenta attivamente due diversi adattatori LoRA ottimizzati: "food-review" e "cad-fabricator".

Il flusso di lavoro di alto livello per la configurazione di GKE Inference Gateway è il seguente:

1. Prepara l'ambiente: configura l'infrastruttura e i componenti necessari.
2. Crea un pool di inferenza: definisci un pool di server di modelli utilizzando la risorsa personalizzata InferencePool.
3. Specifica gli obiettivi di inferenza: specifica gli obiettivi di inferenza utilizzando la risorsa personalizzata InferenceObjective
4. Crea il gateway: esponi il servizio di inferenza utilizzando l'API Gateway.
5. Crea HTTPRoute: definisci come viene instradato il traffico HTTP al servizio di inferenza.
6. Invia richieste di inferenza: invia richieste al modello di cui è stato eseguito il deployment.

prepara l'ambiente

1. Installa Helm.

2. Crea un cluster GKE:

   • Crea un cluster GKE Autopilot o Standard con la versione 1.32.3 o successive. Per istruzioni, vedi Creare un cluster GKE.
   • Configura i nodi con la famiglia di computing e l'acceleratore che preferisci.
   • Utilizza la guida rapida all'inferenza di GKE per manifest di deployment preconfigurati e testati, in base all'acceleratore, al modello e alle esigenze di prestazioni selezionati.

3. Installa la definizione di risorsa personalizzata (CRD) necessaria nel tuo cluster GKE:

   • Per le versioni di GKE precedenti alla 1.34.0-gke.1626000, esegui il comando seguente per installare sia le CRD v1 InferencePool sia le CRD alpha InferenceObjective:

   kubectl apply -f  https://github.com/kubernetes-sigs/gateway-api-inference-extension/releases/download/v1.0.0/experimental-manifests.yaml
   

   • Per le versioni di GKE 1.34.0-gke.1626000 o successive, installa solo la CRD alpha InferenceObjective eseguendo il seguente comando:

   kubectl apply -f https://github.com/kubernetes-sigs/gateway-api-inference-extension/raw/v1.0.0/config/crd/bases/inference.networking.x-k8s.io_inferenceobjectives.yaml
   

4. Se utilizzi una versione di GKE precedente alla v1.32.2-gke.1182001 e vuoi utilizzare Model Armor con GKE Inference Gateway, devi installare i CRD dell'estensione di gestione del traffico e del 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.yaml
   

5. Per configurare l'autorizzazione per eseguire lo scraping delle metriche, crea il secret inference-gateway-sa-metrics-reader-secret:

   kubectl apply -f - <<EOF
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRole
   metadata:
     name: inference-gateway-metrics-reader
   rules:
   - nonResourceURLs:
     - /metrics
     verbs:
     - get
   ---
   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: inference-gateway-sa-metrics-reader
     namespace: default
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: inference-gateway-sa-metrics-reader-role-binding
     namespace: default
   subjects:
   - kind: ServiceAccount
     name: inference-gateway-sa-metrics-reader
     namespace: default
   roleRef:
     kind: ClusterRole
     name: inference-gateway-metrics-reader
     apiGroup: rbac.authorization.k8s.io
   ---
   apiVersion: v1
   kind: Secret
   metadata:
     name: inference-gateway-sa-metrics-reader-secret
     namespace: default
     annotations:
       kubernetes.io/service-account.name: inference-gateway-sa-metrics-reader
   type: kubernetes.io/service-account-token
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRole
   metadata:
     name: inference-gateway-sa-metrics-reader-secret-read
   rules:
   - resources:
     - secrets
     apiGroups: [""]
     verbs: ["get", "list", "watch"]
     resourceNames: ["inference-gateway-sa-metrics-reader-secret"]
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: gmp-system:collector:inference-gateway-sa-metrics-reader-secret-read
     namespace: default
   roleRef:
     name: inference-gateway-sa-metrics-reader-secret-read
     kind: ClusterRole
     apiGroup: rbac.authorization.k8s.io
   subjects:
   - name: collector
     namespace: gmp-system
     kind: ServiceAccount
   EOF
   

Crea un server di modelli e il deployment del modello

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 contenitore del server modello e il tuo modello, la porta di servizio e il nome del deployment. Puoi anche configurare gli adattatori LoRA nel deployment o eseguire il deployment del modello di base. I seguenti passaggi descrivono come creare le risorse Kubernetes necessarie.

1. Crea un secret di Kubernetes per archiviare il token Hugging Face. Questo token viene utilizzato per accedere al modello base e agli adattatori LoRA:

   kubectl create secret generic hf-token --from-literal=token=HF_TOKEN
   

   Sostituisci HF_TOKEN con il tuo token Hugging Face.

2. Esegui il deployment del server del modello e del modello. Il seguente comando applica un manifest che definisce un deployment Kubernetes per un server di modelli vLLM con un modello Llama3:

   kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api-inference-extension/release-1.0/config/manifests/vllm/gpu-deployment.yaml
   

Crea un pool di inferenza

La risorsa personalizzata Kubernetes InferencePool definisce un gruppo di pod con una configurazione di calcolo e un modello linguistico di grandi dimensioni (LLM) di base comune. Il campo selector specifica a quali pod appartengono a questo pool. Le etichette in questo selettore devono corrispondere esattamente a quelle applicate ai pod del server del modello. Il campo targetPort definisce le porte utilizzate dal server del modello all'interno dei pod. 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 indirizzare il traffico ai pod del server del modello.

Prima di creare InferencePool, assicurati che i pod selezionati da InferencePool siano già in esecuzione.

Per creare un InferencePool utilizzando Helm, segui questi passaggi:

helm install vllm-llama3-8b-instruct \
  --set inferencePool.modelServers.matchLabels.app=vllm-llama3-8b-instruct \
  --set provider.name=gke \
  --version v1.0.0 \
  oci://registry.k8s.io/gateway-api-inference-extension/charts/inferencepool

Modifica il seguente campo in modo che corrisponda al tuo deployment:

• inferencePool.modelServers.matchLabels.app: la chiave dell'etichetta utilizzata per selezionare i pod del server di modelli.

L'installazione di Helm installa automaticamente i criteri di timeout, lo strumento di selezione degli endpoint e i pod necessari per l'osservabilità.

Viene creato un oggetto InferencePool: vllm-llama3-8b-instruct che fa riferimento ai servizi endpoint del modello all'interno dei pod. Viene inoltre creato un deployment del selettore di endpoint denominato app:vllm-llama3-8b-instruct-epp per questo InferencePool creato.

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 sua criticità di pubblicazione e il campo poolRef specifica il InferencePool su cui viene pubblicato il modello.

```yaml
apiVersion: inference.networking.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à per l'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 di InferencePool creato nel passaggio precedente. Ad esempio vllm-llama3-8b-instruct.

Per creare un InferenceObjective, segui questi passaggi:

1. Salva il seguente manifest come inference-objectives.yaml. Questo manifest crea due risorse InferenceObjective. La prima configura l'obiettivo di inferenza food-review su vllm-llama3-8b-instruct InferencePool con una priorità di 10. La seconda configura l'llama3-base-model obiettivo di inferenza da pubblicare con una priorità più elevata di 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-instruct
   

2. Applica il manifest di esempio al cluster:

   kubectl apply -f inferenceobjective.yaml
   

Crea il gateway

La risorsa Gateway è il punto di ingresso per il traffico esterno nel tuo cluster Kubernetes. Definisce i listener che accettano le connessioni in entrata.

GKE Inference Gateway funziona con le seguenti classi 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 ulteriori informazioni, consulta la documentazione relativa alle classi Gateway.

Per creare un gateway, segui questi passaggi:

1. 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: http
   

   Sostituisci 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.

2. Applica il manifest al cluster:

   kubectl apply -f gateway.yaml
   

Nota: per saperne di più sulla configurazione di TLS per proteggere il gateway con HTTPS, consulta la documentazione di GKE sulla configurazione TLS.

Crea il HTTPRoute

La risorsa HTTPRoute definisce il modo in cui GKE Gateway instrada le richieste HTTP in entrata ai servizi di backend, ad esempio InferencePool. La risorsa HTTPRoute specifica le regole di corrispondenza (ad esempio intestazioni o percorsi) e il backend a cui deve essere inoltrato il traffico.

1. Per creare un HTTPRoute, salva il seguente manifest di esempio come httproute.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: InferencePool
   

   Sostituisci quanto segue:

   • HTTPROUTE_NAME: un nome univoco per la risorsa HTTPRoute. Ad esempio: my-route.
   • GATEWAY_NAME: il nome della risorsa Gateway che hai creato. Ad esempio: inference-gateway.
   • PATH_PREFIX: il prefisso del percorso che utilizzi per trovare corrispondenze con le richieste in entrata. Ad esempio, / per trovare corrispondenze con tutti.
   • INFERENCE_POOL_NAME: il nome della risorsa InferencePool a cui vuoi indirizzare il traffico. Ad esempio: vllm-llama3-8b-instruct.

2. Applica il manifest al cluster:

   kubectl apply -f httproute.yaml
   

Inviare una 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:

1. Imposta le seguenti variabili di ambiente:

   export GATEWAY_NAME=GATEWAY_NAME
   export PORT_NUMBER=PORT_NUMBER # Use 80 for HTTP
   

   Sostituisci quanto segue:

   • GATEWAY_NAME: il nome della risorsa Gateway.
   • PORT_NUMBER: il numero di porta che hai configurato nel gateway.

2. Per ottenere l'endpoint del gateway, esegui il comando seguente:

   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}
   

3. Per inviare una richiesta all'endpoint /v1/completions utilizzando curl, esegui questo 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 valore 0 per 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 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 stop e top_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 i potenziali errori nella risposta. Ad esempio, controlla il codice di stato HTTP nella risposta curl. Un codice di stato diverso da 200 indica 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.

Passaggi successivi

• Personalizza la configurazione di GKE Inference Gateway
• Configurare il routing basato sul corpo
• Servire un LLM con GKE Inference Gateway