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), utilizzando la potenza dei microservizi NVIDIA NIM™.

Questo tutorial è progettato 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. Scopri i componenti

GPU in Google Kubernetes Engine (GKE)

Le GPU ti consentono di accelerare carichi di lavoro specifici in esecuzione sui tuoi nodi, come il machine learning e l'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 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 GPU seguenti 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. Configurare 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. Eseguire il deployment e testare 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 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 il tipo di feedback che 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: