Exécuter des GPU multi-instances

Cette page explique comment partitionner un GPU NVIDIA A100 ou H100 pour partager un seul GPU sur plusieurs conteneurs sur Google Kubernetes Engine (GKE).

Dans cette page, nous partons du principe que vous maîtrisez les concepts de Kubernetes tels que les Pods, les nœuds, les déploiements et les espaces de noms, et que vous connaissez les concepts de GKE tels que les pools de nœuds, l'autoscaling et le provisionnement automatique.

Introduction

Kubernetes attribue un GPU complet par conteneur même si le conteneur n'a besoin que d'une fraction du GPU pour sa charge de travail, ce qui peut entraîner une perte de ressources et un coût excessif, en particulier si vous utilisez la dernière génération de puissants GPU. Pour améliorer l'utilisation des GPU, les GPU multi-instances vous permettent de partitionner un seul GPU compatible et de créer jusqu'à sept tranches. Chaque tranche peut être allouée à un conteneur du nœud de manière indépendante, pour un maximum de sept conteneurs par GPU. Les GPU multi-instances fournissent une isolation matérielle entre les charges de travail, et des QoS cohérents et prévisibles pour tous les conteneurs exécutés sur le GPU.

Pour les applications CUDA, les GPU multi-instances présentent généralement une grande transparence. Chaque partition de GPU apparaît comme une ressource GPU standard et le modèle de programmation reste inchangé.

Pour en savoir plus sur les GPU multi-instances, consultez le guide de l'utilisateur sur les GPU multi-instance NVIDIA.

GPU compatibles

Les types de GPU suivants sont compatibles avec les GPU multi-instances :

  • NVIDIA A100 (40 Go)
  • NVIDIA A100 (80 Go)

  • NVIDIA H100 (80 Go)

Partitions de GPU multi-instances

Le GPU A100 et le GPU H100 se composent de sept unités de calcul et de huit unités de mémoire, qui peuvent être partitionnées en instances de GPU de différentes tailles. Les tailles de partition des GPU utilisent la syntaxe suivante : [compute]g.[memory]gb. Par exemple, une taille de partition de GPU de 1g.5gb fait référence à une instance GPU dotée d'une unité de calcul (1/7e de flux multiprocesseurs sur le GPU) et d'une unité de mémoire (5 Go). La taille de partition des GPU peut être spécifiée lorsque vous déployez une charge de travail Autopilot ou lorsque vous créez un cluster standard.

La table de partitionnement du guide de l'utilisateur sur les GPU multi-instances NVIDIA répertorie toutes les différentes tailles de partitions de GPU, ainsi que la quantité de ressources de calcul et de mémoire disponibles sur chaque partition de GPU. Le tableau indique également le nombre d'instances de GPU pour chaque taille de partition pouvant être créée sur le GPU.

Le tableau suivant répertorie les tailles de partition compatibles avec GKE :

Taille de la partition Instances de GPU
GPU : NVIDIA A100 (40 Go) (nvidia-tesla-a100)
1g.5gb 7
2g.10gb 3
3g.20gb 2
7g.40gb 1
GPU : NVIDIA A100 (80 Go) (nvidia-a100-80gb)
1g.10gb 7
2g.20gb 3
3g.40gb 2
7g.80gb 1
GPU : NVIDIA H100 (80 Go) (nvidia-h100-80gb)
1g.10gb 7
1g.20gb 4
2g.20gb 3
3g.40gb 2
7g.80gb 1

Chaque GPU sur chaque nœud d'un pool est partitionné de la même manière. Par exemple, considérons un pool de nœuds avec deux nœuds, quatre GPU sur chaque nœud et une taille de partition de 1g.5gb. GKE crée sept partitions de taille 1g.5gb sur chaque GPU. Étant donné qu'il y a quatre GPU sur chaque nœud, il y aura 28 partitions de GPU 1g.5gb disponibles sur chaque nœud. Étant donné qu'il y a deux nœuds dans le pool de nœuds, un total de 56 partitions de GPU 1g.5gb sont disponibles dans l'ensemble du pool de nœuds.

