Créer un cluster GKE personnalisé optimisé pour l'IA qui utilise A4 ou A3 Ultra

Cette page vous explique comment créer un cluster Google Kubernetes Engine (GKE) optimisé pour l'IA qui utilise des machines virtuelles (VM) A4 ou A3 Ultra pour prendre en charge vos charges de travail d'IA et de ML. Pour A4X, consultez Créer un cluster GKE personnalisé optimisé pour l'IA qui utilise A4X.

Les séries de machines A4 et A3 Ultra sont conçues pour vous permettre d'exécuter des clusters d'IA/de ML à grande échelle avec des fonctionnalités telles que le placement ciblé des charges de travail, des contrôles avancés de maintenance des clusters et la planification tenant compte de la topologie. Pour en savoir plus, consultez la présentation de la gestion des clusters.

GKE fournit une plate-forme unique pour exécuter un ensemble varié de charges de travail pour vos organisations, ce qui réduit la charge opérationnelle liée à la gestion de plusieurs plates-formes. Vous pouvez exécuter des charges de travail telles que le pré-entraînement distribué hautes performances, l'affinage de modèles, l'inférence de modèles, la diffusion d'applications et les services associés.

Sur cette page, vous allez apprendre à créer un cluster GKE avec Google Cloud CLI pour configurer votre cluster de manière aussi flexible que possible en fonction des besoins de votre charge de travail. Vous pouvez également choisir d'utiliser Cluster Toolkit pour déployer rapidement votre cluster avec des paramètres par défaut qui reflètent les bonnes pratiques pour de nombreux cas d'utilisation. Pour savoir comment procéder, consultez Créer un cluster GKE optimisé pour l'IA avec la configuration par défaut.

Options de configuration de cluster avec GPUDirect RDMA

Pour créer votre cluster avec Google Cloud CLI, vous pouvez choisir l'une des options de configuration de cluster suivantes :

  • Si vous ne prévoyez pas d'exécuter de charges de travail d'IA distribuées : créez un cluster GKE sans utiliser GPUDirect RDMA.
  • Si vous prévoyez d'exécuter des charges de travail d'IA distribuées : créez un cluster GKE avec GPUDirect RDMA.

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 la Google Cloud CLI pour cette tâche, installez et initialisez la gcloud CLI. Si vous avez déjà installé la gcloud CLI, obtenez la dernière version en exécutant la commande gcloud components update. Il est possible que les versions antérieures de la gcloud CLI ne permettent pas d'exécuter les commandes de ce document.

Rôles requis

Pour obtenir les autorisations nécessaires pour créer et gérer un cluster GKE, demandez à votre administrateur de vous accorder les rôles IAM suivants sur le projet :

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises avec des rôles personnalisés ou d'autres rôles prédéfinis.

Choisir une option de consommation et obtenir de la capacité

  1. Sélectionnez une option de consommation. Faites votre choix en fonction de la manière dont vous souhaitez obtenir et utiliser les ressources GPU. Pour en savoir plus, consultez Choisir une option de consommation.

    Pour GKE, tenez compte des informations supplémentaires suivantes lorsque vous choisissez une option de consommation :

  2. Obtenez de la capacité. Découvrez comment obtenir de la capacité pour votre option de consommation.

Conditions requises

Les exigences suivantes s'appliquent à un cluster GKE optimisé par l'IA :

  • Pour utiliser le modèle de provisionnement Démarrage flexible, vous devez utiliser GKE version 1.32.2-gke.1652000 ou ultérieure.

  • Assurez-vous d'utiliser la version minimale du pilote de GPU, en fonction du type de machine :

    • A4 : les GPU B200 des VM A4 nécessitent au minimum la version R570 du pilote GPU. Par défaut, GKE installe automatiquement cette version du pilote sur tous les nœuds A4 qui exécutent la version minimale requise pour A4, à savoir 1.32.1-gke.1729000 ou version ultérieure.
    • A3 Ultra : les GPU H200 des VM A3 Ultra nécessitent au minimum la version R550 du pilote de GPU, qui est disponible dans la version 1.31 de GKE en tant que version du pilote latest. Pour les VM A3 Ultra, vous devez définir la valeur du champ gpu-driver-version=latest avec la version 1.31 de GKE. Pour GKE version 1.31.5-gke.1169000 ou ultérieure, GKE installe automatiquement les versions de pilote GPU R550 sur les nœuds A3 Ultra par défaut, y compris lorsque vous omettez l'indicateur gpu-driver-version.

  • Pour utiliser GPUDirect RDMA, les exigences supplémentaires suivantes s'appliquent :

    • Utilisez les versions minimales suivantes, en fonction du type de machine :
      • A4 : utilisez la version 1.32.2-gke.1475000 ou ultérieure.
      • A3 Ultra : utilisez la version 1.31.4-gke.1183000 ou ultérieure.
    • Les nœuds GKE doivent utiliser une image de nœud Container-Optimized OS. Les images de nœuds Ubuntu et Windows ne sont pas acceptées.
    • Votre charge de travail GKE doit utiliser tous les GPU disponibles, et votre pod doit utiliser toutes les cartes d'interface réseau (NIC) secondaires disponibles sur un seul nœud GKE. Plusieurs pods ne peuvent pas partager RDMA sur un même nœud GKE.
    • Cette configuration exécute un test NCCL. Pour exécuter ce test NCCL, vous devez disposer d'un quota de VM minimal de 2 (soit 16 GPU si vous utilisez les types de machines a4-highgpu-8g ou a3-ultragpu-8g).
    • GPUDirect RDMA n'est pas compatible avec NCCL Fast Socket ni avec GPUDirect-TCPX/TCPXO. N'activez pas NCCL Fast Socket et n'installez pas le plug-in TCPX/TCPXO sur les clusters qui utilisent GPUDirect RDMA.

  • Assurez-vous d'utiliser un emplacement où le type de machine que vous choisissez est disponible. Pour en savoir plus, consultez Emplacements des GPU.

