Demander des TPU avec une réservation future en mode Agenda

Autopilot Standard

Preview — Future reservation in calendar mode

Cette fonctionnalité est soumise(s) aux "Conditions des offres de pré-DG" de la section "Conditions générales du service" des Conditions spécifiques du service. Les fonctionnalités de pré-DG sont disponibles "en l'état" et peuvent avoir une prise en charge limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Ce guide explique comment optimiser le provisionnement de Tensor Processing Unit (TPU) à l'aide de la réservation future en mode Agenda. La réservation future en mode Agenda est un conseiller et un outil de recommandation intégrés à l'agenda qui peuvent vous aider à trouver de la capacité TPU et à planifier à l'avance. Vous pouvez demander de la capacité pour une heure de début et une durée spécifiques, comprises entre 1 et 90 jours. Le système de recommandation vous proposera des dates.

Ce guide est destiné aux ingénieurs en machine learning (ML), aux administrateurs et opérateurs de plate-forme, ainsi qu'aux spécialistes des données et de l'IA qui souhaitent utiliser les fonctionnalités d'orchestration de conteneurs Kubernetes pour exécuter des charges de travail par lot. Pour en savoir plus sur les rôles courants et les exemples de tâches que nous citons dans le contenu Google Cloud , consultez Rôles utilisateur et tâches courantes de GKE.

Pour en savoir plus, consultez À propos des réservations futures en mode Agenda.

Cas d'utilisation

Les réservations futures en mode Agenda sont idéales pour les charges de travail avec des requêtes planifiées, à court terme et à forte demande, comme les modèles d'entraînement ou d'inférence par lot qui nécessitent une haute disponibilité à l'heure de début demandée.

Si votre charge de travail nécessite des ressources provisionnées de façon dynamique selon vos besoins, pendant sept jours maximum, sans réservation à long terme ni gestion complexe des quotas, envisagez d'utiliser l'option de consommation à démarrage flexible. Pour en savoir plus, consultez À propos du provisionnement de GPU et de TPU avec le démarrage flexible.

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 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.
  Remarque : Pour les installations de la gcloud CLI existantes, veillez à définir la propriété compute/region. Si vous utilisez principalement des clusters zonaux, définissez plutôt compute/zone. En définissant un emplacement par défaut, vous pouvez éviter les erreurs gcloud CLI de ce type : One of [--zone, --region] must be supplied: Please specify location. Vous devrez peut-être spécifier l'emplacement dans certaines commandes si celui de votre cluster diffère de l'emplacement par défaut que vous avez défini.

• Assurez-vous de disposer de l'un des éléments suivants :
  • un cluster Standard existant exécutant la version 1.28.3-gke.1098000 ou ultérieure.
  • un cluster Autopilot existant exécutant la version 1.30.3-gke.1451000 ou ultérieure.

Demander une réservation future en mode Agenda pour les TPU

Pour demander des TPU avec une réservation future en mode Agenda, procédez comme suit :

1. Assurez-vous de disposer d'un quota suffisant pour toutes les ressources qui ne font pas partie d'une réservation lorsque des VM sont créées, comme les disques ou les adresses IP. Les demandes de réservations futures en mode Agenda ne nécessitent pas de quota Compute Engine.
2. Suivez les étapes de la section Créer une demande en mode Agenda. Voici quelques exemples :
   1. Affichez la disponibilité future des TPU.
   2. Créez et envoyez une demande de réservation future en mode Agenda pour les TPU.
   3. Attendez que Google Cloud approuve votre demande.
3. Créez un pool de nœuds TPU qui utilise votre réservation.

Créer un pool de nœuds

Cette section ne s'applique qu'aux clusters Standard, car le mode Autopilot crée automatiquement des nœuds en fonction des charges de travail.

Vous pouvez utiliser votre réservation lorsque vous créez des pools de nœuds de tranche TPU à hôte unique ou multi-hôtes.

Créer un pool de nœuds de tranche TPU à hôte unique

Vous pouvez créer un pool de nœuds de tranche de TPU à hôte unique à l'aide de Google Cloud CLI.

gcloud container node-pools create NODE_POOL_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --cluster=CLUSTER_NAME \
    --node-locations=NODE_ZONES \
    --machine-type=MACHINE_TYPE \
    --reservation-affinity=specific \ This is required
    --reservation=RESERVATION

Remplacez les éléments suivants :

• NODE_POOL_NAME : nom du nouveau pool de nœuds.
• CONTROL_PLANE_LOCATION : nom de la zone basé sur la version de TPU que vous souhaitez utiliser. Pour identifier un emplacement disponible, consultez Disponibilité des TPU dans GKE.
• CLUSTER_NAME : nom du cluster.
• NODE_ZONES : liste d'une ou de plusieurs zones, séparées par une virgule, dans lesquelles GKE crée le pool de nœuds.
• MACHINE_TYPE : type de machine à utiliser pour les nœuds. Pour en savoir plus sur les types de machines compatibles avec les TPU, utilisez le tableau de la section Choisir la version de TPU.
• RESERVATION : nom de la réservation de calendrier à consommer.

Pour obtenir la liste complète de toutes les options que vous pouvez spécifier, consultez la documentation de référence sur gcloud container clusters create.

Une fois que vous avez créé un pool de nœuds avec la réservation d'agenda, vous pouvez déployer votre charge de travail comme n'importe quel autre pool de nœuds TPU. La consommation d'une réservation future en mode Agenda fonctionne de la même manière que pour tout autre type de réservation. Pour en savoir plus, consultez Consommer des ressources zonales réservées.

Créer un pool de nœuds de tranche TPU multi-hôtes

La procédure de création d'un pool de nœuds de tranche TPU multi-hôte diffère selon que vous utilisez Ironwood (TPU7x) ou une version antérieure de TPU.

Ironwood (TPU7x)

Preview — Ironwood (TPU7x)

Cette fonctionnalité est soumise(s) aux "Conditions des offres de pré-DG" de la section "Conditions générales du service" des Conditions spécifiques du service. Les fonctionnalités de pré-DG sont disponibles "en l'état" et peuvent avoir une prise en charge limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Vous pouvez créer un pool de nœuds tranche de TPU multi-hôte dans la version Ironwood (TPU7x) à l'aide de Google Cloud CLI ou de Terraform :

gcloud

Pour créer un pool de nœuds de tranche TPU multi-hôte avec Ironwood (TPU7x), vous devez d'abord créer une règle de charge de travail.

Remarque : Vous n'avez pas besoin de créer une règle de charge de travail pour chaque pool de nœuds. Une règle de charge de travail est unique par projet, par région et par topologie. Vous pouvez réutiliser la même règle de charge de travail pour plusieurs pools de nœuds qui partagent ces caractéristiques. Pour afficher la liste des règles de charge de travail, utilisez la commande gcloud compute resource-policies list --filter="region:REGION".

1. Créez une règle de charge de travail :

   gcloud compute resource-policies create workload-policy WORKLOAD_POLICY_NAME \
       --type=HIGH_THROUGHPUT \
       --accelerator-topology=TPU_TOPOLOGY \
       --project=PROJECT_ID \
       --region=REGION
   

   Remplacez les éléments suivants :

   • WORKLOAD_POLICY_NAME : nom de votre règle de charge de travail.
   • TPU_TOPOLOGY : topologie TPU Ironwood (TPU7x). Exemple :2x2x2 Pour afficher toutes les topologies Ironwood (TPU7x) compatibles, consultez la section Topologie.
   • PROJECT_ID : ID de votre projet Google Cloud .
   • REGION : région de la règle de charge de travail. Une règle de charge de travail est une ressource régionale qui peut être réutilisée dans des pools de nœuds partageant la même topologie.

2. Créez le pool de nœuds avec la règle de charge de travail :

   gcloud container node-pools create NODE_POOL_NAME \
       --cluster=CLUSTER_NAME \
       --location=us-central1 \
       --node-locations=us-central1-c \
       --machine-type=tpu7x-standard-4t \
       --reservation-affinity=specific \
       --reservation=FUTURE_RESERVATION_NAME \
       --placement-policy=WORKLOAD_POLICY
   

   Remplacez les éléments suivants :

   • NODE_POOL_NAME : nom du nouveau pool de nœuds.
   • WORKLOAD_POLICY : nom de la règle de charge de travail que vous avez créée.
   • FUTURE_RESERVATION_NAME : nom de votre réservation future.

   Cette commande crée un pool de nœuds nommé NODE_POOL_NAME avec les caractéristiques suivantes :

   • --machine-type=tpu7x-standard-4t spécifie le type de machine Ironwood (TPU7x).

Terraform

1. Assurez-vous d'utiliser la version 4.84.0 ou ultérieure du fournisseur google.

2. Créez une règle de charge de travail :

   resource "google_compute_resource_policy" {
     name   = "WORKLOAD_POLICY_NAME"
     region = CLUSTER_LOCATION
     workload_policy {
       type = "HIGH_THROUGHPUT"
       accelerator_topology = "TPU_TOPOLOGY"
     }
   }
   

   Remplacez les éléments suivants :

   • WORKLOAD_POLICY_NAME : nom de votre règle de charge de travail.
   • CLUSTER_LOCATION : emplacement de calcul du cluster. Nous vous recommandons de disposer d'un cluster régional pour améliorer la fiabilité du plan de contrôle Kubernetes. Vous pouvez également utiliser un cluster zonal. Pour en savoir plus, consultez Sélectionner une version et une topologie de TPU.
   • TPU_TOPOLOGY : topologie TPU Ironwood (TPU7x). Exemple :2x2x2 Pour afficher toutes les topologies Ironwood (TPU7x) compatibles, consultez Planifier les TPU.

   Pour en savoir plus sur la référence google_compute_resource_policy, consultez Fournisseur Terraform.

3. Dans votre configuration Terraform, ajoutez le bloc suivant :

   resource "google_container_node_pool" "NODE_POOL_RESOURCE_NAME" {
     provider           = google
     project            = PROJECT_ID
     cluster            = CLUSTER_NAME
     name               = POOL_NAME
     location           = CLUSTER_LOCATION
     node_locations     = [NODE_ZONES]
     initial_node_count = NUM_NODES
   
     autoscaling {
       max_node_count = MAX_NODES
       location_policy      = "ANY"
     }
     node_config {
       machine_type = MACHINE_TYPE
       reservation_affinity {
         consume_reservation_type = "SPECIFIC_RESERVATION"
         key = "compute.googleapis.com/reservation-name"
         values = [RESERVATION_LABEL_VALUES]
       }
       flex_start = false
     }
   
     placement_policy {
       policy_name = WORKLOAD_POLICY_NAME
     }
   }
   

   Remplacez les éléments suivants :

   • NODE_POOL_RESOURCE_NAME : nom de la ressource de pool de nœuds dans le modèle Terraform.
   • PROJECT_ID : ID de votre projet.
   • CLUSTER_NAME : nom du cluster existant auquel ajouter le pool de nœuds.
   • POOL_NAME : nom du pool de nœuds à créer
   • NODE_ZONES : liste d'une ou de plusieurs zones, séparées par une virgule, dans lesquelles GKE crée le pool de nœuds.
   • NUM_NODES : nombre de nœuds dans le pool de nœuds. Doit être égal à zéro ou au produit du nombre de puces TPU divisé par quatre, car dans les tranches de TPU à hôtes multiples, chaque nœud de tranche TPU comporte quatre puces. Par exemple, si TPU_TOPOLOGY est défini sur 4x8, il y a 32 puces, ce qui signifie que NUM_NODES doit être égal à 8. Pour en savoir plus sur les topologies TPU, utilisez le tableau de la section Choisir la version de TPU.
   • TPU_TOPOLOGY : indique la topologie physique sélectionnée pour la tranche de TPU. Le format de la topologie dépend de la version de TPU que vous utilisez. Pour en savoir plus sur les topologies TPU, consultez le tableau de la section Choisir une topologie.

   Vous pouvez également utiliser les variables suivantes :

   • RESERVATION_NAME : si vous utilisez une réservation TPU, fournissez une liste des libellés des ressources de réservation à utiliser lors de la création du pool de nœuds. Pour en savoir plus sur la spécification de RESERVATION_LABEL_VALUES dans le champ reservation_affinity, consultez la page Fournisseur Terraform.
   • autoscaling : créez un pool de nœuds avec l'autoscaling activé. Lorsque GKE met à l'échelle un pool de nœuds de tranche TPU multi-hôte, il effectue un scaling de façon atomique du pool de nœuds de zéro à la taille maximale.
     • MAX_NODES : taille maximale du pool de nœuds. La valeur doit être égale au produit des valeurs définies dans TPU_TOPOLOGY ({A}x{B}x{C}) divisé par le nombre de puces dans chaque VM. Par exemple, si TPU_TOPOLOGY est 2x2x2, le produit est 8. Étant donné que chaque VM de tpu7x-standard-4t comporte quatre puces, le nombre de nœuds est de deux.
   • spot : pool de nœuds qui utilisera des VM Spot pour les nœuds de tranche TPU. Ce paramètre ne peut pas être modifié après la création du pool de nœuds. Pour en savoir plus, consultez VM Spot.
   • flex_start : pool de nœuds qui utilisera l'option de consommation flex-start. Ce paramètre ne peut pas être défini sur true si spot est activé.

Autres versions de TPU

Vous pouvez créer un pool de nœuds tranche de TPU multi-hôte dans les versions v3, v4, v5p, v5e et Trillium (v6e) à l'aide de Google Cloud CLI, de Terraform ou de la console Google Cloud .

gcloud

  gcloud container node-pools create NODE_POOL_NAME \
      --cluster=CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --node-locations=NODE_ZONES \
      --machine-type=MACHINE_TYPE \
      --tpu-topology=TPU_TOPOLOGY \
      --reservation-affinity=specific \
      --reservation=FUTURE_RESERVATION_NAME

Remplacez les éléments suivants :

• NODE_POOL_NAME : nom du nouveau pool de nœuds.
• CLUSTER_NAME : nom du cluster.
• CONTROL_PLANE_LOCATION : nom de la zone basé sur la version de TPU que vous souhaitez utiliser. Pour identifier un emplacement disponible, consultez Disponibilité des TPU dans GKE.
• NODE_ZONES : liste d'une ou de plusieurs zones, séparées par une virgule, dans lesquelles GKE crée le pool de nœuds.
• MACHINE_TYPE : type de machine à utiliser pour les nœuds. Pour en savoir plus sur les types de machines compatibles avec les TPU, utilisez le tableau de la section Choisir la version de TPU.
• TPU_TOPOLOGY : topologie du TPU. Exemple :2x2x2 Pour afficher toutes les topologies de TPU compatibles, consultez la section Topologie.

• FUTURE_RESERVATION_NAME : nom de votre réservation future.

Terraform

1. Assurez-vous d'utiliser la version 4.84.0 ou ultérieure du fournisseur google.

2. Ajoutez le bloc suivant à votre configuration Terraform :

   resource "google_container_node_pool" "NODE_POOL_RESOURCE_NAME" {
     provider           = google
     project            = PROJECT_ID
     cluster            = CLUSTER_NAME
     name               = POOL_NAME
     location           = CLUSTER_LOCATION
     node_locations     = [NODE_ZONES]
     initial_node_count = NUM_NODES
   
     autoscaling {
       max_node_count = MAX_NODES
       location_policy      = "ANY"
     }
     node_config {
       machine_type = MACHINE_TYPE
       reservation_affinity {
         consume_reservation_type = "SPECIFIC_RESERVATION"
         key = "compute.googleapis.com/reservation-name"
         values = [RESERVATION_LABEL_VALUES]
       }
       flex_start = false
     }
   
     placement_policy {
       type = "COMPACT"
       tpu_topology = TPU_TOPOLOGY
     }
   }
   

   Remplacez les éléments suivants :

   • NODE_POOL_RESOURCE_NAME : nom de la ressource de pool de nœuds dans le modèle Terraform.
   • PROJECT_ID : ID de votre projet.
   • CLUSTER_NAME : nom du cluster existant auquel ajouter le pool de nœuds.
   • POOL_NAME : nom du pool de nœuds à créer
   • CLUSTER_LOCATION : emplacement de calcul du cluster. Nous vous recommandons de disposer d'un cluster régional pour améliorer la fiabilité du plan de contrôle Kubernetes. Vous pouvez également utiliser un cluster zonal. Pour en savoir plus, consultez la section Sélectionner une version et une topologie de TPU.
   • NODE_ZONES : liste d'une ou de plusieurs zones, séparées par une virgule, dans lesquelles GKE crée le pool de nœuds.
   • NUM_NODES : nombre de nœuds dans le pool de nœuds. Doit être égal à zéro ou au produit du nombre de puces TPU divisé par quatre, car dans les tranches de TPU à hôtes multiples, chaque nœud de tranche TPU comporte quatre puces. Par exemple, si TPU_TOPOLOGY est défini sur 4x8, il y a 32 puces, ce qui signifie que NUM_NODES doit être égal à 8. Pour en savoir plus sur les topologies TPU, utilisez le tableau de la section Choisir la version de TPU.
   • TPU_TOPOLOGY : indique la topologie physique de la tranche de TPU. Le format de la topologie dépend de la version de TPU que vous utilisez. Pour en savoir plus sur les topologies TPU, consultez le tableau de la section Choisir une topologie.

   Vous pouvez également utiliser les variables suivantes :

   • RESERVATION_NAME : si vous utilisez la réservation TPU, il s'agit de la liste des libellés des ressources de réservation à utiliser lors de la création du pool de nœuds. Pour en savoir plus sur la spécification de RESERVATION_LABEL_VALUES dans le champ reservation_affinity, consultez la page Fournisseur Terraform.
   • autoscaling : Ajouter un pool de nœuds avec l'autoscaling activé. Lorsque GKE met à l'échelle un pool de nœuds de tranche TPU multi-hôte, il effectue un scaling de façon atomique du pool de nœuds de zéro à la taille maximale.
     • MAX_NODES : taille maximale du pool de nœuds. Elle doit être égale au produit des valeurs définies dans TPU_TOPOLOGY ({A}x{B}x{C}) divisée par le nombre de puces dans chaque VM.
   • spot : permet au pool de nœuds d'utiliser des VM Spot pour les nœuds de tranche TPU. Ce paramètre ne peut pas être modifié après la création du pool de nœuds. Pour en savoir plus, consultez VM Spot.
   • flex_start : définit le pool de nœuds de sorte qu'il utilise l'option de consommation flex-start. Ne peut pas être défini sur true si spot est activé.

Console

Pour créer un pool de nœuds à l'aide de TPU, exécutez la commande suivante :

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

   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. Dans la section Détails du pool de nœuds, cochez la case Spécifier les emplacements de nœud.

5. Sélectionnez le nom de la zone en fonction de la version de TPU que vous souhaitez utiliser. Pour identifier un emplacement disponible, consultez Disponibilité des TPU dans GKE.

6. Dans le volet de navigation, cliquez sur Nœuds.

7. Dans la section Configuration de la machine, sélectionnez TPU.

8. Dans le menu déroulant Série, sélectionnez l'une des options suivantes :

   • CT3 : TPU v3, appareil à hôte unique
   • CT3P : TPU v3, tranche de pod multi-hôte
   • CT4P : TPU v4
   • CT5LP : TPU v5e
   • CT5P : TPU v5p
   • CT6E : TPU Trillium (v6e)

9. Dans le menu déroulant Type de machine, sélectionnez le nom de la machine à utiliser pour les nœuds. Utilisez le tableau Choisir la version du TPU pour apprendre à définir le type de machine et la topologie TPU qui créent un pool de nœuds de tranche TPU multi-hôtes.

10. Dans le menu déroulant Topologie TPU, sélectionnez la topologie physique de la tranche de TPU.

11. Dans la boîte de dialogue Modifications requises, cliquez sur Apporter des modifications.

12. Assurez-vous d'avoir défini le champ Type de disque de démarrage sur Disque persistant standard ou Disque persistant SSD.

13. Vous pouvez éventuellement cocher la case Activer les nœuds sur les VM Spot afin d'utiliser des VM Spot pour les nœuds du pool de nœuds.

14. Cliquez sur Créer.

Une fois que vous avez créé un pool de nœuds avec la réservation d'agenda, vous pouvez déployer votre charge de travail comme n'importe quel autre pool de nœuds TPU. La consommation d'une réservation future en mode Agenda fonctionne de la même manière que pour tout autre type de réservation. Pour en savoir plus, consultez Consommer des ressources zonales réservées.

Étapes suivantes

• Essayez des exemples de déploiement GKE pour les modèles d'IA générative qui utilisent les ressources TPU que vous avez réservées :

  • Diffuser un LLM à l'aide de TPU Trillium sur GKE avec vLLM
  • Diffuser un LLM à l'aide de TPU sur GKE avec KubeRay
  • Diffuser un LLM à l'aide de TPU sur GKE avec JetStream et PyTorch
  • Diffuser Gemma à l'aide de TPU sur GKE avec JetStream
  • Diffuser Stable Diffusion XL (SDXL) à l'aide de TPU sur GKE avec MaxDiffusion
  • Diffuser des modèles Open Source à l'aide de TPU sur GKE avec Optimum TPU

• Explorez des exemples expérimentaux pour exploiter GKE et accélérer vos initiatives d'IA/ML dans GKE AI Labs.