Exécuter des GPU dans des pools de nœuds GKE Standard

Cette page vous explique comment utiliser les accélérateurs matériels de GPU NVIDIA® dans les nœuds de vos clusters Google Kubernetes Engine (GKE). Pour en savoir plus sur les GPU dans GKE, consultez la page À propos des GPU dans GKE.

Vous pouvez également utiliser des GPU directement dans vos pods Autopilot. Pour obtenir des instructions, consultez la section Déployer des charges de travail GPU dans Autopilot.

Présentation

GKE vous permet de créer des pools de nœuds équipés de GPU NVIDIA Tesla® K80, P100, P4, V100, T4, L4 et A100. Les GPU fournissent une puissance de calcul permettant de mener des tâches de deep learning telles que la reconnaissance d'images ou le traitement du langage naturel, ainsi que d'autres tâches gourmandes en ressources de calcul, telles que le transcodage de vidéos et le traitement d'images.

Vous pouvez également utiliser des GPU avec des VM Spot si vos charges de travail peuvent tolérer les perturbations fréquentes des nœuds. L'utilisation de VM préemptives réduit le coût de l'exécution des GPU. Pour en savoir plus, consultez la page Utiliser des VM Spot avec des pools de nœuds GPU.

Depuis la version 1.29.2-gke.1108000, vous pouvez désormais créer des pools de nœuds GPU sur GKE Sandbox. Pour en savoir plus, consultez les pages GKE Sandbox et Configuration de GKE Sandbox.

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.

Conditions requises

Les exigences des GPU sur GKE sont les suivantes :

  • Version de Kubernetes : pour les pools de nœuds utilisant l'image de nœud Container-Optimized OS, les nœuds GPU sont disponibles dans GKE version 1.9 ou ultérieure. Pour les pools de nœuds utilisant l'image de nœud Ubuntu, les nœuds GPU sont disponibles dans GKE version 1.11.3 ou ultérieure.

  • Quota de GPU : pour pouvoir créer des nœuds GPU, vous devez disposer d'un quota de GPU Compute Engine dans la zone sélectionnée. Pour vous assurer que vous disposez d'un quota de GPU suffisant dans votre projet, consultez la page Quotas dans la console Google Cloud.

    En cas de besoin, vous devez demander un quota de GPU supplémentaire dans la console Google Cloud. Si vous disposez d'un compte de facturation établi, ce quota sera automatiquement attribué à votre projet après l'envoi de la demande de quota.

  • Pilotes de GPU NVIDIA : lorsque vous créez un cluster ou un pool de nœuds, vous pouvez demander à GKE d'installer automatiquement une version des pilotes en fonction de la version de GKE que vous utilisez. Si vous ne indiquez pas à GKE d'installer automatiquement les pilotes de GPU, vous devez installer manuellement les pilotes.

  • GPU A100 : les GPU A100 ne sont compatibles qu'avec les types de machines a2 et nécessitent GKE 1.18.6-gke.3504 ou une version ultérieure. Vous devez vous assurer de disposer d'un quota suffisant pour que le type de machine A2 sous-jacent utilise le GPU A100.

  • GPU L4 :

    • Vous devez utiliser GKE version 1.22.17-gke.5400 ou ultérieure.
    • La version de GKE que vous choisissez doit inclure le pilote NVIDIA version 525 ou ultérieure dans Container-Optimized OS. Si la version 525 ou ultérieure n'est pas la version par défaut ou la dernière version dans votre version de GKE, vous devez installer manuellement un pilote compatible sur vos nœuds.

Limites

