Déployer des charges de travail GPU dans Autopilot

Cette page explique comment demander des accélérateurs matériels (GPU) dans vos charges de travail Autopilot Google Kubernetes Engine (GKE).

Autopilot fournit la classe de calcul Accelerator spécialisée pour exécuter les pods GPU. Avec cette classe de calcul, GKE place les pods sur des nœuds GPU, ce qui permet à ces pods d'accéder à des fonctionnalités avancées sur la machine virtuelle (VM). Vous pouvez également exécuter des pods de GPU sans sélectionner la classe de calcul Accelerator. Pour en savoir plus sur les avantages de la classe de calcul Accelerator, consultez la section Quand utiliser des classes de calcul spécifiques.

Tarification

Autopilot vous facture différemment selon que vous avez demandé la classe de calcul Accelerator pour exécuter vos charges de travail GPU.

Utiliser la classe de calcul Accelerator ? Tarification Compatibilité avec les fonctionnalités de GKE
Le matériel Compute Engine qui exécute vos charges de travail GPU vous est facturé, ainsi qu'un supplément Autopilot pour la gestion et l'évolutivité automatiques des nœuds. Pour en savoir plus, consultez Tarifs du mode Autopilot.

Compatibles avec les éléments suivants :
Vous êtes facturé en fonction des demandes de ressources des pods GPU. Pour en savoir plus, consultez la section "Pods GPU" dans la section Tarifs de Kubernetes Engine.

Compatibles avec les éléments suivants :

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.

  • Assurez-vous de disposer d'un cluster GKE Autopilot exécutant l'une des versions suivantes :

    • Classe de calcul d'accélérateur : toute version de correctif de la version 1.28 à partir de 1.28.6-gke.1095000
      • GPU NVIDIA H100 (80 Go) : 1.28.6-gke.1369000 ou version ultérieure et 1.29.1-gke.1575000 ou version ultérieure
      • Plusieurs pods GPU par VM : 1.29.2-gke.1355000 ou version ultérieure

    • Aucune classe de calcul sélectionnée :

      • GPU NVIDIA L4 : 1.28.3-gke.1203000 ou version ultérieure
      • GPU NVIDIA A100 (80 Go) : 1.27 ou version ultérieure
      • Tous les autres GPU : 1.24.2-gke.1800 ou version ultérieure

  • Assurez-vous de disposer de quotas de GPU suffisants dans votre projet. Vous devez disposer d'un quota de GPU Compute Engine suffisant pour les modèles de GPU que vous souhaitez créer dans chaque région. En cas de besoin, demandez un quota de GPU.

Limites

  • Les GPU à temps partagé et les GPU multi-instances sont disponibles avec Autopilot sur les versions 1.29.3-gke.1093000 et ultérieures de GKE.
  • La disponibilité des GPU dépend de la région Google Cloud de votre cluster Autopilot et de votre quota de GPU. Pour trouver un modèle de GPU par région ou zone, consultez la page Disponibilité des GPU dans les régions et zones.
  • Pour les GPU NVIDIA A100 (80 Go), un montant fixe vous est facturé pour les disques SSD locaux associés aux nœuds, que vos pods utilisent cette capacité ou non.
  • Pour les versions de GKE antérieures à la version 1.29.2-gke.1355000, si vous demandez explicitement un nœud GPU existant spécifique pour votre pod, celui-ci doit consommer toutes les ressources GPU du nœud. Par exemple, si le nœud existant comporte huit GPU et que les conteneurs de votre pod demandent quatre GPU au total, le mode Autopilot va rejeter le pod.
  • Pour GKE version 1.29.2-gke.1355000 ou ultérieure, si vous souhaitez que plusieurs pods GPU tiennent dans un seul nœud, la somme des demandes de GPU pour ces pods doit être inférieure ou égale au nombre de ressources GPU associées à ce nœud. Par exemple, un nœud avec un gke-accelerator-count de 4 peut accepter jusqu'à quatre pods qui demandent un GPU chacun.

Le placement de plusieurs pods sur un même nœud GPU est utile dans les situations suivantes :

  • Vous avez des réservations de capacité pour de grands types de machines "Accélérateur" et vous exécutez des charges de travail à GPU unique. Dans ce cas, le déploiement d'un pod par nœud aurait pour effet de gaspiller les autres GPU sur cette machine.
  • Vous avez des charges de travail GPU qui doivent s'exécuter sur le même hôte.

Dans ces situations, nous vous recommandons d'utiliser tous les GPU du nœud en vous assurant que la somme des demandes de ressources GPU de pod sur le nœud est égale au nombre de GPU associés au nœud.

Demander des GPU dans vos conteneurs

Pour demander des ressources GPU pour vos conteneurs, ajoutez les champs suivants à la spécification de pod. Selon les exigences de votre charge de travail, vous pouvez éventuellement omettre les champs cloud.google.com/compute-class: "Accelerator" et cloud.google.com/gke-accelerator-count.

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  nodeSelector:
    cloud.google.com/compute-class: "Accelerator"
    cloud.google.com/gke-accelerator: GPU_TYPE
    cloud.google.com/gke-accelerator-count: GPU_COUNT
  containers:
  - name: my-gpu-container
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
        nvidia.com/gpu: GPU_QUANTITY

Remplacez les éléments suivants :

  • GPU_TYPE : type de matériel GPU. Les valeurs autorisées sont les suivantes :
    • nvidia-h100-80gb : NVIDIA H100 (80 Go) (disponible uniquement avec la classe de calcul Accelerator)
    • nvidia-a100-80gb : NVIDIA A100 (80 Go)
    • nvidia-tesla-a100 : NVIDIA A100 (40 Go)
    • nvidia-l4 : NVIDIA L4
    • nvidia-tesla-t4 : NVIDIA T4
  • GPU_COUNT : nombre total de GPU disponibles à associer au nœud. Doit être supérieur ou égal à GPU_QUANTITY et une quantité de GPU compatible pour le type de GPU que vous avez sélectionné. Si vous omettez ce nodeSelector, Autopilot place un pod sur chaque nœud GPU.
  • GPU_QUANTITY : nombre de GPU à allouer au conteneur. Doit être inférieur ou égal à GPU_COUNT et une quantité de GPU compatible pour le type de GPU que vous avez sélectionné.

Vous devez spécifier à la fois le type de GPU et la quantité de GPU dans la spécification de pod. Si vous omettez l'une de ces valeurs, Autopilot rejettera votre pod.

Lorsque vous déployez ce fichier manifeste, Autopilot installe automatiquement les pilotes NVIDIA par défaut pour la version de nœud GKE. Dans les versions 1.29.2-gke.1108000 et ultérieures, vous pouvez éventuellement choisir d'installer la dernière version du pilote pour cette version de GKE en ajoutant le sélecteur de nœud suivant à votre fichier manifeste :

spec:
  nodeSelector:
    cloud.google.com/gke-gpu-driver-version: "DRIVER_VERSION"

Remplacez DRIVER_VERSION par l'une des valeurs suivantes :

  • default : pilote stable par défaut pour la version de GKE de votre nœud. Si vous omettez le nodeSelector dans votre fichier manifeste, il s'agit de l'option par défaut.
  • latest : dernière version de pilote disponible pour la version de GKE de votre nœud.

Demandes de ressources mémoire et de processeur pour les pods de GPU dans Autopilot

Lorsque vous définissez vos pods GPU, vous devez également demander des ressources de processeur et de mémoire afin que vos conteneurs fonctionnent comme prévu. Autopilot applique des valeurs de processeur et de mémoire minimales, maximales, et par défaut en fonction du type de GPU et de sa quantité. Si vous exécutez plusieurs pods GPU sur un seul nœud, spécifiez le processeur et la mémoire. Sinon, ils utiliseront par défaut la capacité totale du nœud. Pour en savoir plus, consultez la page Demandes de ressources dans Autopilot.

La spécification de votre pod doit ressembler à l'exemple suivant, qui demande quatre GPU T4 :

apiVersion: v1
kind: Pod
metadata:
  name: t4-pod
spec:
  nodeSelector:
    cloud.google.com/compute-class: "Accelerator"
    cloud.google.com/gke-accelerator: "nvidia-tesla-t4"
  containers:
  - name: t4-container-1
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
        nvidia.com/gpu: 3
        cpu: "54"
        memory: "54Gi"
      requests:
        cpu: "54"
        memory: "54Gi"
  - name: t4-container-2
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
        nvidia.com/gpu: 1
        cpu: "18"
        memory: "18Gi"
      requests:
        cpu: "18"
        memory: "18Gi"

Ce fichier manifeste spécifie la valeur de limits pour les ressources de processeur et de mémoire. Si vous omettez la valeur de limits pour le processeur ou la mémoire dans GKE 1.29.2-gke.1060000 et versions ultérieures, GKE attribue à vos pods la classe QoS Burstable et permet à vos pods de passer en utilisation intensive et d'exploiter les ressources inutilisées en s'appuyant sur la somme des demandes de ressources sur le nœud. Pour en savoir plus, consultez la page Configurer l'utilisation intensive des pods dans GKE.

Demandes de stockage éphémère pour les pods de GPU dans Autopilot

Vous pouvez également demander un stockage éphémère dans les pods nécessitant un stockage de courte durée. La capacité maximale de stockage éphémère et le type de matériel de stockage utilisés dépendent du type et de la quantité de GPU demandés par le pod. Vous pouvez utiliser le disque SSD local pour le stockage éphémère si vous utilisez des GPU NVIDIA L4, la classe de calcul Accelerator et exécutez la version de correctif GKE 1.28.6-gke.1369000 et ultérieure ou 1.29.1-gke.1575000 et versions ultérieures.

Pour utiliser le disque SSD local comme stockage éphémère, ajoutez le sélecteur de nœuds cloud.google.com/gke-ephemeral-storage-local-ssd: "true" au fichier manifeste de votre charge de travail. Consultez l'exemple de fichier manifeste dans la section Utiliser le stockage éphémère basé sur le disque SSD local avec des clusters Autopilot. Les GPU NVIDIA H100 (80 Go) et NVIDIA A100 (80 Go) utilisent toujours des disques SSD locaux pour le stockage éphémère. Vous ne pouvez pas spécifier ce sélecteur de nœud pour ces GPU.

Vérifier l'allocation de GPU

Pour vérifier qu'une charge de travail GPU déployée possède les GPU demandés, exécutez la commande suivante :

kubectl describe node NODE_NAME

Remplacez NODE_NAME par le nom du nœud sur lequel le pod a été planifié.

Le résultat ressemble à ce qui suit :


apiVersion: v1
kind: Node
metadata:
...
  labels:
    ...
    cloud.google.com/gke-accelerator: nvidia-tesla-t4
    cloud.google.com/gke-accelerator-count: "1"
    cloud.google.com/machine-family: custom-48
    ...
...

Vérifier la version du pilote de GPU

Dans les clusters Autopilot, GKE installe automatiquement les pilotes d'appareils NVIDIA sur tous les nœuds GPU. Pour trouver la version du pilote que GKE a installé dans votre cluster, exécutez la commande suivante :

kubectl logs --label=k8s-app=nvidia-gpu-device-plugin \
    --container="nvidia-gpu-device-plugin" \
    --tail=-1 \
    --namespace=kube-system | grep Driver

Le résultat ressemble à ce qui suit :

I1206 18:37:08.251742    5851 metrics.go:144] nvml initialized successfully. Driver version: 535.104.12

Fonctionnement de l'allocation de GPU dans Autopilot

Une fois que vous avez demandé un type de GPU et une quantité pour les conteneurs d'un pod et déployé le pod, voici ce qui se produit :

  1. Si aucun nœud GPU ne peut être alloué, Autopilot provisionne un nouveau nœud GPU pour planifier le pod. Autopilot installe automatiquement les pilotes NVIDIA afin d'assurer la mise à disposition du matériel.
  2. Autopilot ajoute des rejets de nœuds au nœud GPU et ajoute les tolérances correspondantes au pod. Cela empêche GKE de planifier d'autres pods sur le nœud GPU.

Autopilot place exactement un pod GPU sur chaque nœud GPU, ainsi que toutes les charges de travail gérées par GKE qui s'exécutent sur tous les nœuds et tous les DaemonSets que vous configurez afin de tolérer tous les rejets de nœuds.

Exécuter des DaemonSet sur chaque nœud

