Gérer la pile de GPU avec l'opérateur GPU NVIDIA sur Google Kubernetes Engine (GKE)

Standard

Cette page vous aide à déterminer quand utiliser l'opérateur GPU NVIDIA et vous explique comment l'activer sur GKE.

Présentation

Les opérateurs sont des extensions logicielles de Kubernetes qui permettent aux utilisateurs de créer des ressources personnalisées chargées de gérer les applications et leurs composants. Vous pouvez utiliser des opérateurs pour aller au-delà de ce que propose Kubernetes et automatiser des tâches complexes, telles que le déploiement et la mise à niveau d'applications.

L'opérateur GPU NVIDIA est un opérateur Kubernetes qui fournit une infrastructure commune et une API pour le déploiement, la configuration et la gestion des composants logiciels nécessaires au provisionnement de GPU NVIDIA dans un cluster Kubernetes. L'opérateur GPU NVIDIA vous offre une expérience cohérente, et simplifie la gestion des ressources GPU et l'intégration des charges de travail accélérées par GPU dans Kubernetes.

Pourquoi utiliser l'opérateur GPU NVIDIA ?

Nous vous recommandons d'utiliser la gestion de GPU par GKE pour vos nœuds GPU, car GKE gère entièrement le cycle de vie des nœuds GPU. Pour commencer à utiliser GKE pour gérer vos nœuds GPU, choisissez l'une des options suivantes :

L'opérateur GPU NVIDIA peut également être une option appropriée si vous cherchez à définir une expérience cohérente entre plusieurs fournisseurs de services cloud, si vous utilisez déjà l'opérateur GPU NVIDIA ou si vous utilisez des logiciels qui dépendent de l'opérateur GPU NVIDIA.

Pour déterminer plus aisément laquelle de ces options convient à votre situation, consultez la section Gérer la pile de GPU via GKE ou l'opérateur GPU NVIDIA sur GKE.

Limites

L'opérateur GPU NVIDIA est compatible avec les images de nœuds Container-Optimized OS (COS) et Ubuntu, avec les limites suivantes :

La version 24.6.0 de l'opérateur GPU, ou une version ultérieure, est requise pour assurer la compatibilité de l'opérateur GPU NVIDIA avec GKE.
L'opérateur GPU NVIDIA n'est pas compatible avec les clusters en mode Autopilot.
L'opérateur GPU NVIDIA n'est pas compatible avec les images de nœuds Windows.
L'opérateur GPU NVIDIA n'est pas géré par GKE. Pour mettre à niveau l'opérateur GPU NVIDIA, consultez la documentation de NVIDIA.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

Activez l'API Google Kubernetes Engine.

Activer l'API Google Kubernetes Engine

Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.
Remarque : Pour les installations de gcloud CLI existantes, veillez à définir les propriétés compute/region et compute/zone. En définissant des emplacements par défaut, vous pouvez éviter les erreurs gcloud CLI telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location.

Assurez-vous de remplir les conditions requises listées dans la section Exécuter des GPU dans des pools de nœuds en mode Standard.
Vérifiez que Helm est installé dans votre environnement de développement. Helm est préinstallé sur Cloud Shell.

Bien qu'aucune version Helm spécifique ne soit requise, vous pouvez utiliser la commande suivante pour vérifier que Helm est bien installé.
```
helm version
```
Si le résultat renvoie Command helm not found, vous pouvez installer la CLI Helm en exécutant la commande suivante :
```
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 \
  && chmod 700 get_helm.sh \
  && ./get_helm.sh
```

Créer et configurer le pool de nœuds GPU

Procédez comme suit pour créer et configurer le pool de nœuds GPU :