Créer un cluster GKE optimisé pour l'IA

Suivez les instructions de cette section pour créer un cluster GKE qui répond aux exigences des clusters GKE optimisés pour l'IA. Vous pouvez choisir de créer un cluster avec ou sans GPUDirect RDMA.

Éléments à prendre en compte pour créer un cluster

Lorsque vous créez un cluster, tenez compte des informations suivantes :

  • Choisissez l'emplacement d'un cluster :
    • Assurez-vous d'utiliser un emplacement où le type de machine que vous choisissez est disponible. Pour en savoir plus, consultez Emplacements des GPU.
    • Pour les réservations denses, vous pouvez créer un cluster zonal. Dans ce cas, remplacez l'indicateur --region par l'indicateur --zone=COMPUTE_ZONE, où COMPUTE_ZONE correspond à la zone de votre plan de contrôle.
    • Pour les charges de travail qui s'exécutent sur plus de 1 000 nœuds et qui nécessitent une faible latence réseau entre les nœuds, vous pouvez créer un cluster régional. Pour colocaliser physiquement vos nœuds sensibles aux performances, créez vos pools de nœuds GPU dans une seule zone à l'aide de l'indicateur --node-locations.
  • Choisissez une version du pilote :
    • La version du pilote peut être l'une des valeurs suivantes :
      • default : installe la version de pilote par défaut pour la version de nœud GKE. Pour en savoir plus sur les exigences concernant les versions de pilote par défaut, consultez la section Exigences.
      • latest : installe la dernière version de pilote disponible pour votre version de GKE. Cette option n'est disponible que pour les nœuds qui utilisent Container-Optimized OS.
      • disabled : ignorer l'installation automatique du pilote. Vous devez installer manuellement un pilote après avoir créé le pool de nœuds.
    • Pour en savoir plus sur les versions de pilote de GPU par défaut et les plus récentes pour les versions de nœud GKE, consultez Installer manuellement des pilotes de GPU NVIDIA.

  • Choisir une affinité de réservation :

    • Vous pouvez trouver des informations sur votre réservation, comme son nom ou celui d'un bloc spécifique. Pour trouver ces valeurs, consultez Afficher les demandes de réservations futures.
    • L'indicateur --reservation-affinity peut prendre les valeurs specific ou any. Toutefois, pour les charges de travail d'IA distribuées à hautes performances, nous vous recommandons d'utiliser une réservation spécifique.

    • Lorsque vous utilisez une réservation spécifique, y compris les réservations partagées, spécifiez la valeur de l'indicateur --reservation au format suivant :

      projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME

      Remplacez les éléments suivants :

      • PROJECT_ID : ID de votre projet Google Cloud .
      • RESERVATION_NAME : nom de votre réservation.
      • BLOCK_NAME : nom d'un bloc spécifique dans la réservation.

Créer un cluster sans GPUDirect RDMA

Pour créer un cluster sans GPUDirect RDMA, suivez les instructions ci-dessous pour créer un cluster avec un pool de nœuds par défaut basé sur le processeur et des pools de nœuds supplémentaires avec des GPU. Cette approche permet au pool de nœuds par défaut d'exécuter d'autres services.

  1. Créez le cluster :

      gcloud container clusters create CLUSTER_NAME \
      --cluster-version=CLUSTER_VERSION \
      --region=COMPUTE_REGION

    Remplacez les éléments suivants :

    • CLUSTER_NAME : nom de votre nouveau cluster
    • CLUSTER_VERSION : version de votre nouveau cluster Pour savoir quelle version de GKE est compatible avec votre configuration, consultez la section Exigences.
    • COMPUTE_REGION : région de votre nouveau cluster. Si vous prévoyez de créer un cluster zonal, utilisez l'option --zone au lieu de l'option --region, par exemple : --zone=COMPUTE_ZONE. Remplacez COMPUTE_ZONE par la zone du plan de contrôle.

  2. Créez le pool de nœuds basé sur GPU avec l'une des commandes suivantes. La commande que vous devez exécuter dépend de l'option de consommation que vous utilisez pour votre déploiement. Sélectionnez l'onglet correspondant au modèle de provisionnement de votre option de consommation.

    Lié à la réservation

    Pour le provisionnement lié à une réservation, exécutez la commande suivante :

      gcloud container node-pools create NODE_POOL_NAME \
      --region COMPUTE_REGION --cluster CLUSTER_NAME \
      --node-locations COMPUTE_ZONE \
      --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
      --machine-type MACHINE_TYPE \
      --num-nodes=NUM_NODES \
      --reservation-affinity=specific \
      --reservation=RESERVATION_NAME/reservationBlocks/BLOCK_NAME

    Remplacez les éléments suivants :

    • NODE_POOL_NAME : nom du pool de nœuds.
    • COMPUTE_REGION : région de votre nouveau cluster.
    • CLUSTER_NAME : nom de votre nouveau cluster
    • COMPUTE_ZONE : zone de votre pool de nœuds.

    • GPU_TYPE : type d'accélérateur GPU :

      • VM A4 : saisissez nvidia-b200.
      • VM A3 Ultra : saisissez nvidia-h200-141gb.

    • AMOUNT : nombre de GPU à associer aux nœuds du pool de nœuds. Par exemple, pour les VM a4-highgpu-8g et a3-ultragpu-8g, le nombre de GPU est de 8.

    • DRIVER_VERSION : version du pilote NVIDIA à installer. Elle peut être l'une des valeurs suivantes : default, latest ou disabled.

    • MACHINE_TYPE : type de machine Compute Engine pour les nœuds. Par exemple, utilisez a4-highgpu-8g pour les VM A4 et a3-ultragpu-8g pour les VM A3 Ultra.

    • NUM_NODES : nombre de nœuds du pool de nœuds.

    • RESERVATION_NAME : nom de votre réservation. Pour trouver cette valeur, consultez Afficher les demandes de réservations futures.

    • BLOCK_NAME : nom d'un bloc spécifique dans la réservation. Pour trouver cette valeur, consultez Afficher les demandes de réservations futures.

    Démarrage flexible

    Pour le provisionnement à démarrage flexible, exécutez la commande suivante :

      gcloud container node-pools create NODE_POOL_NAME \
      --region COMPUTE_REGION --cluster CLUSTER_NAME \
      --node-locations COMPUTE_ZONE \
      --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
      --machine-type MACHINE_TYPE \
      --flex-start --enable-autoscaling --num-nodes=0 \
      --total-max-nodes TOTAL_MAX_NODES \
      --no-enable-autorepair --location-policy=ANY \
      --reservation-affinity=none [\
      --enable-queued-provisioning]

    Remplacez les éléments suivants :

    • NODE_POOL_NAME : nom du pool de nœuds.
    • COMPUTE_REGION : région de votre nouveau cluster.
    • CLUSTER_NAME : nom de votre nouveau cluster
    • COMPUTE_ZONE : zone de votre pool de nœuds.

    • GPU_TYPE : type d'accélérateur GPU :

      • VM A4 : saisissez nvidia-b200.
      • VM A3 Ultra : saisissez nvidia-h200-141gb.

    • AMOUNT : nombre de GPU à associer aux nœuds du pool de nœuds. Par exemple, pour les VM a4-highgpu-8g et a3-ultragpu-8g, le nombre de GPU est de 8.

    • DRIVER_VERSION : version du pilote NVIDIA à installer. Elle peut être l'une des valeurs suivantes : default, latest ou disabled.

    • MACHINE_TYPE : type de machine Compute Engine pour les nœuds. Par exemple, utilisez a4-highgpu-8g pour les VM A4 et a3-ultragpu-8g pour les VM A3 Ultra.

    • TOTAL_MAX_NODES : nombre maximal de nœuds pour effectuer le scaling automatique du pool de nœuds entier.

      Si vous souhaitez utiliser flex-start avec le provisionnement en file d'attente, incluez l'indicateur --enable-queued-provisioning.

      Pour en savoir plus sur l'utilisation du démarrage flexible, consultez Exécuter des charges de travail à grande échelle avec le démarrage flexible et le provisionnement en file d'attente.

    Spot

    Pour le provisionnement de spot, exécutez la commande suivante :

      gcloud container node-pools create NODE_POOL_NAME \
      --region COMPUTE_REGION --cluster CLUSTER_NAME \
      --node-locations COMPUTE_ZONE \
      --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
      --machine-type MACHINE_TYPE \
      --num-nodes=NUM_NODES \
      --spot

    Remplacez les éléments suivants :

    • NODE_POOL_NAME : nom du pool de nœuds.
    • COMPUTE_REGION : région de votre nouveau cluster.
    • CLUSTER_NAME : nom de votre nouveau cluster
    • COMPUTE_ZONE : zone de votre pool de nœuds.

    • GPU_TYPE : type d'accélérateur GPU :

      • VM A4 : saisissez nvidia-b200.
      • VM A3 Ultra : saisissez nvidia-h200-141gb.

    • AMOUNT : nombre de GPU à associer aux nœuds du pool de nœuds. Par exemple, pour les VM a4-highgpu-8g et a3-ultragpu-8g, le nombre de GPU est de 8.

    • DRIVER_VERSION : version du pilote NVIDIA à installer. Elle peut être l'une des valeurs suivantes : default, latest ou disabled.

    • MACHINE_TYPE : type de machine Compute Engine pour les nœuds. Par exemple, utilisez a4-highgpu-8g pour les VM A4 et a3-ultragpu-8g pour les VM A3 Ultra.

    • NUM_NODES : nombre de nœuds du pool de nœuds.

      Pour en savoir plus sur la création de clusters avec des VM Spot, consultez Exécuter des charges de travail tolérantes aux pannes à moindre coût avec des VM Spot.

  3. Connectez-vous à votre cluster pour pouvoir exécuter les commandes kubectl dans les sections suivantes :

      gcloud container clusters get-credentials CLUSTER_NAME --location=COMPUTE_REGION

    Remplacez les éléments suivants :

