Cette page a été traduite par l'API Cloud Translation.

Déployer un modèle d'IA sur GKE avec NVIDIA NIM

1. Introduction

Cet atelier pratique vous guidera dans le déploiement et la gestion d'un modèle d'IA conteneurisé sur Google Kubernetes Engine (GKE), en utilisant la puissance des microservices NVIDIA NIM™.

Ce tutoriel s'adresse aux développeurs et aux data scientists qui souhaitent :

Simplifiez le déploiement de l'inférence d'IA : découvrez comment utiliser un NIM prédéfini pour déployer plus rapidement et plus facilement des modèles d'IA en production sur GKE.
Optimiser les performances sur les GPU NVIDIA : découvrez comment déployer des NIM qui utilisent NVIDIA TensorRT pour une inférence optimisée sur les GPU de votre cluster GKE.
Faites évoluer les charges de travail d'inférence de l'IA : découvrez comment faire évoluer votre déploiement NIM en fonction de la demande en utilisant Kubernetes pour l'autoscaling et la gestion des ressources de calcul.

2. Objectifs de l'atelier

À la fin de ce tutoriel, vous aurez acquis de l'expérience dans les domaines suivants :

Déployer NIM sur GKE : déployez un NVIDIA NIM prédéfini pour diverses tâches d'inférence sur votre cluster GKE.
Gérer les déploiements NIM : utilisez les commandes kubectl pour gérer, surveiller et mettre à l'échelle vos NIM déployés.
Faites évoluer les charges de travail d'inférence : utilisez les fonctionnalités Kubernetes pour faire évoluer automatiquement vos déploiements NIM en fonction des demandes de trafic.

3. Découvrir les composants

GPU dans Google Kubernetes Engine (GKE)

Les GPU vous permettent d'accélérer des charges de travail spécifiques exécutées sur vos nœuds, telles que le machine learning et le traitement de données. GKE fournit toute une gamme d'options de types de machines pour la configuration des nœuds, y compris les types de machines avec des GPU NVIDIA H100, L4 et A100.

NVIDIA NIM

NVIDIA NIM est un ensemble de microservices d'inférence faciles à utiliser qui permettent d'accélérer le déploiement de modèles de base sur n'importe quel cloud ou centre de données, et de sécuriser vos données.

NVIDIA AI Enterprise

NVIDIA AI Enterprise est une plate-forme logicielle cloud native de bout en bout qui accélère les pipelines de data science et simplifie le développement et le déploiement de copilotes de qualité professionnelle et d'autres applications d'IA générative. Disponible sur GCP Marketplace.

4. Prérequis

Projet : projet Google Cloud pour lequel la facturation est activée.
Autorisations : autorisations suffisantes pour créer des clusters GKE et d'autres ressources associées.
Helm : Helm est un gestionnaire de packages pour Kubernetes.
Opérateur de GPU NVIDIA : un module complémentaire Kubernetes qui automatise la gestion de tous les composants logiciels NVIDIA nécessaires au provisionnement des GPU.
Clé API NVIDIA : cliquez sur ce lien et suivez les instructions pour créer un compte et générer une clé API. Une clé API sera nécessaire pour télécharger le conteneur NIM.
GPU NVIDIA : l'un des GPU ci-dessous devrait fonctionner (veuillez noter que vous pouvez suivre ces étapes pour demander une augmentation de quota si vous ne disposez pas d'assez de GPU)
Facultatif : SDK gcloud : si vous n'utilisez pas Cloud Shell dans le portail GCP, assurez-vous d'avoir installé et configuré le SDK Google Cloud.
Facultatif : kubectl : si vous n'utilisez pas Cloud Shell dans le portail GCP, assurez-vous que l'outil de ligne de commande kubectl est installé et configuré.

5. Créer un cluster GKE avec des GPU

Ouvrez Cloud Shell ou votre terminal.

Spécifiez les paramètres suivants :

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

Veuillez noter que vous devrez peut-être modifier les valeurs de NODE_POOL_MACHINE_TYPE, CLUSTER_MACHINE_TYPE et GPU_TYPE en fonction du type d'instance de calcul et de GPU que vous utilisez.

Créez un cluster GKE :

gcloud container clusters create ${CLUSTER_NAME} \
    --project=${PROJECT_ID} \
    --location=${ZONE} \
    --release-channel=rapid \
    --machine-type=${CLUSTER_MACHINE_TYPE} \
    --num-nodes=1

Créez un pool de nœuds 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. Configurer la clé API NVIDIA NGC

La clé API NGC vous permet d'extraire des images personnalisées depuis NVIDIA NGC. Pour spécifier votre clé :

export NGC_CLI_API_KEY="<YOUR NGC API KEY>"

Il s'agit de la clé générée dans la section "Conditions préalables".

7. Déployer et tester NVIDIA NIM

Récupérez le chart Helm du LLM NIM :

helm fetch https://helm.ngc.nvidia.com/nim/charts/nim-llm-1.3.0.tgz --username='$oauthtoken' --password=$NGC_CLI_API_KEY

Créez un espace de noms NIM :
```
kubectl create namespace nim
```

Configurer les secrets :

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

Configurer la configuration 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

Lancer le déploiement NIM :

helm install my-nim nim-llm-1.1.2.tgz -f nim_custom_value.yaml --namespace nim

Vérifiez que le pod NIM est en cours d'exécution :

kubectl get pods -n nim

Tester le déploiement de NIM :
Une fois que nous avons vérifié que notre service NIM a été déployé avec succès, nous pouvons effectuer des demandes d'inférence pour voir le type de commentaires que nous recevrons du service NIM. Pour ce faire, nous activons le transfert de port sur le service afin de pouvoir accéder au NIM depuis notre localhost sur le port 8000 :

kubectl port-forward service/my-nim-nim-llm 8000:8000 -n nim

Ensuite, nous pouvons ouvrir un autre terminal ou onglet dans Cloud Shell et essayer la requête suivante :

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
}'

Si vous obtenez une réponse de chat du service NIM, cela signifie que le service fonctionne comme prévu.

8. Nettoyage

Supprimez le cluster GKE :

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

9. Étape suivante

Pour en savoir plus, consultez les articles suivants :