Créez un pool de nœuds GPU en suivant les instructions sur la création d'un pool de nœuds GPU, et en apportant les modifications suivantes :
- Définissez gpu-driver-version=disabled pour ignorer l'installation automatique des pilotes de GPU, car ceux-ci ne sont pas compatibles avec l'opérateur GPU NVIDIA.
- Définissez --node-labels="gke-no-default-nvidia-gpu-device-plugin=true" pour désactiver le DaemonSet ciblant le plug-in des appareils GPU gérés par GKE.
Exécutez la commande suivante et ajoutez si nécessaire d'autres options pour la création du pool de nœuds GPU :
```
gcloud container node-pools create POOL_NAME \
  --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=disabled \
  --node-labels="gke-no-default-nvidia-gpu-device-plugin=true"
```
Remplacez les éléments suivants :
- POOL_NAME : nom que vous avez choisi pour le pool de nœuds.
- GPU_TYPE : type d'accélérateur GPU que vous souhaitez utiliser. Par exemple, nvidia-h100-80gb.
- AMOUNT : nombre de GPU à associer aux nœuds du pool de nœuds.
Par exemple, la commande suivante crée un pool de nœuds GKE intitulé a3nodepool, avec des GPU H100 dans le cluster zonal a3-cluster. Dans cet exemple, le DaemonSet ciblant le plug-in des appareils GPU gérés par GKE, ainsi que l'installation automatique des pilotes, sont désactivés.
```
gcloud container node-pools create a3nodepool \
  --region=us-central1 --cluster=a3-cluster \
  --node-locations=us-central1-a \
  --accelerator=type=nvidia-h100-80gb,count=8,gpu-driver-version=disabled \
  --machine-type=a3-highgpu-8g \
  --node-labels="gke-no-default-nvidia-gpu-device-plugin=true" \
  --num-nodes=1
```
Obtenez les identifiants d'authentification du cluster en exécutant la commande suivante :
```
USE_GKE_GCLOUD_AUTH_PLUGIN=True \
gcloud container clusters get-credentials CLUSTER_NAME [--zone COMPUTE_ZONE] [--region COMPUTE_REGION]
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster contenant votre pool de nœuds.
- COMPUTE_REGION ou COMPUTE_ZONE : spécifiez la région ou la zone du cluster selon qu'il s'agit d'un cluster régional ou zonal, respectivement.
Le résultat ressemble à ce qui suit :
```
Fetching cluster endpoint and auth data.
kubeconfig entry generated for CLUSTER_NAME.
```
(Facultatif) Vérifiez que vous pouvez vous connecter au cluster.
```
kubectl get nodes -o wide
```
Vous devriez voir la liste de tous les nœuds exécutés dans ce cluster.
Créez l'espace de noms gpu-operator pour l'opérateur GPU NVIDIA en exécutant la commande suivante :
```
kubectl create ns gpu-operator
```
Le résultat ressemble à ce qui suit :
```
namespace/gpu-operator created
```

Créez un quota de ressources dans l'espace de noms gpu-operator en exécutant la commande suivante :

kubectl apply -n gpu-operator -f - << EOF
apiVersion: v1
kind: ResourceQuota
metadata:
  name: gpu-operator-quota
spec:
  hard:
    pods: 100
  scopeSelector:
    matchExpressions:
    - operator: In
      scopeName: PriorityClass
      values:
        - system-node-critical
        - system-cluster-critical
EOF

Le résultat ressemble à ce qui suit :

resourcequota/gpu-operator-quota created

Affichez le quota de ressources de l'espace de noms gpu-operator :

kubectl get -n gpu-operator resourcequota gpu-operator-quota

Le résultat ressemble à ce qui suit :

NAME                 AGE     REQUEST       LIMIT
gpu-operator-quota   2m27s   pods: 0/100

Installez manuellement les pilotes sur vos nœuds Container-Optimized OS ou Ubuntu. Pour obtenir des instructions détaillées, consultez la page Installer manuellement les pilotes de GPU NVIDIA.
- Si vous utilisez COS, exécutez les commandes suivantes pour déployer le DaemonSet d'installation et installer la version par défaut des pilotes de GPU :
```
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml
```
- Si vous utilisez Ubuntu, le DaemonSet d'installation que vous déployez dépend du type de GPU et de la version de nœud GKE, comme décrit dans la section Ubuntu des instructions.

Vérifiez la version des pilotes de GPU en exécutant la commande suivante :

kubectl logs -l k8s-app=nvidia-driver-installer  \
  -c "nvidia-driver-installer" --tail=-1 -n kube-system

Le résultat est semblable à ceci lorsque l'installation des pilotes de GPU réussit :

I0716 03:17:38.863927    6293 cache.go:66] DRIVER_VERSION=535.183.01
…
I0716 03:17:38.863955    6293 installer.go:58] Verifying GPU driver installation
I0716 03:17:41.534387    6293 install.go:543] Finished installing the drivers.

Installer l'opérateur GPU NVIDIA

Cette section explique comment installer l'opérateur GPU NVIDIA à l'aide de Helm. Pour en savoir plus, consultez la documentation NVIDIA sur l'installation de l'opérateur GPU NVIDIA.

Ajoutez le dépôt Helm NVIDIA :

helm repo add nvidia https://helm.ngc.nvidia.com/nvidia \
  && helm repo update

Installez l'opérateur GPU NVIDIA à l'aide de Helm avec les options de configuration suivantes :
- Assurez-vous que la version de l'opérateur GPU est la version 24.6.0 ou une version ultérieure.
- Configurez le chemin d'installation des pilotes dans l'opérateur GPU comme suit : hostPaths.driverInstallDir=/home/kubernetes/bin/nvidia.
- Définissez le chemin d'installation du kit d'outils, pour COS et Ubuntu, comme suit : toolkit.installDir=/home/kubernetes/bin/nvidia. Dans COS, le répertoire /home est accessible en écriture et sert d'emplacement avec état pour le stockage des binaires d'exécution NVIDIA. Pour en savoir plus, consultez la page Présentation des disques et du système de fichiers de COS.
- Activez la spécification Container Device Interface (CDI) dans l'opérateur GPU en définissant cdi.enabled=true et cdi.default=true, car l'ancien mode n'est pas compatible. La spécification CDI est obligatoire pour COS et Ubuntu sur GKE.
```
helm install --wait --generate-name \
  -n gpu-operator \
  nvidia/gpu-operator \
  --set hostPaths.driverInstallDir=/home/kubernetes/bin/nvidia \
  --set toolkit.installDir=/home/kubernetes/bin/nvidia \
  --set cdi.enabled=true \
  --set cdi.default=true \
  --set driver.enabled=false