Créer un cluster avec GPUDirect RDMA

Pour les charges de travail d'IA distribuées, plusieurs nœuds GPU sont souvent associés pour fonctionner comme un seul ordinateur. Les VM A4 et A3 Ultra sont fournies avec l'adaptateur réseau Titanium ML, qui est basé sur les cartes d'interface réseau NVIDIA ConnectX-7 (CX7). Les VM A4 et A3 Ultra offrent un trafic GPU à GPU entre les nœuds de 3,2 Tbit/s sans blocage grâce à RDMA over Converged Ethernet (RoCE). RoCE permet le scaling et la collaboration sur plusieurs GPU en offrant une expérience cloud hautes performances pour les charges de travail d'IA.

Pour savoir comment créer vos clusters GKE à l'aide de la Google Cloud CLI et de GPUDirect-TCPX (VM A3 High) ou TCPXO (VM A3 Mega), consultez Maximiser la bande passante réseau des GPU dans les clusters en mode Autopilot ou Maximiser la bande passante réseau des GPU dans les clusters en mode Standard.

Pour créer vos clusters GKE en mode Autopilot ou standard avec GPUDirect RDMA, procédez comme suit (les étapes sont décrites dans les sections suivantes) :

  1. Créer des VPC et des sous-réseaux
  2. Créer le cluster GKE avec le multiréseau
  3. Créer des objets réseau GKE
  4. Installer le binaire RDMA et configurer NCCL
  5. Déployer et exécuter un test NCCL
  6. Configurer vos fichiers manifestes de pod pour GPUDirect-RDMA

Créer des VPC et des sous-réseaux

Les VM A4 et A3 Ultra présentent la configuration suivante :

  • Huit GPU NVIDIA B200 (A4) ou H200 (A3 Ultra) par machine virtuelle connectée avec NVLink
  • Deux processeurs Intel Emerald Rapids
  • Huit cartes d'interface réseau CX-7 de 400 Gbit/s pour la mise en réseau entre GPU
  • Deux cartes d'interface réseau Google Titanium de 200 Gbit/s pour les services externes

Les charges de travail d'IA et de ML, telles que l'entraînement distribué, nécessitent une accélération puissante pour optimiser les performances en réduisant les délais d'exécution des tâches. Pour les charges de travail nécessitant des performances, un débit et une latence élevés, GPUDirect RDMA réduit le nombre de sauts réseau nécessaires pour transférer des charges utiles vers et depuis les GPU, ce qui utilise plus efficacement la bande passante réseau disponible. GPUDirect RDMA est conçu pour améliorer considérablement le débit à grande échelle par rapport aux GPU qui n'utilisent pas GPUDirect.

L'une des cartes d'interface réseau Google Titanium associées au processeur utilise le réseau par défaut dans GKE. Vous n'avez pas besoin de créer un VPC pour cette carte d'interface réseau si vous disposez de suffisamment de plages d'adresses IP pour le réseau par défaut.

Vous pouvez créer un VPC pour la deuxième carte réseau Titanium (gVNIC) du processeur et un autre VPC pour les huit cartes réseau RDMA CX-7 à l'aide de ces commandes.

  1. Définissez les variables d'environnement pour qu'elles correspondent à votre déploiement :

    export REGION="COMPUTE_REGION"
export ZONE="COMPUTE_ZONE"
export PROJECT="PROJECT_ID"
export GVNIC_NETWORK_PREFIX="GVNIC_NETWORK_PREFIX"
export RDMA_NETWORK_PREFIX="RDMA_NETWORK_PREFIX"

    Remplacez les variables suivantes :

    • COMPUTE_REGION : région de votre cluster.
    • COMPUTE_ZONE : zone de votre pool de nœuds.
    • PROJECT_ID : ID de votre projet Google Cloud .
    • GVNIC_NETWORK_PREFIX : a4high-gvnic pour les VM A4 ou a3ultra-gvnic pour les VM A3 Ultra.
    • RDMA_NETWORK_PREFIX : a4high-rdma pour les VM A4 ou a3ultra-rdma pour les VM A3 Ultra.

  2. Créez deux réseaux VPC :

    # Create a VPC for the additional Google Titanium CPU NIC
gcloud compute --project=${PROJECT} \
  networks create \
  ${GVNIC_NETWORK_PREFIX}-net \
  --subnet-mode=custom

gcloud compute --project=${PROJECT} \
  networks subnets create \
  ${GVNIC_NETWORK_PREFIX}-sub \
  --network=${GVNIC_NETWORK_PREFIX}-net \
  --region=${REGION} \
  --range=192.168.0.0/24

gcloud compute --project=${PROJECT} \
  firewall-rules create \
  ${GVNIC_NETWORK_PREFIX}-internal \
  --network=${GVNIC_NETWORK_PREFIX}-net \
  --action=ALLOW \
  --rules=tcp:0-65535,udp:0-65535,icmp \
  --source-ranges=192.168.0.0/16

# Create HPC VPC for the RDMA NICs with 8 subnets.
gcloud beta compute --project=${PROJECT} \
  networks create ${RDMA_NETWORK_PREFIX}-net \
  --network-profile=${ZONE}-vpc-roce \
  --subnet-mode=custom

# Create subnets for the HPC VPC.
for N in $(seq 0 7); do
  gcloud compute --project=${PROJECT} \
    networks subnets create \
    ${RDMA_NETWORK_PREFIX}-sub-$N \
    --network=${RDMA_NETWORK_PREFIX}-net \
    --region=${REGION} \
    --range=192.168.$((N+1)).0/24 &  # offset to avoid overlap with gvnics
done

Créer le cluster GKE avec le multiréseau

Autopilot

  1. Créez un cluster GKE Autopilot avec le multiréseau :

    gcloud container clusters create-auto CLUSTER_NAME \
    --enable-multi-networking \
    --cluster-version=CLUSTER_VERSION \
    --region=COMPUTE_REGION

    Remplacez les éléments suivants :

    • CLUSTER_NAME : nom du cluster
    • CLUSTER_VERSION : version de votre nouveau cluster. Pour savoir quelle version de GKE est compatible avec votre configuration, consultez la section Exigences.
    • COMPUTE_REGION : nom de la région de calcul.

  2. Connectez-vous à votre cluster pour pouvoir exécuter les commandes kubectl dans les sections suivantes :

    gcloud container clusters get-credentials CLUSTER_NAME --location=COMPUTE_REGION

    Remplacez les éléments suivants :

    • CLUSTER_NAME : nom du cluster
    • COMPUTE_REGION : nom de la région de calcul.

    Pour en savoir plus, consultez Installer kubectl et configurer l'accès au cluster.

Standard