Avant d'utiliser des GPU sur GKE, gardez à l'esprit les limites suivantes :

  • Vous ne pouvez pas ajouter de GPU à des pools de nœuds existants.
  • Les nœuds GPU ne peuvent pas être migrés à chaud lors d'événements de maintenance.

  • Le type de GPU que vous pouvez utiliser dépend de la série de machines, comme suit :

    Vous devez vous assurer de disposer d'un quota suffisant dans votre projet pour la série de machines correspondant au type et à la quantité de GPU que vous avez sélectionnés.

  • Les GPU ne sont pas compatibles avec les pools de nœuds Windows Server.

  • Les clusters GKE Standard exécutant la version 1.28.2-gke.1098000 ou une version antérieure ne sont pas compatibles avec le provisionnement automatique des nœuds qui créent des pools de nœuds avec des GPU L4. Toutefois, les clusters exécutant des versions antérieures sont compatibles avec le scaling de l'autoscaler de cluster pour les pools de nœuds existants.

  • Pour utiliser des GPU H100 afin d'utiliser des disques SSD locaux pour le stockage des pods, vous devez spécifier explicitement le nombre exact de disques SSD locaux à associer à la VM A3 sous-jacente en utilisant --ephemeral-storage-local-ssd=count=SSD_COUNT pour le stockage éphémère ou l'option --local-nvme-ssd-block=count=SSD_COUNT pour l'accès au stockage en mode bloc. Si vous omettez cette option, vous ne pourrez pas utiliser les disques SSD locaux dans vos pods. Ces options ne sont requises que si vous souhaitez utiliser un disque SSD local pour accéder aux données.

    La taille de machine acceptée dans GKE est de a3-highgpu-8g, et le nombre de disques SSD locaux correspondants est de 16.

Qui peut en bénéficier ?

Les GPU sont disponibles dans des régions et zones spécifiques. Lorsque vous demandez un quota de GPU, prenez en compte les régions dans lesquelles vous souhaitez exécuter les clusters.

Pour obtenir la liste complète des régions et des zones concernées, consultez la page GPU sur Compute Engine.

Vous pouvez également consulter les GPU disponibles dans votre zone à l'aide de Google Cloud CLI. Pour afficher la liste de tous les types d'accélérateurs GPU acceptés dans chaque zone, exécutez la commande suivante :

gcloud compute accelerator-types list

Tarifs

Pour obtenir plus d'informations sur les tarifs des GPU, consultez la grille tarifaire sur la page "GPU" de Google Cloud.

Quota de GPU

Votre quota de GPU est le nombre total de GPU pouvant s'exécuter dans votre projet Google Cloud. Pour créer des clusters avec des GPU, votre projet doit posséder un quota suffisant de GPU.

Votre quota de GPU doit être au moins équivalent au nombre total de GPU que vous avez l'intention d'exécuter dans le cluster. Si vous activez l'autoscaling de cluster, vous devez demander un quota de GPU au moins équivalent au nombre maximal de nœuds du cluster, multiplié par le nombre de GPU par nœud.

Par exemple, si vous créez un cluster de trois nœuds exécutant chacun deux GPU, votre projet nécessite un quota minimal de six GPU.

Demander un quota de GPU

Pour demander un quota de GPU, accédez à la console Google Cloud. Pour plus d'informations sur la demande de quotas, consultez la section Quotas de GPU dans la documentation Compute Engine.

Pour rechercher un quota de GPU et envoyer une demande de quota, utilisez la console Google Cloud :

  1. Accédez à la page des Quotas IAM et administration dans la console Google Cloud.

    Accéder à la section "Quotas"

  2. Dans la zone Filtre, procédez comme suit :

    1. Sélectionnez la propriété Quota, saisissez le nom du modèle de GPU, puis appuyez sur Entrée.
    2. (Facultatif) Pour appliquer des filtres plus avancés afin d'affiner les résultats, sélectionnez la propriété Dimensions (par exemple, lieux), ajoutez le nom de la région ou de la zone que vous utilisez, puis appuyez sur Entrée.

  3. Dans la liste des quotas de GPU, sélectionnez le quota que vous souhaitez modifier.

  4. Cliquez sur Modifier les quotas. Un formulaire de demande s'affiche.

  5. Renseignez le champ Nouvelle limite de quota pour chaque demande de quota.

  6. Renseignez le champ Description de la demande en indiquant des informations sur votre demande.

  7. Cliquez sur Next (Suivant).

  8. Dans la boîte de dialogue de Confirmation du remplacement, cliquez sur Confirmer.

  9. Sur l'écran Coordonnées, saisissez votre nom et un numéro de téléphone que les approbateurs pourront utiliser pour traiter votre demande de modification de quota.

  10. Cliquez sur Envoyer la requête.

  11. Vous recevez un e-mail de confirmation pour suivre la modification des quotas.

Exécuter des GPU

Pour exécuter des GPU dans des clusters GKE Standard, créez un pool de nœuds auquel sont associés des GPU. Lorsque vous ajoutez un pool de nœuds GPU à un cluster existant qui exécute déjà un pool de nœuds non GPU, GKE rejette automatiquement les nœuds GPU en leur attribuant le rejet de nœud suivant :

  • Clé : nvidia.com/gpu
  • Effet : NoSchedule

En outre, par l'exécution du contrôleur d'admission ExtendedResourceToleration, GKE applique automatiquement les tolérances correspondantes aux pods qui demandent des GPU.

Ainsi, seuls les pods qui demandent des GPU sont planifiés sur les nœuds GPU, ce qui permet un autoscaling plus efficace : les nœuds GPU peuvent évoluer rapidement à la baisse si le nombre de pods demandant des GPU est insuffisant.

Pour améliorer la rentabilité, la fiabilité et la disponibilité des GPU sur GKE, nous vous recommandons d'effectuer les actions suivantes :

  • Créez des pools de nœuds GPU distincts. Pour chaque pool de nœuds, limitez l'emplacement des nœuds aux zones dans lesquelles les GPU sont disponibles.
  • Activez l'autoscaling dans chaque pool de nœuds.
  • Utilisez des clusters régionaux pour améliorer la disponibilité en répliquant le plan de contrôle Kubernetes sur plusieurs zones de la région.
  • Demandez à GKE d'installer automatiquement les pilotes de GPU par défaut ou les plus récents sur les pools de nœuds pour ne pas avoir à installer et gérer manuellement vos versions de pilotes.

Créer un pool de nœuds GPU

Pour créer un pool de nœuds GPU distinct dans un cluster existant, vous pouvez utiliser la console Google Cloud ou Google Cloud CLI. Vous pouvez également utiliser Terraform pour provisionner vos clusters GKE et votre pool de nœuds GPU.

Vous pouvez demander à GKE d'installer automatiquement la version par défaut ou la dernière version du pilote NVIDIA correspondant à votre version de Container-Optimized OS.

gcloud

Pour créer un pool de nœuds comportant des GPU dans un cluster, exécutez la commande suivante :

gcloud container node-pools create POOL_NAME \
  --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
  [--machine-type MACHINE_TYPE] \
  --region COMPUTE_REGION --cluster CLUSTER_NAME \
  --node-locations COMPUTE_ZONE1[,COMPUTE_ZONE2] \
  [--enable-autoscaling \
   --min-nodes MIN_NODES \
   --max-nodes MAX_NODES] \
  [--ephemeral-storage-local-ssd=count=SSD_COUNT]

Remplacez les éléments suivants :

  • POOL_NAME : nom que vous avez choisi pour le pool de nœuds.
  • GPU_TYPE : type de GPU. Les possibilités suivantes s'offrent à vous :
    • nvidia-tesla-k80
    • nvidia-tesla-p100
    • nvidia-tesla-p4
    • nvidia-tesla-v100
    • nvidia-tesla-t4
    • nvidia-tesla-a100
    • nvidia-a100-80gb
    • nvidia-l4
    • nvidia-h100-80gb

  • DRIVER_VERSION : version du pilote NVIDIA à installer. Les possibilités suivantes s'offrent à vous :

    • 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 pool de nœuds. Si vous omettez la commande gpu-driver-version, cette option est celle configurée par défaut.

  • AMOUNT : nombre de GPU à associer aux nœuds du pool de nœuds.

  • MACHINE_TYPE : type de machine Compute Engine pour les nœuds. Obligatoire pour les types de GPU suivants :

    Pour tous les autres GPU, cette option est facultative.

  • COMPUTE_REGION : région Compute Engine du cluster, telle que us-central1. Choisissez une région qui comporte au moins une zone dans laquelle les GPU demandés sont disponibles.

  • CLUSTER_NAME : nom du cluster dans lequel créer le pool de nœuds.

  • COMPUTE_ZONE1,COMPUTE_ZONE2,[...] : zones spécifiques dans lesquelles GKE crée les nœuds GPU. Ces zones doivent se trouver dans la même région que le cluster, spécifiée par l'option --region. Les types de GPU que vous définissez doivent être disponibles dans chaque zone sélectionnée. Nous vous recommandons de toujours utiliser l'option --node-locations lors de la création du pool de nœuds pour spécifier la ou les zones contenant les GPU demandés.

  • MIN_NODES : nombre minimal de nœuds pour chaque zone du pool de nœuds à tout moment. Cette valeur n'est pertinente que si l'option --enable-autoscaling est utilisée.

  • MAX_NODES : nombre maximal de nœuds pour chaque zone du pool de nœuds à tout moment. Cette valeur n'est pertinente que si l'option --enable-autoscaling est utilisée.

  • SSD_COUNT : nombre de disques SSD locaux à associer au stockage éphémère. Cette option est requise pour utiliser des disques SSD locaux dans des types de machines A3 avec des GPU H100.

Par exemple, la commande suivante crée un pool de nœuds avec autoscaling à disponibilité élevée, p100, doté de deux GPU P100 pour chaque nœud, dans le cluster régional p100-cluster. GKE installe automatiquement les pilotes par défaut sur ces nœuds.

gcloud container node-pools create p100 \
  --accelerator type=nvidia-tesla-p100,count=2,gpu-driver-version=default \
  --region us-central1 --cluster p100-cluster \
  --node-locations us-central1-c \
  --min-nodes 0 --max-nodes 5 --enable-autoscaling

Console

Pour créer un pool de nœuds comportant des GPU, procédez comme suit :

  1. Accédez à la page Google Kubernetes Engine dans Google Cloud Console.

    Accéder à Google Kubernetes Engine

  2. Dans la liste des clusters, cliquez sur le nom du cluster que vous souhaitez modifier.

  3. Cliquez sur Ajouter un pool de nœuds.

  4. Si vous le souhaitez, sur la page Détails du pool de nœuds, cochez la case Activer l'autoscaling.

  5. Configurez le pool de nœuds comme vous le souhaitez.

  6. Dans le volet de navigation, sélectionnez Nœuds.

  7. Sous Configuration de la machine, cliquez sur GPU.

  8. Sélectionnez un Type de GPU et un Nombre de GPU pour les exécuter sur chaque nœud.

  9. Lisez l'avertissement, puis sélectionnez Je comprends les restrictions.

  10. Dans la section Installation du pilote de GPU, sélectionnez l'une des méthodes suivantes :

    • Gérée par Google : GKE installe automatiquement un pilote. Si vous sélectionnez cette option, choisissez l'une des options suivantes dans la liste déroulante Version :
      • Par défaut : installe la version par défaut du pilote.
      • Dernière version : installe la dernière version disponible du pilote.
    • Gérée par le client : GKE n'installe pas de pilote. Vous devez installer manuellement un pilote compatible en suivant les instructions de la section Installer des pilotes d'appareils GPU NVIDIA.

  11. Cliquez sur Créer.

Terraform

Vous pouvez créer un cluster régional utilisant des GPU avec Terraform grâce à un module Terraform.

  1. Définissez les variables Terraform en incluant le bloc suivant dans le fichier variables.tf :

    variable "project_id" {
  default     = PROJECT_ID
  description = "the gcp_name_short project where GKE creates the cluster"
}

variable "region" {
  default     = CLUSTER_REGION
  description = "the gcp_name_short region where GKE creates the cluster"
}

variable "zone" {
  default     = "COMPUTE_ZONE1,COMPUTE_ZONE2"
  description = "the GPU nodes zone"
}

variable "cluster_name" {
  default     = "CLUSTER_NAME"
  description = "the name of the cluster"
}

variable "gpu_type" {
  default     = "GPU_TYPE"
  description = "the GPU accelerator type"
}

variable "gpu_driver_version" {
  default = "DRIVER_VERSION"
  description = "the NVIDIA driver version to install"
}

variable "machine_type" {
  default = "MACHINE_TYPE"
  description = "The Compute Engine machine type for the VM"
}

    Remplacez les éléments suivants :

    • PROJECT_ID : ID de votre projet.
    • CLUSTER_NAME : nom du cluster GKE.
    • CLUSTER_REGION : région de calcul du cluster.
    • COMPUTE_ZONE1,COMPUTE_ZONE2,[...] : zones spécifiques dans lesquelles GKE crée les nœuds GPU. Ces zones doivent se trouver dans la même région que celle spécifiée par la variable region. Ces zones doivent avoir les types de GPU que vous avez définis. Pour identifier les zones qui possèdent des GPU, consultez la section Disponibilité. Vous devez utiliser la variable node_locations lors de la création du pool de nœuds GPU pour spécifier la ou les zones contenant les GPU demandés.

    • GPU_TYPE : type de GPU. Les possibilités suivantes s'offrent à vous :

      • nvidia-tesla-k80
      • nvidia-tesla-p100
      • nvidia-tesla-p4
      • nvidia-tesla-v100
      • nvidia-tesla-t4
      • nvidia-tesla-a100
      • nvidia-a100-80gb
      • nvidia-l4
      • nvidia-h100-80gb

    • DRIVER_VERSION : version du pilote de GPU que GKE doit installer automatiquement. Ce champ est facultatif. Les valeurs suivantes sont acceptées :

      • INSTALLATION_DISABLED : désactive l'installation automatique du pilote de GPU. Vous devez installer manuellement les pilotes pour exécuter vos GPU.
      • DEFAULT : installe automatiquement la version de pilote par défaut pour votre version de système d'exploitation de nœud.
      • LATEST : installe automatiquement la dernière version de pilote disponible pour votre version de système d'exploitation de nœud.

    Si vous omettez ce champ, GKE n'installe pas de pilote automatiquement. Ce champ n'est pas disponible dans les pools de nœuds qui utilisent le provisionnement automatique des nœuds. Pour installer manuellement un pilote, consultez la section Installer manuellement des pilotes de GPU NVIDIA dans ce document. MACHINE_TYPE : type de machine Compute Engine pour les nœuds. Obligatoire pour les types de GPU suivants :

    Pour tous les autres GPU, cette option est facultative.

  2. Ajoutez le bloc suivant à votre configuration Terraform :

    provider "google" {
  project = var.project_id
  region  = var.region
}

resource "google_container_cluster" "ml_cluster" {
  name     = var.cluster_name
  location = var.region
  node_locations = [var.zone]
}

resource "google_container_node_pool" "gpu_pool" {
  name       = google_container_cluster.ml_cluster.name
  location   = var.region
  cluster    = google_container_cluster.ml_cluster.name
  node_count = 3

  autoscaling {
    total_min_node_count = "1"
    total_max_node_count = "5"
  }

  management {
    auto_repair  = "true"
    auto_upgrade = "true"
  }

  node_config {
    oauth_scopes = [
      "https://www.googleapis.com/auth/logging.write",
      "https://www.googleapis.com/auth/monitoring",
      "https://www.googleapis.com/auth/devstorage.read_only",
      "https://www.googleapis.com/auth/trace.append",
      "https://www.googleapis.com/auth/service.management.readonly",
      "https://www.googleapis.com/auth/servicecontrol",
    ]

    labels = {
      env = var.project_id
    }

    guest_accelerator {
      type  = var.gpu_type
      count = 1
      gpu_driver_installation_config {
        gpu_driver_version = var.gpu_driver_version
      }
    }

    image_type   = "cos_containerd"
    machine_type = var.machine_type
    tags         = ["gke-node", "${var.project_id}-gke"]

    disk_size_gb = "30"
    disk_type    = "pd-standard"

    metadata = {
      disable-legacy-endpoints = "true"
    }
  }
}

Terraform appelle les API Google Cloud pour définir la création d'un cluster avec un pool de nœuds utilisant des GPU. Le pool de nœuds dispose initialement de trois nœuds et l'autoscaling est activé. Pour en savoir plus sur Terraform, consultez la spécification de la ressource google_container_node_pool.

Vous pouvez également créer un cluster avec des GPU et spécifier des zones à l'aide de l'option --node-locations. Toutefois, nous vous recommandons de créer un pool de nœuds GPU distinct dans un cluster existant, comme indiqué dans cette section.

Installer manuellement des pilotes de GPU NVIDIA

Si vous avez choisi de désactiver l'installation automatique du pilote d'appareils lorsque vous avez créé un pool de nœuds GPU, ou si vous utilisez une version de GKE antérieure à la version minimale compatible pour l'installation automatique, vous devez installer manuellement un pilote de GPU NVIDIA compatible sur les nœuds. Google fournit une interface DaemonSet que vous pouvez appliquer pour installer les pilotes. Sur les nœuds GPU qui utilisent Container-Optimized OS, vous avez également la possibilité de choisir entre la version par défaut du pilote de GPU et une version plus récente.

Nous vous recommandons d'utiliser si possible l'installation automatique du pilote, en spécifiant l'option gpu-driver-version dans l'option --accelerator lorsque vous créez votre cluster standard. Si vous avez utilisé le DaemonSet d'installation pour installer manuellement les pilotes de GPU au plus tard le 25 janvier 2023, vous devrez peut-être le réappliquer pour obtenir une version qui ignore les nœuds utilisant l'installation automatique du pilote.

Les instructions suivantes vous expliquent comment installer les pilotes sur des nœuds Container-Optimized OS (COS) et Ubuntu, et comment utiliser Terraform.

COS

Pour déployer l'interface d'installation DaemonSet et installer la version du pilote de GPU par défaut, exécutez la commande suivante :

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

Sinon, pour installer la version la plus récente du pilote de GPU (voir le tableau ci-dessous), exécutez la commande suivante :

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded-latest.yaml

L'installation prend quelques secondes. Une fois installé, le plug-in d'appareils GPU NVIDIA indique la capacité des GPU NVIDIA via les API Kubernetes.

Chaque version de l'image Container-Optimized OS possède au moins une version compatible du pilote de GPU NVIDIA. Consultez les notes de version des principaux jalons LTS de Container-Optimized OS pour la version par défaut compatible.

Le tableau suivant répertorie les versions de pilotes disponibles dans chaque version de GKE :

Version de GKE Pilote NVIDIA
1.26 R470 (par défaut), R510 or R525
1,25 R470 (par défaut), R510 or R525
1.24 R470 (par défaut), R510 or R525
1.23 R450 (par défaut), R470, R510, or R525
1.22 R450 (par défaut), R470, R510, or R525
1.21 R450 (par défaut), R470 ou R510
1.20 R450 (par défaut), R470

Ubuntu

Pour déployer l'interface DaemonSet d'installation pour tous les GPU à l'exception des GPU NVIDIA L4, exécutez la commande suivante :

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/ubuntu/daemonset-preloaded.yaml

L'installation prend quelques secondes. Une fois installé, le plug-in d'appareils GPU NVIDIA indique la capacité des GPU NVIDIA via les API Kubernetes.

Pour les GPU NVIDIA L4, installez le pilote R525 à l'aide de la commande suivante :

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/ubuntu/daemonset-preloaded-R525.yaml

Le tableau suivant répertorie les versions de pilotes disponibles dans chaque version de GKE :

Version de GKE Pilote NVIDIA
1.27 R470
1.26 R470
1,25 R470
1.24 R470
1.23 R470
1.22 R450
1.21 R450
1.20 R450

Terraform

Vous pouvez utiliser Terraform pour installer la version par défaut du pilote de GPU en fonction du type de nœuds. Dans les deux cas, vous devez configurer le type de ressource Terraform kubectl_manifest.

  • Pour installer le DaemonSet sur COS, ajoutez le bloc suivant à votre configuration Terraform :

      data "http" "nvidia_driver_installer_manifest" {
    url = "https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml"
  }

  resource "kubectl_manifest" "nvidia_driver_installer" {
    yaml_body = data.http.nvidia_driver_installer_manifest.body
  }

  • Pour installer DaemonSet sur Ubuntu, ajoutez le bloc suivant à votre configuration Terraform :

      data "http" "nvidia_driver_installer_manifest" {
    url = "https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/ubuntu/daemonset-preloaded.yaml"
  }

  resource "kubectl_manifest" "nvidia_driver_installer" {
    yaml_body = data.http.nvidia_driver_installer_manifest.body
  }

Utiliser le provisionnement automatique des nœuds avec des GPU

Lorsque vous utilisez le provisionnement automatique des nœuds avec des GPU, les pools de nœuds provisionnés automatiquement par défaut ne disposent pas de champs d'application suffisants pour installer les pilotes. Pour accorder les champs d'application requis, modifiez les champs d'application par défaut pour le provisionnement automatique des nœuds afin d'ajouter logging.write, monitoring, devstorage.read_only et compute, comme dans l'exemple suivant.

gcloud container clusters update CLUSTER_NAME --enable-autoprovisioning \
    --min-cpu=1 --max-cpu=10 --min-memory=1 --max-memory=32 \
    --autoprovisioning-scopes=https://www.googleapis.com/auth/logging.write,https://www.googleapis.com/auth/monitoring,https://www.googleapis.com/auth/devstorage.read_only,https://www.googleapis.com/auth/compute

Dans GKE version 1.29.2-gke.1108000 et ultérieure, vous pouvez sélectionner une version du pilote de GPU que GKE doit installer automatiquement dans les nœuds GPU provisionnés automatiquement. Ajoutez le champ 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.

Pour en savoir plus sur le provisionnement automatique, consultez la page Utiliser le provisionnement automatique des nœuds.

Configurer des pods pour qu'ils utilisent des GPU

Vous devez appliquer une limite de ressources pour configurer des pods afin qu'ils utilisent des GPU. Vous devez définir une limite de ressources dans une spécification de pod à l'aide de la paire clé/valeur suivante :

  • Clé : nvidia.com/gpu
  • Valeur : nombre de GPU à utiliser

Vous trouverez ci-dessous un exemple de spécification de pod utilisant des GPU :

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  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: 2

Utiliser plusieurs types de GPU

Si vous souhaitez utiliser plusieurs types d'accélérateurs GPU par cluster, vous devez créer plusieurs pools de nœuds, chacun avec son propre type d'accélérateur. GKE associe un sélecteur unique aux nœuds GPU pour faciliter le placement des charges de travail GPU sur les nœuds ayant des types de GPU spécifiques :

  • Clé : cloud.google.com/gke-accelerator
  • Valeur : nvidia-tesla-k80, nvidia-tesla-p100, nvidia-tesla-p4, nvidia-tesla-v100, nvidia-tesla-t4, nvidia-tesla-a100, nvidia-a100-80gb, nvidia-h100-80gb ou nvidia-l4.

Vous pouvez cibler certains types de GPU en ajoutant le sélecteur de nœud suivant à la spécification de pod de la charge de travail. Exemple :

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  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: 2
  nodeSelector:
    cloud.google.com/gke-accelerator: nvidia-tesla-k80

Mettre à niveau les pools de nœuds à l'aide d'accélérateurs (GPU et TPU)

GKE met automatiquement à niveau les clusters standards, y compris les pools de nœuds. Vous pouvez également mettre à jour manuellement les pools de nœuds si vous souhaitez que vos nœuds passent plus rapidement à la nouvelle version. Pour contrôler le fonctionnement des mises à niveau de votre cluster, utilisez les versions disponibles, les intervalles et exclusions de maintenance et le séquençage du déploiement.

Vous pouvez également configurer une stratégie de mise à niveau des nœuds pour votre pool de nœuds, telle que des mises à niveau de la surutilisation ou des mises à niveau bleu-vert. En configurant ces stratégies, vous pouvez vous assurer que les pools de nœuds sont mis à niveau de manière à atteindre l'équilibre optimal entre vitesse et perturbation de votre environnement. Pour les pools de nœuds de tranches TPU multi-hôtes, au lieu d'utiliser la stratégie de mise à niveau des nœuds configurée, GKE recrée de manière atomique l'ensemble du pool de nœuds en une seule étape. Pour en savoir plus, consultez la définition de l'atomicité dans la terminologie liée aux TPU dans GKE.