```
Pour en savoir plus sur ces paramètres, consultez les pages Common Chart Customization Options et Common Deployment Scenarios de la documentation NVIDIA.

Vérifiez que l'opérateur GPU NVIDIA est bien installé.

Pour vérifier que les opérandes de l'opérateur GPU s'exécutent correctement, exécutez la commande suivante.

kubectl get pods -n gpu-operator

La sortie ressemble à ceci :

NAME                                                          READY    STATUS
RESTARTS   AGE
gpu-operator-5c7cf8b4f6-bx4rg                                 1/1      Running   0          11m
gpu-operator-node-feature-discovery-gc-79d6d968bb-g7gv9       1/1      Running   0          11m
gpu-operator-node-feature-discovery-master-6d9f8d497c-thhlz   1/1      Running   0          11m
gpu-operator-node-feature-discovery-worker-wn79l              1/1      Running   0          11m
gpu-feature-discovery-fs9gw                                   1/1      Running   0          8m14s
gpu-operator-node-feature-discovery-worker-bdqnv              1/1      Running   0          9m5s
nvidia-container-toolkit-daemonset-vr8fv                      1/1      Running   0          8m15s
nvidia-cuda-validator-4nljj                                   0/1      Completed 0          2m24s
nvidia-dcgm-exporter-4mjvh                                    1/1      Running   0          8m15s
nvidia-device-plugin-daemonset-jfbcj                          1/1      Running   0          8m15s
nvidia-mig-manager-kzncr                                      1/1      Running   0          2m5s
nvidia-operator-validator-fcrr6                               1/1      Running   0          8m15s

Pour vérifier que le nombre de GPU est correctement configuré dans le champ "Pouvant être affectée" du nœud, exécutez la commande suivante :

kubectl describe node GPU_NODE_NAME | grep Allocatable -A7

Remplacez GPU_NODE_NAME par le nom du nœud contenant des GPU.

Le résultat ressemble à ce qui suit :

Allocatable:
cpu:                11900m
ephemeral-storage:  47060071478
hugepages-1Gi:      0
hugepages-2Mi:      0
memory:             80403000Ki
nvidia.com/gpu:     1           # showing correct count of GPU associated with the nods
pods:               110

Pour vérifier que la charge de travail GPU s'exécute correctement, vous pouvez utiliser l'outil cuda-vectoradd :

cat << EOF | kubectl create -f -
apiVersion: v1
kind: Pod
metadata:
  name: cuda-vectoradd
spec:
  restartPolicy: OnFailure
  containers:
  - name: vectoradd
    image: nvidia/samples:vectoradd-cuda11.2.1
    resources:
      limits:
        nvidia.com/gpu: 1
EOF

Exécutez ensuite la commande suivante :

kubectl logs cuda-vectoradd

Le résultat ressemble à ce qui suit :

[Vector addition of 50000 elements]
Copy input data from the host memory to the CUDA device
CUDA kernel launch with 196 blocks of 256 threads
Copy output data from the CUDA device to the host memory
Test PASSED
Done

Gérer la pile de GPU avec l'opérateur GPU NVIDIA sur Google Kubernetes Engine (GKE)

Présentation

Pourquoi utiliser l'opérateur GPU NVIDIA ?

Limites

Avant de commencer

Créer et configurer le pool de nœuds GPU

Installer l'opérateur GPU NVIDIA

Étape suivante