Esegui il deployment di un modello di AI su GKE con NVIDIA NIM

1. Introduzione

Questo codelab pratico ti guiderà nella distribuzione e nella gestione di un modello di AI containerizzato su Google Kubernetes Engine (GKE), sfruttando la potenza dei microservizi NVIDIA NIM™.

Questo tutorial è pensato per sviluppatori e data scientist che vogliono:

  • Semplifica il deployment dell'inferenza AI: scopri come utilizzare un NIM predefinito per un deployment più rapido e semplice dei modelli di AI in produzione su GKE.
  • Ottimizza le prestazioni sulle GPU NVIDIA: acquisisci esperienza pratica con il deployment di NIM che utilizzano NVIDIA TensorRT per un'inferenza ottimizzata sulle GPU all'interno del cluster GKE.
  • Scalare i carichi di lavoro di inferenza AI: scopri come scalare il deployment di NIM in base alla domanda utilizzando Kubernetes per la scalabilità automatica e la gestione delle risorse di calcolo.

2. Cosa imparerai a fare

Al termine di questo tutorial, avrai esperienza con:

  1. Deployment di NIM su GKE: esegui il deployment di un NVIDIA NIM precompilato per varie attività di inferenza nel tuo cluster GKE.
  2. Gestione dei deployment NIM: utilizza i comandi kubectl per gestire, monitorare e scalare i NIM di cui è stato eseguito il deployment.
  3. Scalabilità dei carichi di lavoro di inferenza: utilizza le funzionalità di Kubernetes per la scalabilità automatica dei deployment NIM in base alle esigenze di traffico.

3. Informazioni sui componenti

GPU in Google Kubernetes Engine (GKE)

Le GPU ti consentono di accelerare carichi di lavoro specifici in esecuzione sui tuoi nodi, come machine learning ed elaborazione di dati. GKE offre una gamma di opzioni di tipi di macchine per la configurazione dei nodi, inclusi i tipi di macchine con GPU NVIDIA H100, L4 e A100.

NVIDIA NIM

NVIDIA NIM è un insieme di microservizi di inferenza facili da usare per accelerare il deployment di modelli di base su qualsiasi cloud o data center e contribuire a proteggere i tuoi dati.

NVIDIA AI Enterprise

NVIDIA AI Enterprise è una piattaforma software cloud-native end-to-end che accelera le pipeline di data science e semplifica lo sviluppo e il deployment di copiloti di livello di produzione e altre applicazioni di AI generativa. Disponibile tramite GCP Marketplace.

4. Prerequisiti

  • Progetto:un progetto Google Cloud con la fatturazione abilitata.
  • Autorizzazioni:autorizzazioni sufficienti per creare cluster GKE e altre risorse correlate.
  • Helm: Helm è un gestore di pacchetti per Kubernetes.
  • Operatore GPU NVIDIA: un componente aggiuntivo di Kubernetes che automatizza la gestione di tutti i componenti software NVIDIA necessari per il provisioning della GPU.
  • Chiave API NVIDIA:fai clic su questo link e segui le istruzioni su come creare un account e generare una chiave API. Per scaricare il container NIM sarà necessaria una chiave API.
  • GPU NVIDIA:una delle seguenti GPU dovrebbe funzionare (tieni presente che puoi seguire questi passaggi per richiedere un aumento della quota, se non hai GPU sufficienti)
  • (Facoltativo) - SDK GCloud: se non utilizzi Cloud Shell nel portale GCP, assicurati di aver installato e configurato Google Cloud SDK.
  • (Facoltativo) - kubectl: se non utilizzi Cloud Shell nel portale GCP, assicurati di aver installato e configurato lo strumento a riga di comando kubectl.

5. Crea un cluster GKE con GPU

  1. Apri Cloud Shell o il terminale.
  2. Specifica i seguenti parametri:
    export PROJECT_ID=<YOUR PROJECT ID>
export REGION=<YOUR REGION>
export ZONE=<YOUR ZONE>
export CLUSTER_NAME=nim-demo
export NODE_POOL_MACHINE_TYPE=g2-standard-16
export CLUSTER_MACHINE_TYPE=e2-standard-4
export GPU_TYPE=nvidia-l4
export GPU_COUNT=1