Pour créer un cluster GKE Standard avec plusieurs types de partitions de GPU, vous devez créer plusieurs pools de nœuds. Par exemple, si vous souhaitez que les nœuds possèdent des partitions de GPU 1g.5gb et 3g.20gb dans un cluster, vous devez créer deux pools de nœuds, l'un avec une taille de partition de GPU définie sur 1g.5gb, et l'autre avec 3g.20gb.

Un cluster GKE Autopilot crée automatiquement des nœuds avec la configuration de partition appropriée lorsque vous créez des charges de travail nécessitant des tailles de partition différentes.

Chaque nœud comporte un libellé avec la taille des partitions de GPU disponibles sur le nœud. Cette attribution de libellé permet aux charges de travail de cibler les nœuds avec la taille de partition de GPU nécessaire. Par exemple, sur un nœud doté d'instances de GPU 1g.5gb, le nœud présente le libellé suivant :

cloud.google.com/gke-gpu-partition-size=1g.5gb

Fonctionnement

Pour utiliser des GPU multi-instances, vous devez effectuer les tâches suivantes :

  1. Créer un cluster avec les GPU multi-instances activés.
  2. Installer manuellement des pilotes.
  3. Vérifier le nombre de ressources GPU disponibles sur le nœud.
  4. Déployer des conteneurs à l'aide de GPU multi-instances.

Tarification

Les GPU multi-instances sont exclusifs aux GPU A100 et H100 et sont soumis à la tarification des GPU correspondants, en plus des autres produits permettant d'exécuter vos charges de travail. Vous ne pouvez associer que des GPU entiers aux nœuds de votre cluster pour le partitionnement. Pour en savoir plus sur les tarifs des GPU, consultez la page Tarifs des GPU.

Limites

  • L'utilisation de partitions de GPU multi-instances avec GKE n'est pas recommandée pour les charges de travail non approuvées.
  • L'autoscaling et le provisionnement automatique des partitions GPU sont entièrement compatibles avec GKE version 1.20.7-gke.400 ou ultérieure. Dans les versions antérieures, seuls les pools de nœuds avec au moins un nœud peuvent faire l'objet d'un autoscaling en fonction des tailles de partition de GPU spécifiques dont ont besoin les charges de travail.
  • Les métriques d'utilisation du GPU (par exemple, duty_cycle) ne sont pas disponibles pour les instances de GPU.
  • Le mode multi-instance divise un GPU physique en instances distinctes, chacune étant isolées des autres au niveau matériel. Un conteneur qui utilise une instance de GPU multi-instance ne peut accéder qu'aux ressources de processeur et de mémoire disponibles pour cette instance.
  • Un pod ne peut consommer qu'une seule instance de GPU multi-instance.

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.
  • En mode Autopilot, les GPU multi-instances sont compatibles avec GKE versions 1.29.3-gke.1093000 et ultérieures.
  • Vous devez disposer d'un quota de GPU NVIDIA A100 suffisant. Consultez la section Demander une augmentation de quota.
  • Si vous souhaitez utiliser des GPU multi-instances avec Autopilot, consultez la page Déployer des charges de travail GPU dans Autopilot pour en savoir plus.
  • GKE attribue la classe de calcul Accelerator à toutes les charges de travail GPU multi-instances dans les clusters Autopilot.

Créer un cluster avec les GPU multi-instances activés

Si vous utilisez GKE Standard, vous devez activer les GPU multi-instances dans le cluster. Les clusters Autopilot qui exécutent la version 1.29.3-gke.1093000 ou une version ultérieure activent les GPU multi-instances par défaut. Pour utiliser des GPU multi-instances dans Autopilot, consultez la section Déployer des conteneurs à l'aide de GPU multi-instance dans ce document.

Lorsque vous créez un cluster Standard avec des GPU multi-instances, vous devez spécifier gpuPartitionSize avec acceleratorType et acceleratorCount. La valeur de acceleratorType doit être nvidia-tesla-a100, nvidia-a100-80gb ou nvidia-h100-80gb.

L'exemple suivant montre comment créer un cluster GKE avec un nœud, et sept partitions de GPU de taille 1g.5gb sur le nœud. Les autres étapes de cette page utilisent une taille de partition de GPU de 1g.5gb, ce qui crée sept partitions sur chaque GPU. Vous pouvez également utiliser l'une des tailles de partition de GPU compatibles mentionnées précédemment.

Vous pouvez utiliser la Google Cloud CLI ou Terraform.

gcloud

Créez un cluster avec les GPU multi-instances activés :

gcloud container clusters create CLUSTER_NAME  \
    --project=PROJECT_ID  \
    --zone ZONE  \
    --cluster-version=CLUSTER_VERSION  \
    --accelerator type=nvidia-tesla-a100,count=1,gpu-partition-size=1g.5gb,gpu-driver-version=DRIVER_VERSION  \
    --machine-type=a2-highgpu-1g  \
    --num-nodes=1

Remplacez les éléments suivants :

  • CLUSTER_NAME : nom de votre nouveau cluster
  • PROJECT_ID : ID de votre projet Google Cloud
  • ZONE : zone de calcul du plan de contrôle du cluster.
  • CLUSTER_VERSION : la version doit être 1.19.7-gke.2503 ou ultérieure.
  • DRIVER_VERSION : version du pilote NVIDIA à installer. La valeur peut être l'une des suivantes :
    • default : installe la version de pilote par défaut pour votre version de GKE.
    • latest : installe la dernière version de pilote disponible pour votre version de GKE. Disponible seulement pour les nœuds qui utilisent Container-Optimized OS.
    • disabled : passe l'installation automatique du pilote. Vous devez installer manuellement un pilote après avoir créé le cluster. Si vous omettez la commande gpu-driver-version, cette option est celle configurée par défaut.

Terraform

Pour créer un cluster avec des GPU multi-instances activés à l'aide de Terraform, reportez-vous à l'exemple suivant :

resource "google_container_cluster" "default" {
  name               = "gke-standard-zonal-gpu"
  location           = "us-central1-a"
  initial_node_count = 1

  node_config {
    guest_accelerator {
      type  = "nvidia-tesla-t4"
      count = 1
      gpu_driver_installation_config {
        gpu_driver_version = "LATEST"
      }
    }
    machine_type = "n1-standard-2"
  }

  # Set `deletion_protection` to `true` will ensure that one cannot
  # accidentally delete this instance by use of Terraform.
  deletion_protection = false
}

Pour en savoir plus sur l'utilisation de Terraform, consultez la page Compatibilité de Terraform avec GKE.

Se connecter au cluster

Configurez kubectl pour vous connecter au cluster nouvellement créé :

gcloud container clusters get-credentials CLUSTER_NAME

Installer les pilotes

Si vous avez choisi de désactiver l'installation automatique du pilote lors de la création du cluster ou si vous exécutez une version de GKE antérieure à la version 1.27.2-gke.1200, vous devez installer manuellement un pilote NVIDIA compatible une fois la création terminée. Les GPU multi-instances nécessitent un pilote NVIDIA version 450.80.02 ou ultérieure.

Une fois le pilote installé, le mode GPU multi-instance sera activé. Si vous avez installé automatiquement des pilotes, vos nœuds redémarrent lorsque le plug-in de l'appareil GPU commence à créer des partitions de GPU. Si vous avez installé manuellement les pilotes, vos nœuds redémarrent une fois l'installation du pilote terminée. Le redémarrage peut prendre quelques minutes.

Vérifier le nombre de ressources GPU disponibles sur le nœud

Exécutez la commande suivante pour vérifier que la capacité et le nombre allouables des ressources nvidia.com/gpu sont de 7 :

kubectl describe nodes

Voici la sortie de la commande :

...
Capacity:
  ...
  nvidia.com/gpu:             7
Allocatable:
  ...
  nvidia.com/gpu:             7

Déployer des conteneurs à l'aide de GPU multi-instances

