Cette page a été traduite par l'API Cloud Translation.

Exécuter une petite charge de travail par lot avec des TPU et des VM à démarrage flexible

Ce guide vous explique comment optimiser le provisionnement de TPU pour les charges de travail d'entraînement à moyenne et petite échelle à l'aide de VM à démarrage flexible. Les VM à démarrage flexible sont créées à l'aide de l'option de consommation Démarrage flexible. Dans ce guide, vous utilisez des VM à démarrage flexible pour déployer une charge de travail composée d'un pool de nœuds de tranche TPU.

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.

Tarification avec démarrage flexible

Le démarrage flexible est recommandé si votre charge de travail nécessite des ressources provisionnées de manière dynamique selon les besoins, pendant sept jours maximum avec des réservations à court terme, sans gestion complexe des quotas et avec un accès économique. Le démarrage flexible est optimisé par le planificateur de charges de travail dynamique et facturé selon la tarification du planificateur de charges de travail dynamique :

Remise (jusqu'à 53 %) sur les vCPU, les GPU et les TPU.
Vous payez à l'usage.

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.

Vérifiez que vous disposez d'un cluster Autopilot ou d'un cluster Standard exécutant la version 1.33.0-gke.1712000 ou ultérieure.
Assurez-vous de bien comprendre les limites du démarrage flexible.
Lorsque vous utilisez un cluster standard, assurez-vous de conserver au moins un pool de nœuds sans activer le démarrage flexible pour que le cluster fonctionne correctement.
Vérifiez que vous disposez d'un quota de TPU préemptifs dans les emplacements de vos nœuds.

Créer un pool de nœuds avec démarrage flexible

Si vous utilisez un cluster en mode Autopilot, ignorez cette section et passez à la section Exécuter une charge de travail par lot.

Pour créer un pool de nœuds avec le démarrage flexible activé sur un cluster Standard existant, utilisez gcloud CLI.

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

Vous pouvez créer un pool de nœuds de tranche TPU à hôte unique avec flex-start :

Créez un pool de nœuds avec démarrage flexible :
```
gcloud container node-pools create NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --node-locations=NODE_ZONES \
    --machine-type=MACHINE_TYPE \
    --reservation-affinity=none \
    --enable-autoscaling \
    --flex-start \
    --num-nodes 0 \
    --min-nodes=0 \
    --max-nodes=1
```
Remplacez les éléments suivants :
- NODE_POOL_NAME : nom que vous avez choisi pour votre pool de nœuds.
- CLUSTER_NAME : nom du cluster.
- CONTROL_PLANE_LOCATION : région de calcul du plan de contrôle 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.
  
  Par exemple, la commande de création de votre pool de nœuds peut inclure les paramètres suivants :
```
...
--machine-type=ct6e-standard-4t \
--tpu-topology=4x4 \
--enable-autoscaling \
--num-nodes=0 \
--max-nodes=4 \
```
  Cette commande définit le champ --max-nodes sur 4, car une topologie 4x4 se compose de 16 puces et chaque VM ct6e-standard-4t en comporte quatre.
  
  L'autoscaler de cluster augmente le nombre de nœuds jusqu'à ce que votre charge de travail soit satisfaite. Une fois votre charge de travail terminée, l'autoscaler de cluster réduit la capacité à zéro nœud.
- --reservation-affinity=none : le démarrage flexible n'utilise pas et ne nécessite pas de réservations.

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)

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.

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.
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=none \
    --enable-autoscaling \
    --num-nodes=0 --min-nodes=0 --max-nodes=MAX_NODES \
    --flex-start \
    --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.
- MAX_NODES : taille maximale du pool de nœuds. L'option --max-nodes est obligatoire si --enable-autoscaling est fourni. 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 pour 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.
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).
- --flex-start active le démarrage flexible.

Terraform

Assurez-vous d'utiliser la version 4.84.0 ou ultérieure du fournisseur google.
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.
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 = true
  }

  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=none \
      --enable-autoscaling \
      --num-nodes=0 --min-nodes=0 --max-nodes=MAX_NODES \
      --flex-start

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.
MAX_NODES : taille maximale du pool de nœuds. L'option --max-nodes est obligatoire si --enable-autoscaling est fourni. 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 pour chaque VM.

Cette commande crée un pool de nœuds nommé NODE_POOL_NAME avec le démarrage flexible activé.

Terraform

Assurez-vous d'utiliser la version 4.84.0 ou ultérieure du fournisseur google.
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 = true
  }

  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 :

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

Accéder à Google Kubernetes Engine
Dans la liste des clusters, cliquez sur le nom du cluster que vous souhaitez modifier.
Cliquez sur Ajouter un pool de nœuds.
Dans la section Détails du pool de nœuds, cochez la case Spécifier les emplacements de nœud.
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.
Dans le volet de navigation, cliquez sur Nœuds.
Dans la section Configuration de la machine, sélectionnez TPU.
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)
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.
Dans le menu déroulant Topologie TPU, sélectionnez la topologie physique de la tranche de TPU.
Dans la boîte de dialogue Modifications requises, cliquez sur Apporter des modifications.
Assurez-vous d'avoir défini le champ Type de disque de démarrage sur Disque persistant standard ou Disque persistant SSD.
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.
Cliquez sur Créer.

Vérifier l'état du démarrage flexible dans le pool de nœuds

Exécutez la commande suivante :

gcloud container node-pools describe NODE_POOL_NAME \
    --cluster CLUSTER_NAME \
    --location CONTROL_PLANE_LOCATION \
    --format="get(config.flexStart)"

Si le démarrage flexible est activé dans le pool de nœuds, le champ flexStart est défini sur True.

Exécuter une charge de travail par lot

Dans cette section, vous allez créer un job qui planifie un nœud TPU avec des VM à démarrage flexible. Dans Kubernetes, un contrôleur Job crée un ou plusieurs pods et s'assure qu'ils exécutent correctement une tâche spécifique.

Dans la consoleGoogle Cloud , lancez une session Cloud Shell en cliquant sur Activer Cloud Shell. Une session s'ouvre dans le volet inférieur de la console Google Cloud .

Créez un fichier nommé dws-flex-start.yaml :

Hôte unique

Utilisez le fichier manifeste suivant pour le fichier dws-flex-start.yaml :

apiVersion: batch/v1
kind: Job
metadata:
  name: job-1
spec:
  template:
    spec:
      nodeSelector:
        cloud.google.com/gke-flex-start: "true"
        cloud.google.com/gke-tpu-accelerator: ACCELERATOR_TYPE
        cloud.google.com/gke-tpu-topology: TPU_TOPOLOGY
      containers:
      - name: container-1
        image: gcr.io/k8s-staging-perf-tests/sleep:latest
        args: ["3600s"] # Sleep for 1 hour
        resources:
          requests:
              google.com/tpu: NUM_CHIPS
          limits:
              google.com/tpu: NUM_CHIPS
      restartPolicy: OnFailure

Multi-hôtes

Utilisez le fichier manifeste suivant pour le fichier dws-flex-start.yaml :

apiVersion: v1
kind: Service
metadata:
  name: headless-svc
spec:
  clusterIP: None
  selector:
    job-name: job-1
---
apiVersion: batch/v1
kind: Job
metadata:
  name: job-1
spec:
  backoffLimit: 0
  completions: 2
  parallelism: 2
  completionMode: Indexed
  template:
    spec:
      subdomain: headless-svc
      restartPolicy: Never
      nodeSelector:
          cloud.google.com/gke-flex-start: "true"
          cloud.google.com/gke-tpu-accelerator: ACCELERATOR_TYPE
          cloud.google.com/gke-tpu-topology: TPU_TOPOLOGY
      containers:
      - name: tpu-job
        image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
        ports:
        - containerPort: 8471 # Default port using which TPU VMs communicate
        - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
        securityContext:
          privileged: true
        command:
        - bash
        - -c
        - |
          python -c 'import jax; print("TPU cores:", jax.device_count())'
        resources:
          requests:
            google.com/tpu: NUM_CHIPS
          limits:
            google.com/tpu: NUM_CHIPS

Remplacez les éléments suivants :

ACCELERATOR_TYPE : type d'accélérateur TPU que vous avez utilisé lors de la création des pools de nœuds. Par exemple, tpu-v4-podslice ou tpu-v5-lite-podslice.
TPU_TOPOLOGY : topologie physique de la tranche de TPU. Par exemple, la valeur peut être 4x4x4 ou 2x2, selon la version du TPU.
NUM_CHIPS : le nombre de puces TPU dans chaque VM est de un, quatre ou huit. Pour en savoir plus, consultez Versions de TPU.

Appliquez le fichier manifeste dws-flex-start.yaml :
```
kubectl apply -f dws-flex-start.yaml
```

Vérifiez que les jobs s'exécutent sur le même nœud :

kubectl get pods

Le résultat ressemble à ce qui suit :

NAME    READY   STATUS      RESTARTS   AGE   IP       NODE               NOMINATED NODE   READINESS GATES
job-1   0/1     Completed   0          19m   10.(...) gke-flex-zonal-a2  <none>           <none>

Effectuer un nettoyage

Pour éviter que les ressources utilisées sur cette page soient facturées sur votre compte Google Cloud , supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer le projet

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Supprimer la ressource individuelle

Supprimez les jobs :

kubectl delete job -l "job-name in (job-1,job-2)"

Supprimez le pool de nœuds :

gcloud container node-pools delete NODE_POOL_NAME \
      --location CONTROL_PLANE_LOCATION

Supprimez le cluster à l'aide de la commande suivante :
```
gcloud container clusters delete CLUSTER_NAME
```

Étapes suivantes

Apprenez-en plus sur les TPU dans GKE.
En savoir plus sur le provisionnement automatique des nœuds
Découvrez les bonnes pratiques pour exécuter des charges de travail par lot sur GKE.

Exécuter une petite charge de travail par lot avec des TPU et des VM à démarrage flexible Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Tarification avec démarrage flexible

Avant de commencer

Créer un pool de nœuds avec démarrage flexible

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

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

Ironwood (TPU7x)

gcloud

Terraform

Autres versions de TPU

gcloud

Terraform

Console

Vérifier l'état du démarrage flexible dans le pool de nœuds

Exécuter une charge de travail par lot

Hôte unique

Multi-hôtes

Effectuer un nettoyage

Supprimer le projet

Supprimer la ressource individuelle

Étapes suivantes

Exécuter une petite charge de travail par lot avec des TPU et des VM à démarrage flexible