Vous pouvez exécuter des DaemonSet sur chaque nœud, même sur les nœuds avec des rejets appliqués. Par exemple, certains agents de journalisation et de surveillance doivent s'exécuter sur chaque nœud du cluster. Vous pouvez configurer ces objets DaemonSet pour ignorer les rejets de nœuds, afin que GKE les place sur chaque nœud.

Pour exécuter des objets DaemonSet sur chaque nœud de votre cluster, y compris vos nœuds GPU, ajoutez la tolérance suivante à votre spécification :

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: logging-agent
spec:
  tolerations:
  - key: ""
    operator: "Exists"
    effect: ""
  containers:
  - name: logging-agent-v1
    image: IMAGE_PATH

Pour exécuter des objets DaemonSet sur des nœuds GPU spécifiques de votre cluster, ajoutez les éléments suivants à votre spécification :

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: logging-agent
spec:
  nodeSelector:
    cloud.google.com/gke-accelerator: "GPU_TYPE"
  tolerations:
  - key: ""
    operator: "Exists"
    effect: ""
  containers:
  - name: logging-agent-v1
    image: IMAGE_PATH

Remplacez GPU_TYPE par le type de GPU dans vos nœuds cibles. Les possibilités suivantes s'offrent à vous :

  • nvidia-h100-80gb : NVIDIA H100 (80 Go) (disponible uniquement avec la classe de calcul Accelerator)
  • nvidia-a100-80gb : NVIDIA A100 (80 Go)
  • nvidia-tesla-a100 : NVIDIA A100 (40 Go)
  • nvidia-l4 : NVIDIA L4
  • nvidia-tesla-t4 : NVIDIA T4

Cas d'utilisation des GPU dans Autopilot

Vous pouvez allouer des GPU à des conteneurs dans des pods Autopilot pour faciliter les charges de travail telles que :

  • Inférence de machine learning (ML)
  • Entraînement de machine learning
  • Rendu

Quantités de GPU compatibles

Lorsque vous demandez des GPU dans la spécification de pod, vous devez utiliser les quantités suivantes en fonction du type de GPU :

Quantités de GPU
NVIDIA L4
nvidia-l4		 1, 2, 4, 8
NVIDIA T4
nvidia-tesla-t4		 1, 2, 4
NVIDIA A100 (40 Go)
nvidia-tesla-a100		 1, 2, 4, 8, 16
NVIDIA A100 (80 Go)
nvidia-a100-80gb		 1, 2, 4, 8
NVIDIA H100 (80 Go)
nvidia-h100-80gb		 8

Si vous demandez une quantité de GPU qui n'est pas acceptée pour ce type, Autopilot va rejeter votre pod.

Surveiller des nœuds GPU

Si les métriques système sont activées dans votre cluster GKE, les métriques suivantes sont disponibles dans Cloud Monitoring pour surveiller les performances des charges de travail des GPU :

  • Cycle d'utilisation (container/accelerator/duty_cycle) : durée exprimée en pourcentage de la dernière période d'échantillonnage (10 secondes) pendant laquelle l'accélérateur a été en mode de traitement actif. Entre 1 et 100.
  • Utilisation de la mémoire (container/accelerator/memory_used) : quantité de mémoire d'accélérateur allouée, en octets.
  • Capacité de mémoire (container/accelerator/memory_total) : mémoire totale de l'accélérateur, en octets.

Vous pouvez utiliser des tableaux de bord prédéfinis pour surveiller vos clusters avec des nœuds GPU. Pour en savoir plus, consultez la page Afficher les métriques d'observabilité. Pour obtenir des informations générales sur la surveillance de vos clusters et de leurs ressources, consultez la page Observabilité pour GKE.

Afficher les métriques d'utilisation des charges de travail

Pour afficher les métriques d'utilisation des GPU de vos charges de travail, vous devez accéder au tableau de bord Charges de travail dans la console Google Cloud.

Pour afficher l'utilisation des GPU des charges de travail, procédez comme suit :

  1. Accédez à la page Charges de travail dans la console Google Cloud.

    Accéder à la page Charges de travail
  2. Sélectionner une charge de travail

Le tableau de bord "Charges de travail" affiche les graphiques sur l'utilisation et la capacité de la mémoire des GPU, ainsi que leur cycle de travail.

Étapes suivantes