Vous pouvez déployer jusqu'à un conteneur par appareil GPU multi-instance sur le nœud. Dans cet exemple, avec une taille de partition de 1g.5gb, sept partitions de GPU multi-instances sont disponibles sur le nœud. Par conséquent, vous pouvez déployer jusqu'à sept conteneurs qui demandent des GPU sur ce nœud.

  1. Voici un exemple simple qui démarre le conteneur cuda:11.0.3-base-ubi7 et exécute nvidia-smi pour imprimer l'UUID du GPU dans le conteneur. Dans cet exemple, il y a sept conteneurs, et chaque conteneur reçoit une partition GPU. Cet exemple définit également le sélecteur de nœuds cloud.google.com/gke-gpu-partition-size pour cibler les nœuds avec des partitions de GPU 1g.5gb.

    Autopilot

          cat <<EOF | kubectl apply -f -
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: cuda-simple
      spec:
        replicas: 7
        selector:
          matchLabels:
            app: cuda-simple
        template:
          metadata:
            labels:
              app: cuda-simple
          spec:
            nodeSelector:
              cloud.google.com/gke-gpu-partition-size: 1g.5gb
              cloud.google.com/gke-accelerator: nvidia-tesla-a100
              cloud.google.com/gke-accelerator-count: "1"
            containers:
            - name: cuda-simple
              image: nvidia/cuda:11.0.3-base-ubi7
              command:
              - bash
              - -c
              - |
                /usr/local/nvidia/bin/nvidia-smi -L; sleep 300
              resources:
                limits:
                  nvidia.com/gpu: 1
      EOF

    Ce fichier manifeste effectue les opérations suivantes :

    • Demande le type de GPU nvidia-tesla-a100 en définissant le sélecteur de nœud cloud.google.com/gke-accelerator.
    • Divise le GPU en taille de partition 1g.5gb.
    • Associe un seul GPU au nœud en définissant le sélecteur de nœud cloud.google.com/gke-accelerator-count.

    Standard

          cat <<EOF | kubectl apply -f -
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: cuda-simple
      spec:
        replicas: 7
        selector:
          matchLabels:
            app: cuda-simple
        template:
          metadata:
            labels:
              app: cuda-simple
          spec:
            nodeSelector:
              cloud.google.com/gke-gpu-partition-size: 1g.5gb
            containers:
            - name: cuda-simple
              image: nvidia/cuda:11.0.3-base-ubi7
              command:
              - bash
              - -c
              - |
                /usr/local/nvidia/bin/nvidia-smi -L; sleep 300
              resources:
                limits:
                  nvidia.com/gpu: 1
      EOF

    Ce fichier manifeste effectue les opérations suivantes :

    • Demande un seul GPU avec une taille de partition de 1g.5gb.

  2. Vérifiez que les sept pods sont en cours d'exécution :

    kubectl get pods

    Voici la sortie de la commande :

    NAME                           READY   STATUS    RESTARTS   AGE
cuda-simple-849c47f6f6-4twr2   1/1     Running   0          7s
cuda-simple-849c47f6f6-8cjrb   1/1     Running   0          7s
cuda-simple-849c47f6f6-cfp2s   1/1     Running   0          7s
cuda-simple-849c47f6f6-dts6g   1/1     Running   0          7s
cuda-simple-849c47f6f6-fk2bs   1/1     Running   0          7s
cuda-simple-849c47f6f6-kcv52   1/1     Running   0          7s
cuda-simple-849c47f6f6-pjljc   1/1     Running   0          7s

  3. Affichez les journaux pour voir l'UUID du GPU en utilisant le nom de n'importe quel pod de la commande précédente :

    kubectl logs cuda-simple-849c47f6f6-4twr2

    Voici la sortie de la commande :

    GPU 0: A100-SXM4-40GB (UUID: GPU-45eafa61-be49-c331-f8a2-282736687ab1)
  MIG 1g.5gb Device 0: (UUID: MIG-GPU-45eafa61-be49-c331-f8a2-282736687ab1/11/0)

Étape suivante