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

1. Introduction

Cet atelier de programmation pratique vous explique comment déployer et gérer un modèle d'IA conteneurisé sur Google Kubernetes Engine (GKE) à l'aide de la puissance des microservices NVIDIA NIM™.

Ce tutoriel est destiné aux développeurs et aux data scientists qui souhaitent :

  • simplifier 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 : acquérez une expérience pratique du déploiement de NIM qui utilisent NVIDIA TensorRT pour une inférence optimisée sur les GPU de votre cluster GKE ;
  • mettre à l'échelle les charges de travail d'inférence d'IA : découvrez comment mettre à l'échelle votre déploiement NIM en fonction de la demande à l'aide de 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 :

  1. Déployer NIM sur GKE : déployez un NVIDIA NIM prédéfini pour différentes tâches d'inférence sur votre cluster GKE.
  2. Gérer les déploiements NIM : utilisez les commandes kubectl pour gérer, surveiller et mettre à l'échelle votre NIM déployé.
  3. Mettre à l'échelle les charges de travail d'inférence : utilisez les fonctionnalités Kubernetes pour mettre à l'échelle 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 accélèrent le déploiement de modèles de base sur n'importe quel cloud ou centre de données et vous aident à 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 science des données et simplifie le développement et le déploiement de copilotes de qualité production et d'autres applications d'IA générative. Disponible sur GCP Marketplace.

4. Prérequis

  • Projet : un projet Google Cloud avec facturation activée.
  • Autorisations : autorisations suffisantes pour créer des clusters GKE et d'autres ressources associées.
  • Helm: Helm est un gestionnaire de paquets pour Kubernetes.
  • Opérateur GPU NVIDIA: un module complémentaire Kubernetes qui automatise la gestion de tous les composants logiciels NVIDIA nécessaires au provisionnement de 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 est requise 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 que le SDK Google Cloud est installé et configuré.
  • 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

  1. Ouvrez Cloud Shell ou votre terminal.
  2. 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 des GPU que vous utilisez.

  1. Créer 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
  2. Créer 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 de 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 Prérequis.

7. Déployer et tester NVIDIA NIM

  1. Extraire le graphique 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. Créer un espace de noms NIM :
    kubectl create namespace nim
  3. 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
  4. Configurer 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. Lancer le déploiement NIM :
    helm install my-nim nim-llm-1.1.2.tgz -f nim_custom_value.yaml --namespace nim
    Vérifier que le pod NIM est en cours d'exécution :
    kubectl get pods -n nim
  6. Tester le déploiement NIM :
    Une fois que nous avons vérifié que notre service NIM a été déployé correctement, nous pouvons envoyer des requêtes 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 à partir de notre hôte local sur le port 8000 :
    kubectl port-forward service/my-nim-nim-llm 8000:8000 -n nim
    Ensuite, nous pouvons ouvrir un autre terminal ou un autre 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 complétion 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 :