Tieni presente che potresti dover modificare i valori di NODE_POOL_MACHINE_TYPE, CLUSTER_MACHINE_TYPE e GPU_TYPE in base al tipo di istanza di Compute e alle GPU che utilizzi.

  1. Crea cluster GKE:
    gcloud container clusters create ${CLUSTER_NAME} \
    --project=${PROJECT_ID} \
    --location=${ZONE} \
    --release-channel=rapid \
    --machine-type=${CLUSTER_MACHINE_TYPE} \
    --num-nodes=1
  2. Crea il node pool GPU:
    gcloud container node-pools create gpupool \
    --accelerator type=${GPU_TYPE},count=${GPU_COUNT},gpu-driver-version=latest \
    --project=${PROJECT_ID} \
    --location=${ZONE} \
    --cluster=${CLUSTER_NAME} \
    --machine-type=${NODE_POOL_MACHINE_TYPE} \
    --num-nodes=1

6. Configura la chiave API NVIDIA NGC

La chiave API NGC ti consente di estrarre immagini personalizzate da NVIDIA NGC. Per specificare la chiave:

export NGC_CLI_API_KEY="<YOUR NGC API KEY>"

Questa è la chiave generata nell'ambito dei prerequisiti.

7. Esegui il deployment e testa NVIDIA NIM

  1. Recupera il grafico Helm LLM NIM:
    helm fetch https://helm.ngc.nvidia.com/nim/charts/nim-llm-1.3.0.tgz --username='$oauthtoken' --password=$NGC_CLI_API_KEY
  2. Crea uno spazio dei nomi NIM:
    kubectl create namespace nim
  3. Configura i secret:
    kubectl create secret docker-registry registry-secret --docker-server=nvcr.io --docker-username='$oauthtoken'     --docker-password=$NGC_CLI_API_KEY -n nim

kubectl create secret generic ngc-api --from-literal=NGC_API_KEY=$NGC_CLI_API_KEY -n nim
  4. Configura la configurazione NIM:
    cat <<EOF > nim_custom_value.yaml
image:
  repository: "nvcr.io/nim/meta/llama3-8b-instruct" # container location
  tag: 1.0.0 # NIM version you want to deploy
model:
  ngcAPISecret: ngc-api  # name of a secret in the cluster that includes a key named NGC_CLI_API_KEY and is an NGC API key
persistence:
  enabled: true
imagePullSecrets:
  -   name: registry-secret # name of a secret used to pull nvcr.io images, see https://kubernetes.io/docs/tasks/    configure-pod-container/pull-image-private-registry/
EOF
  5. Avvio del deployment di NIM:
    helm install my-nim nim-llm-1.1.2.tgz -f nim_custom_value.yaml --namespace nim
    Verifica che il pod NIM sia in esecuzione:
    kubectl get pods -n nim
  6. Test del deployment di NIM:
    una volta verificato che il nostro servizio NIM è stato implementato correttamente, possiamo effettuare richieste di inferenza per vedere che tipo di feedback riceveremo dal servizio NIM. Per farlo, abilitiamo l'inoltro delle porte sul servizio per poter accedere a NIM da localhost sulla porta 8000:
    kubectl port-forward service/my-nim-nim-llm 8000:8000 -n nim
    Successivamente, possiamo aprire un altro terminale o scheda in Cloud Shell e provare la seguente richiesta:
    curl -X 'POST' \
  'http://localhost:8000/v1/chat/completions' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "messages": [
    {
      "content": "You are a polite and respectful chatbot helping people plan a vacation.",
      "role": "system"
    },
    {
      "content": "What should I do for a 4 day vacation in Spain?",
      "role": "user"
    }
  ],
  "model": "meta/llama3-8b-instruct",
  "max_tokens": 128,
  "top_p": 1,
  "n": 1,
  "stream": false,
  "stop": "\n",
  "frequency_penalty": 0.0
}'
    Se ricevi un completamento della chat dal servizio NIM, significa che il servizio funziona come previsto.

8. Esegui la pulizia

Elimina il cluster GKE:

gcloud container clusters delete $CLUSTER_NAME --zone=$ZONE

9. Passaggi successivi

Per maggiori informazioni, leggi gli articoli seguenti: