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

Cette page vous explique comment exécuter et optimiser vos charges de travail exigeantes en calcul, telles que l'intelligence artificielle (IA) et le traitement graphique, en associant et en utilisant des accélérateurs matériels de GPU NVIDIA® dans les nœuds de vos clusters Google Kubernetes Engine (GKE) Standard.

Si vous utilisez des pods Autopilot, consultez 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. 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. Dans le mode Standard, vous pouvez associer le matériel GPU aux nœuds de vos clusters, puis allouer des ressources GPU à des charges de travail conteneurisées s'exécutant sur ces nœuds.

Pour en savoir plus sur les cas d'utilisation des GPU, consultez la page GPU de Google Cloud. Pour en savoir plus sur les GPU dans GKE et les différences entre le mode standard et le mode Autopilot, consultez À propos des GPU dans GKE.

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 pour les GPU sur GKE

Les exigences des GPU sur GKE sont les suivantes :

  • Version de Kubernetes : les versions disponibles dépendent de l'image de nœud utilisée par les GPU :

  • 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 est automatiquement attribué à votre projet après l'envoi de la demande de quota.

    Par défaut, les comptes d'essai gratuits ne reçoivent pas de quota de GPU.

  • 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. Vous devez vous assurer de disposer d'un quota suffisant pour que le type de machine A2 sous-jacent utilise le GPU A100.

  • GPU sur des nœuds Ubuntu : si vous utilisez des GPU avec des nœuds Ubuntu, les exigences suivantes s'appliquent aux pilotes.

  • GPU L4 et GPU H100 : pilote NVIDIA version 535 ou ultérieure.

  • GPU H200: pilote NVIDIA version 550 ou ultérieure.

    Si une version de pilote requise ou une version ultérieure n'est pas la version par défaut dans votre version de GKE, vous devez installer manuellement un pilote compatible sur vos nœuds.

Bonne pratique :

Utilisez Container-Optimized OS pour les nœuds GPU. Container-Optimized OS inclut les pilotes requis pour prendre en charge la version spécifique de GKE pour les nœuds GPU.

Limites d'utilisation des GPU sur GKE

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 antérieure ne sont pas compatibles avec le provisionnement automatique des nœuds permettant de créer des pools de nœuds avec des GPU L4. Toutefois, les clusters exécutant des versions antérieures sont compatibles avec l'autoscaler de cluster pour le scaling des pools de nœuds existants.

Disponibilité des GPU par région et par zone

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 en savoir plus sur les tarifs des GPU, consultez la grille tarifaire sur la page Google Cloud GPU.

Veiller à disposer d'un quota de GPU suffisant

Votre quota de GPU est le nombre total de GPU pouvant s'exécuter dans votre projetGoogle 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 de GPU par nœud multiplié par le nombre maximal de nœuds de votre cluster.

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 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 dans des clusters GKE Standard

Pour exécuter des GPU dans des clusters GKE Standard, créez un pool de nœuds auquel sont associés des GPU.

Bonne pratique:

Pour améliorer la rentabilité, la fiabilité et la disponibilité des GPU sur GKE, procédez comme suit :

  • 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.
  • Configurez GKE pour qu'il installe automatiquement les pilotes de GPU par défaut ou les plus récents sur les pools de nœuds, afin que vous n'ayez pas à installer ni à gérer manuellement les versions de vos pilotes.

Comme décrit dans les sections suivantes, GKE utilise des rejets et des tolérances de nœuds pour s'assurer que les pods ne sont pas planifiés sur des nœuds inappropriés.

Rejeter automatiquement un pool de nœuds GPU pour éviter de le planifier de manière inappropriée

Un rejet de nœud vous permet de marquer un nœud afin que le programmeur l'ignore ou empêche son utilisation pour certains pods. 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

GKE n'ajoute ce rejet que si un pool de nœuds non GPU existe dans le cluster. Si vous ajoutez un pool de nœuds GPU à un cluster dans lequel tous les pools de nœuds existants sont des pools de nœuds GPU, ou si vous créez un cluster dans lequel des GPU sont associés au pool de nœuds par défaut, le rejet ci-dessus n'est pas ajouté aux nœuds GPU.

Si vous ajoutez ultérieurement un pool de nœuds non GPU au cluster, GKE n'applique pas rétroactivement ce rejet aux nœuds GPU existants.

Limiter automatiquement la planification avec une tolérance

Les tolérances vous permettent de désigner les pods pouvant être utilisés sur des nœuds rejetés. GKE applique automatiquement une tolérance afin que seuls les pods demandant des GPU soient planifiés sur des nœuds GPU. Ainsi, l'autoscaling est plus efficace, car vos nœuds GPU peuvent rapidement évoluer à la baisse si le nombre de pods demandant des GPU est insuffisant. Pour ce faire, GKE exécute le contrôleur d'admission ExtendedResourceToleration.

Créer un pool de nœuds GPU

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

Dans le plan de contrôle GKE 1.30.1-gke.1156000 ou version ultérieure, GKE installe automatiquement la version de pilote NVIDIA par défaut pour la version de votre nœud GKE si le provisionnement automatique des nœuds n'est pas activé. Vous pouvez éventuellement choisir la dernière version de pilote disponible ou désactiver explicitement l'installation automatique des pilotes. Dans les versions antérieures à 1.30.1-gke.1156000, GKE n'installe pas de pilote par défaut si vous ne spécifiez pas de version de pilote lorsque vous créez ou mettez à jour le pool de nœuds.

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] \
  [--scopes=SCOPES] \
  [--service-account=SERVICE_ACCOUNT]

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 utilisez. Par exemple, nvidia-tesla-t4.

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

    • default : installe la version par défaut du pilote pour la version de GKE de vos nœuds. Dans GKE 1.30.1-gke.1156000 et versions ultérieures, si vous omettez l'option gpu-driver-version, il s'agit de l'option par défaut. Dans les versions antérieures, GKE n'installe pas de pilote si vous omettez cette option.
    • 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. Dans les versions de GKE antérieures à la version 1.30.1-gke.1156000, il s'agit de l'option par défaut.

    L'option gpu-driver-version n'est disponible que pour GKE 1.27.2-gke.1200 et versions ultérieures. Dans les versions antérieures, omettez cette option et installez manuellement un pilote après avoir créé le pool de nœuds. Si vous mettez à niveau un cluster ou un pool de nœuds existant vers cette version ou une version ultérieure, GKE installe automatiquement la version du pilote par défaut correspondant à la version de GKE, sauf si vous spécifiez une valeur différente lorsque vous démarrez la mise à niveau.

  • 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 :

    • GPU NVIDIA H200 141 Go (correspondant au type d'accélérateur nvidia-h200-141gb et au type de machine A3 Ultra) ou GPU NVIDIA H100 80 Go (correspondant au type d'accélérateur nvidia-h100-80gb et au type de machine A3 High) ou GPU NVIDIA H100 80 Go Mega (correspondant au type d'accélérateur nvidia-h100-mega-80gb et au type de machine A3 Mega). Pour en savoir plus, consultez la série de machines A3 dans la documentation Compute Engine.
    • GPU NVIDIA A100 40 Go (correspondant au type d'accélérateur nvidia-tesla-a100 et au type de machine A2 Standard) ou GPU NVIDIA A100 80 Go (correspondant au type d'accélérateur nvidia-a100-80gb et au type de machine A2 Ultra). Pour en savoir plus, consultez Série de machines A2 dans la documentation Compute Engine.
    • GPU NVIDIA L4 (correspondant au type d'accélérateur nvidia-l4 et à la série de machines G2).

    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.

    Vous pouvez également créer le pool de nœuds GPU à l'aide d'un compte de service personnalisé en ajoutant les options suivantes. Si cette valeur est omise, le pool de nœuds utilise le compte de service Compute Engine par défaut:

    • SERVICE_ACCOUNT: nom du compte de service IAM utilisé par vos nœuds.
    • SCOPES: liste des champs d'accès à accorder, séparés par une virgule. Assurez-vous que l'un des champs d'application est storage-ro ou https://www.googleapis.com/auth/devstorage.read_only. Pour en savoir plus sur les portées, consultez Définir des portées d'accès. Si vous omettez l'indicateur scope, la création du pool de nœuds GPU échoue avec l'erreur AccessDenied Échec du téléchargement de gpu_driver_versions.bin à partir du bucket GCS.

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 votre 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 d'accélérateur GPU que vous utilisez. Par exemple, nvidia-tesla-t4.

    • 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. Dans les versions de GKE antérieures à la version 1.30.1-gke.1156000, il s'agit de l'option par défaut si vous omettez ce champ.
      • DEFAULT : installe automatiquement la version de pilote par défaut pour votre version de système d'exploitation de nœud. Dans GKE 1.30.1-gke.1156000 et versions ultérieures, si vous omettez ce champ, il s'agit de l'option par défaut. Dans les versions antérieures, GKE n'installe pas de pilote si vous omettez ce champ.
      • LATEST : installe automatiquement la dernière version de pilote disponible pour votre version de système d'exploitation de nœud. Disponible seulement pour les nœuds qui utilisent Container-Optimized OS.

      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 :

      • GPU NVIDIA H200 141 Go (correspondant au type d'accélérateur nvidia-h200-141gb et au type de machine A3 Ultra) ou GPU NVIDIA H100 80 Go (correspondant au type d'accélérateur nvidia-h100-80gb et au type de machine A3 High) ou GPU NVIDIA H100 80 Go Mega (correspondant au type d'accélérateur nvidia-h100-mega-80gb et au type de machine A3 Mega). Pour en savoir plus, consultez la série de machines A3 dans la documentation Compute Engine.
      • GPU NVIDIA A100 40 Go (correspondant au type d'accélérateur nvidia-tesla-a100 et au type de machine A2 Standard) ou GPU NVIDIA A100 80 Go (correspondant au type d'accélérateur nvidia-a100-80gb et au type de machine A2 Ultra). Pour en savoir plus, consultez Série de machines A2 dans la documentation Compute Engine.
      • GPU NVIDIA L4 (correspondant au type d'accélérateur nvidia-l4 et à la série de machines G2).

      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 ressource google_container_node_pool sur terraform.io.

Bonne pratique:

Pour éviter des frais supplémentaires, supprimez toutes les ressources définies dans le fichier de configuration à l'aide de la commande terraform destroy.

Bonne pratique : 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 GPU NVIDIA

Vous pouvez installer manuellement des pilotes GPU NVIDIA sur vos nœuds en déployant un DaemonSet d'installation sur ces nœuds. Utilisez l'installation manuelle dans les situations suivantes :

  • Vous avez choisi de désactiver l'installation automatique des pilotes de périphérique lorsque vous avez créé un pool de nœuds GPU.
  • Vous utilisez une version de GKE antérieure à la version minimale compatible pour l'installation automatique.
  • Votre charge de travail nécessite une version spécifique du pilote NVIDIA qui n'est pas disponible par défaut ou le pilote le plus récent avec installation automatique.
Bonne pratique :

Utilisez l'installation automatique des pilotes dans la mesure du possible. Pour ce faire, spécifiez 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.

Pour exécuter le DaemonSet d'installation, le pool de nœuds GPU nécessite le champ d'application https://www.googleapis.com/auth/devstorage.read_only pour communiquer avec Cloud Storage. Sans ce champ d'application, le téléchargement du fichier manifeste du DaemonSet d'installation échoue. Ce champ d'application est l'un des champs d'application par défaut qui sont généralement ajoutés lors de la création d'un cluster.

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 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 des appareils GPU NVIDIA utilise l'API Kubernetes pour rendre la capacité du GPU NVIDIA disponible.

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 :

Versions du pilote NVIDIA de GKE
1,30 R535 (par défaut) ou R550
1,29 R535 (par défaut) ou R550
1.28 R535 (par défaut) ou R550
1.27 R470 (par défaut), R525, R535, or R550
1,26 R470 (par défaut), R525, R535, or R550

Ubuntu

Le DaemonSet d'installation que vous déployez dépend du type de GPU et de la version du nœud GKE, comme suit :

  • Pour tous les GPU à l'exception des GPU NVIDIA L4, NVIDIA H100 et NVIDIA H200, exécutez la commande suivante:

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

  • Pour les GPU NVIDIA L4 ou H100 exécutant des versions de nœud à partir de la version 2024-R05 ou ultérieure, installez le pilote R535 :

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

  • Pour les GPU NVIDIA L4 ou H100 exécutant des versions de nœud à partir de versions antérieures à la version 2024-R05 ou ultérieure, installez le pilote R525 :

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

  • Pour les GPU NVIDIA H200, installez le pilote R550:

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

L'installation prend quelques secondes. Une fois installé, le plug-in des appareils GPU NVIDIA utilise l'API Kubernetes pour rendre la capacité du GPU NVIDIA disponible.

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

Pilotes GPU Ubuntu et versions de GKE
1,30 R470 ou R535
1,29 R470 ou R535
1.28 R470 ou R535
1.27 R470 ou R535
1,26 R470 ou R535

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
  }

Installer des pilotes à l'aide du 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.
  • 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

alpha.kubernetes.io/nvidia-gpu n'est pas accepté comme nom de ressource dans GKE. Utilisez plutôt nvidia.com/gpu.

Le fichier manifeste suivant est 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 : type d'accélérateur GPU que vous utilisez. Par exemple, nvidia-tesla-t4.

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-t4

Mettre à niveau des 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 à trouver l'équilibre optimal entre la vitesse et les interruptions pour 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 section Terminologie relative au TPU dans GKE.

L'utilisation d'une stratégie de mise à niveau des nœuds nécessite temporairement que GKE provisionne des ressources supplémentaires, en fonction de la configuration. Si Google Cloudpossède 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, vous pouvez créer et utiliser votre propre image en incluant les valeurs suivantes dans la variable d'environnement LD_LIBRARY_PATH de la spécification de votre conteneur :

  • /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.

    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.

  • /usr/local/nvidia/lib64 : emplacement des pilotes d'appareils NVIDIA.
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 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.

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

Dans les clusters GKE dont le plan de contrôle exécute 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 peut être configurée jusqu'à 60 minutes dans les nœuds GPU.

Pour configurer GKE afin qu'il arrête correctement vos charges de travail dans ce délai de notification, suivez la procédure décrite dans la section Gérer les interruptions des nœuds GKE pour les GPU et les TPU.

Étape suivante