L'utilisation d'une stratégie de mise à niveau de nœuds nécessite temporairement que GKE provisionne des ressources supplémentaires en fonction de la configuration. Si Google Cloud dispose d'une capacité limitée pour les ressources de votre pool de nœuds, par exemple, si des erreurs de disponibilité des ressources s'affichent lorsque vous essayez de créer d'autres nœuds avec des GPU ou des TPU, consultez la section Effectuer une mise à niveau dans un environnement à ressources limitées.

À propos des bibliothèques NVIDIA CUDA-X

CUDA est la plate-forme informatique parallèle et le modèle de programmation NVIDIA pour les GPU. Pour utiliser des applications CUDA, l'image que vous utilisez doit disposer des bibliothèques. Pour ajouter les bibliothèques NVIDIA CUDA-X, utilisez l'une des méthodes suivantes :

  • Recommandé : Utilisez une image sur laquelle les bibliothèques NVIDIA CUDA-X sont préinstallées. Vous pouvez par exemple utiliser des Conteneurs de deep learning. Ces conteneurs préinstallent les principaux frameworks de data science, les bibliothèques NVIDIA CUDA-X et les outils. L'image NVIDIA CUDA ne contient que les bibliothèques NVIDIA CUDA-X.
  • Créez et utilisez votre propre image. Dans ce cas, incluez les valeurs suivantes dans la variable d'environnement LD_LIBRARY_PATH dans la spécification de votre conteneur :
    1. /usr/local/cuda-CUDA_VERSION/lib64 : emplacement des bibliothèques NVIDIA CUDA-X sur le nœud. Remplacez CUDA_VERSION par la version d'image CUDA-X que vous avez utilisée. Certaines versions contiennent également des utilitaires de débogage dans /usr/local/nvidia/bin. Pour en savoir plus, consultez la page image NVIDIA CUDA sur DockerHub.
    2. /usr/local/nvidia/lib64 : emplacement des pilotes d'appareils NVIDIA.

Pour vérifier la version minimale du pilote de GPU requise pour votre version de CUDA, consultez les versions de pilote compatibles avec CUDA Toolkit. Assurez-vous que la version du correctif GKE exécutée sur vos nœuds inclut une version du pilote de GPU compatible avec la version CUDA choisie. Pour obtenir la liste des versions de pilotes de GPU associées à la version de GKE, consultez la page "Container-Optimized OS" correspondante indiquée dans le tableau des versions actuelles de GKE.

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.

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 standards, vous devez installer les pilotes NVIDIA. Pour les clusters Autopilot, GKE installe les pilotes.

Pour obtenir des instructions sur le déploiement de DCGM et de l'exportateur DCGM de Prometheus, consultez la page NVIDIA Data Center GPU Manager (DCGM) dans la documentation sur l'observabilité de Google Cloud.

Configurer l'arrêt optimal des nœuds avec GPU

Dans les clusters GKE avec le plan de contrôle exécutant la version 1.29.1-gke.1425000 ou ultérieure, les nœuds GPU acceptent les signaux SIGTERM qui avertissent le nœud d'un arrêt imminent. La notification d'arrêt imminent est configurable jusqu'à 60 minutes dans les nœuds GPU.

Vous pouvez configurer GKE pour qu'il arrête correctement vos charges de travail dans ce délai de notification. Dans le fichier manifeste de votre pod, définissez le champ spec.terminationGracePeriodSeconds sur une valeur maximale de 60 minutes (3600 secondes). Par exemple, pour obtenir une heure de notification de 10 minutes, dans le fichier manifeste de votre pod, définissez le champ spec.terminationGracePeriodSeconds sur 600 secondes comme suit:

  spec:
    terminationGracePeriodSeconds: 600

GKE fait de son mieux pour arrêter ces pods correctement et exécuter l'action d'arrêt que vous avez définie, par exemple en enregistrant un état d'entraînement.

Étapes suivantes