Déployer des charges de travail GPU dans Autopilot

Cette page explique comment demander des GPU pour accélérer les tâches dans vos charges de travail Autopilot Google Kubernetes Engine (GKE). Cette page décrit également comment Autopilot exécute des GPU, comment votre modèle de tarification change en fonction de votre version de GKE, comment définir des demandes et des limites de ressources de pod, et comment surveiller les charges de travail GPU.

Cette page s'adresse aux administrateurs et opérateurs de la plate-forme, ainsi qu'aux spécialistes des données et de l'IA qui souhaitent demander des GPU pour des charges de travail qui exécutent des tâches telles que l'entraînement ou l'inférence du machine learning (ML). Pour en savoir plus sur les rôles, responsabilités et exemples de tâches courants que nous citons dans le contenu Google Cloud , consultez la section Rôles utilisateur et tâches courantes de l'utilisateur dans GKE Enterprise.

Avant de continuer, assurez-vous de connaître les concepts suivants:

Sélectionner des accélérateurs dans Pods

Autopilot utilise 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). Pour utiliser cette classe dans une charge de travail GPU, effectuez l'une des actions suivantes en fonction de votre version de GKE:

  • Version 1.29.4-gke.1427000 et versions ultérieures: demandez des GPU dans votre fichier manifeste de charge de travail. Vous pouvez également utiliser des fonctionnalités de partage de GPU, comme le temps partagé. GKE ne modifie pas vos fichiers manifestes de charge de travail pour ajouter un sélecteur de nœuds ou une annotation pour la classe Accelerator.
  • Version 1.29 jusqu'à la version 1.29.4-gke.142700 (non incluse): spécifiez le sélecteur de nœud cloud.google.com/compute-class: Accelerator dans le fichier manifeste de votre pod et demandez des GPU. Si vous spécifiez ce sélecteur de nœuds, vous pouvez également utiliser des fonctionnalités de partage de GPU, comme le temps partagé.
  • Version 1.28.9-gke.1069000 jusqu'à la version 1.29 (non incluse): spécifiez le sélecteur de nœud cloud.google.com/compute-class: Accelerator dans le fichier manifeste de votre pod, ainsi que les sélecteurs de GPU. Si vous spécifiez ce sélecteur de nœuds, vous pouvez également utiliser les fonctionnalités de partage de GPU, comme le temps partagé.

La classe de calcul Accelerator n'est pas compatible avec les versions antérieures à 1.28.9-gke.1069000. À la place, GKE traite les pods GPU sur ces versions de la même manière que les autres pods Autopilot, et vous êtes facturé pour les demandes de ressources. Pour en savoir plus, reportez-vous à la section Tarification.

Compatibilité de l'accélérateur avec les fonctionnalités de GKE

Le tableau suivant présente les fonctionnalités GKE compatibles pour chaque méthode de sélection des accélérateurs dans GKE Autopilot:

Classe de calcul Accelerator sélectionnée Compatibilité avec les fonctionnalités de GKE

Tarifs

Le tableau suivant décrit comment le modèle de facturation utilisé par GKE dépend de la version GKE de votre cluster. Pour en savoir plus sur les modèles de facturation de GKE Autopilot, consultez la section Tarifs du mode Autopilot.

Version de GKE Tarifs
1.29.4-gke.1427000 et versions ultérieures

Modèle de facturation basé sur les nœuds. Tous les pods GPU utilisent la classe de calcul Accelerator. 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é des nœuds. Pour en savoir plus, consultez la section Tarifs du mode Autopilot.
De la version 1.29 à la version 1.29.4-gke.1427000 (non incluse)

Le modèle de facturation dépend des sélecteurs de nœuds que vous spécifiez, comme suit:

  • cloud.google.com/compute-class: Accelerator: utilise le modèle de facturation basé sur les nœuds et la classe de calcul de Accelerator.
  • Aucun sélecteur de classe de calcul: utilise le modèle de facturation basé sur les pods.

Vous ne pouvez utiliser des fonctionnalités telles que les GPU multi-instances ou le temps partagé que si vous spécifiez explicitement le sélecteur de nœuds cloud.google.com/compute-class: Accelerator.

Pour en savoir plus, consultez la section "Pods avec des exigences matérielles spécifiques" dans la section Tarifs de Kubernetes Engine.
De la version 1.28.6-gke.1095000 jusqu'à la version 1.29 (non incluse)

Modèle de facturation basé sur les nœuds, que vous spécifiiez ou non la classe de calcul Accelerator dans vos fichiers manifestes de pod.

Vous ne pouvez utiliser des fonctionnalités telles que les GPU multi-instances ou le temps partagé que si vous spécifiez explicitement le sélecteur de nœuds cloud.google.com/compute-class: Accelerator.

Pour en savoir plus, consultez la section "Pods avec des exigences matérielles spécifiques" dans la section Tarifs de Kubernetes Engine.
Versions antérieures à 1.28.6-gke.1095000

Modèle de facturation basé sur les pods. Vous êtes facturé en fonction des demandes de ressources des pods GPU. Pour en savoir plus, consultez la section "Pods avec des exigences matérielles spécifiques" dans la section Tarifs de Kubernetes Engine.

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 H200 (141 Go) : 1.31.4-gke.1183000 ou version ultérieure (RDMA non compatible)
      • GPU NVIDIA H100 Mega (80 Go) : 1.28.9-gke.1250000 ou version ultérieure et 1.29.4-gke.1542000 ou version ultérieure
      • 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

  • 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 dans GKE version 1.29.3-gke.1093000 et ultérieure.
  • La disponibilité des GPU dépend de la région de votre cluster Autopilot et de votre quota de GPU. Google Cloud 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 le sélecteur cloud.google.com/gke-accelerator-count.

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  nodeSelector:
    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-h200-141gb: NVIDIA H200 (141 Go)
    • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80 Go)
    • nvidia-h100-80gb: NVIDIA H100 (80 Go)
    • 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é.

Pour en savoir plus sur la facturation de l'utilisation de l'accélérateur en mode Autopilot, consultez la section Tarifs.

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.

Demander des ressources de processeur et de mémoire 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/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.

Demander un 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 versions ultérieures 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 des GPU déployés

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 --selector=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

Remplacez IMAGE_PATH par le chemin d'accès à l'image du conteneur.

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. Il peut s'agir de l'un des éléments suivants:

  • nvidia-h200-141gb: NVIDIA H200 (141 Go)
  • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80 Go)
  • nvidia-h100-80gb: NVIDIA H100 (80 Go)
  • 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		 1, 2, 4, 8
NVIDIA H100 Mega (80 Go)
nvidia-h100-mega-80gb		 8
NVIDIA H200 (141 Go)
nvidia-h200-141gb		 8

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

Surveiller les performances des charges de travail de vos 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.

Afficher les métriques du gestionnaire de GPU NVIDIA Data Center (DCGM)

Vous pouvez collecter et visualiser des métriques NVIDIA DCGM à l'aide de Google Cloud Managed Service pour Prometheus. Pour les clusters Autopilot, GKE installe les pilotes. Pour les clusters standards, vous devez installer les pilotes NVIDIA.

Pour savoir comment déployer le package DCGM géré par GKE, consultez Collecter et afficher les métriques du gestionnaire GPU de centre de données (DCGM) NVIDIA.

Étape suivante