Créez un cluster GKE Standard et un pool de nœuds GPU avec le multiréseau :

  1. Créez le cluster :

    gcloud container clusters create CLUSTER_NAME \
  --region=COMPUTE_REGION \
  --cluster-version=CLUSTER_VERSION \
  --enable-dataplane-v2 --enable-ip-alias --enable-multi-networking [\
  --services-ipv4-cidr=SERVICE_CIDR \
  --cluster-ipv4-cidr=POD_CIDR]

    Remplacez les éléments suivants :

    • CLUSTER_NAME : nom du cluster
    • CLUSTER_VERSION : version de votre nouveau cluster. Pour savoir quelle version de GKE est compatible avec votre configuration, consultez la section Exigences.
    • COMPUTE_REGION : nom de la région de calcul.

    Vous pouvez éventuellement fournir explicitement les plages CIDR secondaires pour les services et les pods. Si vous utilisez ces options facultatives, remplacez les variables suivantes :

    • SERVICE_CIDR : plage CIDR secondaire pour les services.
    • POD_CIDR : plage CIDR secondaire des pods.

    Lorsque vous utilisez ces indicateurs, vous devez vérifier que les plages CIDR ne chevauchent pas les plages de sous-réseaux pour les réseaux de nœuds supplémentaires. Par exemple, les plages des valeurs SERVICE_CIDR=10.65.0.0/19 et POD_CIDR=10.64.0.0/19 ne se chevauchent pas. Pour en savoir plus, consultez Ajouter des plages d'adresses IPv4 de pod.

  2. Créez le pool de nœuds. La commande que vous devez exécuter dépend de l'option de consommation que vous utilisez pour votre déploiement. Sélectionnez l'onglet correspondant au modèle de provisionnement de votre option de consommation.

    Lié à la réservation

    Pour le provisionnement lié à une réservation, exécutez la commande suivante :

    gcloud container node-pools create NODE_POOL_NAME \
  --region COMPUTE_REGION --cluster CLUSTER_NAME \
  --node-locations COMPUTE_ZONE \
  --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
  --machine-type MACHINE_TYPE \
  --num-nodes=NUM_NODES \
  --reservation-affinity=specific \
  --reservation=RESERVATION_NAME/reservationBlocks/BLOCK_NAME  \
  --additional-node-network network=${GVNIC_NETWORK_PREFIX}-net,subnetwork=${GVNIC_NETWORK_PREFIX}-sub \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-0 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-1 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-2 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-3 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-4 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-5 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-6 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-7

    Remplacez les éléments suivants :

    • NODE_POOL_NAME : nom du pool de nœuds.
    • COMPUTE_REGION : région de votre nouveau cluster.
    • CLUSTER_NAME : nom de votre nouveau cluster
    • COMPUTE_ZONE : zone de votre pool de nœuds.

    • GPU_TYPE : type d'accélérateur GPU :

      • VM A4 : saisissez nvidia-b200.
      • VM A3 Ultra : saisissez nvidia-h200-141gb.

    • AMOUNT : nombre de GPU à associer aux nœuds du pool de nœuds. Par exemple, pour les VM a4-highgpu-8g et a3-ultragpu-8g, le nombre de GPU est de 8.

    • DRIVER_VERSION : version du pilote NVIDIA à installer. Elle peut être l'une des valeurs suivantes : default, latest ou disabled.

    • MACHINE_TYPE : type de machine Compute Engine pour les nœuds. Par exemple, utilisez a4-highgpu-8g pour les VM A4 et a3-ultragpu-8g pour les VM A3 Ultra.

    • MACHINE_TYPE : type de machine Compute Engine pour les nœuds. Par exemple, utilisez a4-highgpu-8g pour les VM A4 et a3-ultragpu-8g pour les VM A3 Ultra.

    • NUM_NODES : nombre de nœuds du pool de nœuds. Pour flex-start, cette valeur doit être définie sur 0.

    • RESERVATION_NAME : nom de votre réservation. Pour trouver cette valeur, consultez Afficher les demandes de réservations futures.

    • BLOCK_NAME : nom d'un bloc spécifique dans la réservation. Pour trouver cette valeur, consultez Afficher les demandes de réservations futures.

    Démarrage flexible

    Pour le provisionnement à démarrage flexible, exécutez la commande suivante :

    gcloud container node-pools create NODE_POOL_NAME \
  --region COMPUTE_REGION --cluster CLUSTER_NAME \
  --node-locations COMPUTE_ZONE \
  --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
  --machine-type MACHINE_TYPE \
  --num-nodes=NUM_NODES \
  --flex-start --num-nodes=0 --enable-autoscaling \
  --total-max-nodes TOTAL_MAX_NODES \
  --no-enable-autorepair --location-policy=ANY \
  --reservation-affinity=none \
  [--enable-queued-provisioning \]
  --additional-node-network network=${GVNIC_NETWORK_PREFIX}-net,subnetwork=${GVNIC_NETWORK_PREFIX}-sub \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-0 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-1 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-2 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-3 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-4 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-5 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-6 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-7

    Remplacez les éléments suivants :

    • NODE_POOL_NAME : nom du pool de nœuds.
    • COMPUTE_REGION : région de votre nouveau cluster.
    • CLUSTER_NAME : nom de votre nouveau cluster
    • COMPUTE_ZONE : zone de votre pool de nœuds.

    • GPU_TYPE : type d'accélérateur GPU :

      • VM A4 : saisissez nvidia-b200.
      • VM A3 Ultra : saisissez nvidia-h200-141gb.

    • AMOUNT : nombre de GPU à associer aux nœuds du pool de nœuds. Par exemple, pour les VM a4-highgpu-8g et a3-ultragpu-8g, le nombre de GPU est de 8.

    • DRIVER_VERSION : version du pilote NVIDIA à installer. Elle peut être l'une des valeurs suivantes : default, latest ou disabled.

    • MACHINE_TYPE : type de machine Compute Engine pour les nœuds. Par exemple, utilisez a4-highgpu-8g pour les VM A4 et a3-ultragpu-8g pour les VM A3 Ultra.

    • MACHINE_TYPE : type de machine Compute Engine pour les nœuds. Par exemple, utilisez a4-highgpu-8g pour les VM A4 et a3-ultragpu-8g pour les VM A3 Ultra.

    • NUM_NODES : nombre de nœuds du pool de nœuds. Pour flex-start, cette valeur doit être définie sur 0.

    • TOTAL_MAX_NODES : nombre maximal de nœuds pour effectuer le scaling automatique du pool de nœuds entier.

    Si vous souhaitez utiliser flex-start avec le provisionnement en file d'attente, incluez l'indicateur --enable-queued-provisioning.

    Pour en savoir plus sur l'utilisation du démarrage flexible, consultez Exécuter des charges de travail à grande échelle avec le démarrage flexible et le provisionnement en file d'attente.

  3. Connectez-vous à votre cluster pour pouvoir exécuter les commandes kubectl dans les sections suivantes :

    gcloud container clusters get-credentials CLUSTER_NAME --location=COMPUTE_REGION

    Remplacez les éléments suivants :

    • CLUSTER_NAME : nom du cluster
    • COMPUTE_REGION : nom de la région de calcul.

    Pour en savoir plus, consultez Installer kubectl et configurer l'accès au cluster.

Créer les objets réseau GKE

Les réseaux VPC créés dans la section précédente doivent être configurés à l'aide d'ensembles de paramètres réseau GKE. Plus précisément, la deuxième carte d'interface réseau Titanium (gVNIC) du processeur doit être configurée en mode NetDevice, et chacune des huit cartes d'interface réseau CX-7 RDMA doit être configurée en mode RDMA.

Cette commande utilise les noms suivants :

  • Le VPC de la carte d'interface réseau (gVNIC) Titanium du processeur est nommé ${GVNIC_NETWORK_PREFIX}-net avec le sous-réseau ${GVNIC_NETWORK_PREFIX}-sub.
  • Le VPC des cartes d'interface réseau RDMA CX-7 est nommé ${RDMA_NETWORK_PREFIX}-net avec des sous-réseaux nommés ${RDMA_NETWORK_PREFIX}-sub-[0…7].

Créez les objets réseau GKE en exécutant la commande suivante :

kubectl apply -f - <<EOF
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: gvnic-1
spec:
  vpc: ${GVNIC_NETWORK_PREFIX}-net
  vpcSubnet: ${GVNIC_NETWORK_PREFIX}-sub
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: gvnic-1
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: gvnic-1
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-0
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-0
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-0
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-0
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-1
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-1
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-1
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-1
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-2
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-2
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-2
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-2
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-3
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-3
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-3
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-3
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-4
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-4
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-4
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-4
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-5
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-5
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-5
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-5
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-6
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-6
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-6
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-6
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-7
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-7
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-7
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-7
EOF

Installer le binaire RDMA et configurer NCCL

Appliquez le DaemonSet suivant pour installer les binaires RDMA et la bibliothèque NCCL sur chaque nœud. Sur chaque VM sous-jacente, les binaires RDMA sont installés dans le répertoire /home/kubernetes/bin/gib et la bibliothèque NCCL dans le répertoire /home/kubernetes/bin/nvidia/lib64.

Autopilot

Pour le mode GKE Autopilot, exécutez la commande suivante :

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/gpudirect-rdma/nccl-rdma-installer-autopilot.yaml

Standard

Pour le mode Standard de GKE, exécutez la commande suivante :

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/gpudirect-rdma/nccl-rdma-installer.yaml

Exécuter des tests NCCL

Pour valider la fonctionnalité du cluster provisionné, vous pouvez exécuter un test NCCL. Pour obtenir des instructions, consultez Déployer et exécuter un test NCCL.

Configurer vos fichiers manifestes de pods pour GPUDirect RDMA

Pour exécuter vos charges de travail à l'aide de GPUDirect RDMA, configurez vos fichiers manifestes de pod en procédant comme suit :

  1. Ajoutez les annotations suivantes aux métadonnées du pod.

    Autopilot

    Utilisez l'annotation suivante pour le mode GKE Autopilot :

    metadata:
annotations:
  networking.gke.io/default-interface: 'eth0'
  networking.gke.io/interfaces: |
    [
      {"interfaceName":"eth0","network":"default"},
      {"interfaceName":"eth1","network":"gvnic-1"},
      {"interfaceName":"eth2","network":"rdma-0"},
      {"interfaceName":"eth3","network":"rdma-1"},
      {"interfaceName":"eth4","network":"rdma-2"},
      {"interfaceName":"eth5","network":"rdma-3"},
      {"interfaceName":"eth6","network":"rdma-4"},
      {"interfaceName":"eth7","network":"rdma-5"},
      {"interfaceName":"eth8","network":"rdma-6"},
      {"interfaceName":"eth9","network":"rdma-7"}
    ]

    Standard

    L'annotation suivante pour le mode GKE Standard n'inclut pas de spécification gvnic-1, mais vous pouvez l'ajouter si vos charges de travail l'exigent.

    Utilisez l'annotation suivante pour le mode GKE Standard :

    metadata:
annotations:
  networking.gke.io/default-interface: 'eth0'
  networking.gke.io/interfaces: |
    [
      {"interfaceName":"eth0","network":"default"},
      {"interfaceName":"eth2","network":"rdma-0"},
      {"interfaceName":"eth3","network":"rdma-1"},
      {"interfaceName":"eth4","network":"rdma-2"},
      {"interfaceName":"eth5","network":"rdma-3"},
      {"interfaceName":"eth6","network":"rdma-4"},
      {"interfaceName":"eth7","network":"rdma-5"},
      {"interfaceName":"eth8","network":"rdma-6"},
      {"interfaceName":"eth9","network":"rdma-7"}
    ]

  2. Spécifiez le type de GPU choisi et la réservation spécifique à l'aide de sélecteurs de nœuds :

    spec:
  nodeSelector:
    cloud.google.com/gke-accelerator: ACCELERATOR
    cloud.google.com/reservation-name: RESERVATION_NAME
    cloud.google.com/reservation-affinity: "specific"

    Remplacez les éléments suivants :

    • ACCELERATOR : accélérateur que vous avez réservé dans la réservation de capacité Compute Engine. Vous devez utiliser l'une des valeurs suivantes :
      • nvidia-b200 : NVIDIA B200 (180 Go) pour les VM A4
      • nvidia-h200-141gb : NVIDIA H200 (141 Go) pour les VM A3 Ultra
    • RESERVATION_NAME : nom de la réservation de capacité Compute Engine.

    Pour consommer des réservations partagées, ou des blocs et sous-blocs spécifiques de réservations, consultez les sections correspondantes dans Consommer des ressources de chemin d'accès zonales réservées.

  3. Ajoutez les volumes suivants à la spécification de pod :

    spec:
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
    - name: gib
      hostPath:
        path: /home/kubernetes/bin/gib

  4. Ajoutez les installations de volume, les variables d'environnement et les ressources suivantes au conteneur qui demande des GPU. Le conteneur de charge de travail doit demander les huit GPU :

    Autopilot

    Pour le mode GKE Autopilot, configurez les ressources suivantes :

    containers:
  - name: my-container
    volumeMounts:
      - name: library-dir-host
        mountPath: /usr/local/nvidia
        readOnly: true
      - name: gib
        mountPath: /usr/local/gib
        readOnly: true
    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
    resources:
      limits:
        nvidia.com/gpu: 8

    Standard

    Pour le mode GKE Standard, configurez les ressources suivantes :

    containers:
  - name: my-container
    volumeMounts:
      - name: library-dir-host
        mountPath: /usr/local/nvidia
      - name: gib
        mountPath: /usr/local/gib
    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
    resources:
      limits:
        nvidia.com/gpu: 8

  5. Définissez toutes les variables d'environnement requises pour configurer NCCL à l'aide du script shell suivant à partir du conteneur de charge de travail :

    source /usr/local/gib/scripts/set_nccl_env.sh

Les onglets suivants incluent des exemples de fichiers manifestes de pods complétés.

Autopilot

Pour le mode Autopilot de GKE, un fichier manifeste de pod terminé doit ressembler à ce qui suit :

apiVersion: apps/v1
kind: Pod
metadata:
  name: my-pod
  labels:
    k8s-app: my-pod
  annotations:
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth1","network":"gvnic-1"},
        {"interfaceName":"eth2","network":"rdma-0"},
        {"interfaceName":"eth3","network":"rdma-1"},
        {"interfaceName":"eth4","network":"rdma-2"},
        {"interfaceName":"eth5","network":"rdma-3"},
        {"interfaceName":"eth6","network":"rdma-4"},
        {"interfaceName":"eth7","network":"rdma-5"},
        {"interfaceName":"eth8","network":"rdma-6"},
        {"interfaceName":"eth9","network":"rdma-7"}
      ]
spec:
  ...
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
    - name: gib
      hostPath:
        path: /home/kubernetes/bin/gib
  containers:
    - name: my-container
      volumeMounts:
        - name: library-dir-host
          mountPath: /usr/local/nvidia
          readOnly: true
        - name: gib
          mountPath: /usr/local/gib
          readOnly: true
      env:
        - name: LD_LIBRARY_PATH
          value: /usr/local/nvidia/lib64
      resources:
        limits:
          nvidia.com/gpu: 8
          ...

Standard

Pour le mode Standard de GKE, un fichier manifeste de pod terminé doit ressembler à ce qui suit :

apiVersion: apps/v1
kind: Pod
metadata:
  name: my-pod
  labels:
    k8s-app: my-pod
  annotations:
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth2","network":"rdma-0"},
        {"interfaceName":"eth3","network":"rdma-1"},
        {"interfaceName":"eth4","network":"rdma-2"},
        {"interfaceName":"eth5","network":"rdma-3"},
        {"interfaceName":"eth6","network":"rdma-4"},
        {"interfaceName":"eth7","network":"rdma-5"},
        {"interfaceName":"eth8","network":"rdma-6"},
        {"interfaceName":"eth9","network":"rdma-7"}
      ]
spec:
  ...
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
    - name: gib
      hostPath:
        path: /home/kubernetes/bin/gib
  containers:
    - name: my-container
      volumeMounts:
        - name: library-dir-host
          mountPath: /usr/local/nvidia
        - name: gib
          mountPath: /usr/local/gib
      env:
        - name: LD_LIBRARY_PATH
          value: /usr/local/nvidia/lib64
      resources:
        limits:
          nvidia.com/gpu: 8
          ...

Tester les performances réseau des clusters qui utilisent GPUDirect RDMA

Nous vous recommandons de valider le fonctionnement des clusters provisionnés. Pour ce faire, utilisez les tests NCCL/gIB, qui sont des tests NVIDIA Collective Communications Library (NCCL) optimisés pour l'environnement Google.

Étapes suivantes