Exécuter des applications Cloud TPU sur GKE

Avertissement :Ces instructions ne s'appliquent qu'aux TPU utilisant l'architecture de nœud TPU. L'architecture de nœud TPU n'est compatible qu'avec GKE sur TPU v2 et v3. Ces instructions ne s'appliquent qu'aux TPU v2 et v3. Pour en savoir plus sur l'utilisation des TPU dans GKE, y compris TPU v4, v5e ou v5p, consultez Déployez des charges de travail TPU.

Ce guide vous explique comment :

• Mettre en place une configuration Cloud TPU en vue de son exécution sous Google Kubernetes Engine.
• Créer un cluster GKE avec Cloud TPU assistance
• Visualiser les métriques Cloud TPU à l'aide de TensorBoard et analyser les performances
• Créer et intégrer en conteneur votre modèle dans une image Docker.

Pour en savoir plus sur les architectures de VM TPU, consultez la page Architecture du système. Ce guide ne peut être utilisé qu'avec l'architecture de nœuds TPU.

Avantages de l'exécution d'applications Cloud TPU sur GKE

Les applications d'entraînement Cloud TPU peuvent être configurées pour s'exécuter dans des conteneurs GKE au sein de pods GKE. Opter pour cette solution procure les avantages suivants :

• Configuration et gestion améliorées des workflows:GKE gère tout au long du cycle de vie du TPU. Une fois que l'initialisation et l'entraînement de Cloud TPU sont configurés avec GKE, vos charges de travail peuvent être répétées par GKE, y compris la reprise après échec de tâche.

• Coût optimisé : vous n'êtes facturé pour le TPU que lorsque la tâche est active. GKE crée et supprime automatiquement les TPU en fonction d'une les besoins en ressources du pod.

• Flexibilité d'utilisation : vous n'avez que très peu de modifications à apporter dans la spécification de pod pour demander un accélérateur matériel différent (processeur, GPU ou TPU) :

  kind: Pod
  metadata:
    name: example-tpu
    annotations:
      # The Cloud TPUs that will be created for this Job will support
      # TensorFlow 2.12.1. This version MUST match the
      # TensorFlow version that your model is built on.
      tf-version.cloud-tpus.google.com: "2.12.1"
  spec:
    containers:
    - name: example-container
      resources:
        limits:
          cloud-tpus.google.com/v2: 8
          # See the line above for TPU, or below for CPU / GPU.
          # cpu: 2
          # nvidia.com/gpu: 1
  

• Évolutivité:GKE fournit des API (Job et le déploiement) peuvent s'adapter à des centaines de les pods GKE et les nœuds TPU.

• Tolérance aux pannes:l'API Job de GKE, ainsi que le mécanisme de point de contrôle TensorFlow, fournissent jusqu'à la fin. Vos jobs d'entraînement seront automatiquement réexécutés avec Dernier état lu à partir du point de contrôle en cas d'échec sur les instances de VM ou les nœuds Cloud TPU.

Configuration requise et limites de Cloud TPU et de GKE

Tenez compte des points suivants lors de la définition de la configuration GKE :

• Cloud TPU n'est pas compatible avec les pools de nœuds Windows Server.
• Vous devez créer les pools de nœuds et le cluster GKE dans une zone où Cloud TPU est disponible. Vous devez également créer des buckets Cloud Storage pour stocker vos données et modèles d'entraînement dans la même région que votre cluster GKE. Consultez le document Types et zones pour obtenir une liste des les zones disponibles.
• Vous devez utiliser des adresses IP conformes à la norme RFC 1918 pour vos clusters GKE. Pour plus consultez la page Mise en réseau GKE.
• Chaque conteneur ne peut demander qu'une ressource Cloud TPU. Toutefois, plusieurs conteneurs d'un pod peuvent en demander chacun une.

Avant de commencer

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

5. Make sure that billing is enabled for your Google Cloud project.

Lorsque vous exploitez Cloud TPU avec GKE, votre projet utilise des composants facturables de Google Cloud. Consultez la grille tarifaire de Cloud TPU et celle de GKE pour estimer vos coûts, et suivez les instructions permettant de nettoyer les ressources lorsque vous n'en avez plus besoin.

6. Activez les API suivantes dans la console Google Cloud:

   • API Cloud TPU
   • API Compute Engine
   • API GKE

Créer un cluster compatible avec Cloud TPU

Suivez les instructions ci-dessous pour configurer votre environnement et créer un un cluster GKE compatible avec Cloud TPU, à l'aide de la gcloud CLI:

1. Installez les composants gcloud dont vous avez besoin pour exécuter GKE avec Cloud TPU :

   $ gcloud components install kubectl 

2. Configurez gcloud avec l'ID de votre projet Google Cloud :

   $ gcloud config set project project-name
   

   Remplacez project-name par le nom de votre projet Google Cloud.

   La première fois que vous exécutez cette commande dans une nouvelle VM Cloud Shell, une page Authorize Cloud Shell s'affiche. Cliquez sur Authorize en bas de la page. de la page pour permettre à gcloud d'effectuer des appels d'API Google Cloud avec votre identifiants de connexion.

3. Configurez gcloud sur la zone dans laquelle vous prévoyez d'utiliser une ressource Cloud TPU. Cet exemple utilise us-central1-b, mais vous peuvent utiliser un TPU dans n'importe quelle zone compatible.

   $ gcloud config set compute/zone us-central1-b
   

4. Exécutez la commande gcloud container clusters create pour créer un cluster sur GKE compatible avec Cloud TPU.

   Remarque :Si vous devez spécifier une plage CIDR existante avec un bloc VPC partagé, utilisez la commande indiquée dans Utiliser une plage CIDR existante avec un VPC partagé.

   $ gcloud container clusters create cluster-name \
     --release-channel=stable \
     --scopes=cloud-platform \
     --enable-ip-alias \
     --enable-tpu
   

   Description des options de commande

   release-channel

   Canaux de publication permettent de gérer les mises à niveau automatiques de vos clusters. Lorsque vous créer un cluster, vous pouvez choisir sa version disponible. Votre cluster ne seront mis à niveau que vers les versions proposées dans ce canal.

   champs d'application

   Vérifiez que tous les nœuds du cluster ont accès à vos bucket Cloud Storage. Le cluster et le bucket de stockage doivent dans le même projet pour que cela fonctionne. Notez que les pods Kubernetes héritent par défaut des champs d'application des nœuds sur lesquels ils sont déployés. Par conséquent, scopes=cloud-platform donne à tous les pods Kubernetes s'exécutant dans le cluster au niveau d'accès cloud-platform. Si vous si vous souhaitez limiter l'accès par pod, consultez GKE sur l'authentification avec des comptes de service.

   enable-ip-alias

   Indique que le cluster utilise des plages d'adresses IP d'alias. Cette étape est obligatoire pour pouvoir utiliser Cloud TPU sur GKE.

   enable-tpu

   Indique que le cluster doit être compatible avec Cloud TPU.

   tpu-ipv4-cidr (facultatif, non spécifié ci-dessus)

   Indique la plage CIDR à utiliser pour Cloud TPU. Préciser IP_RANGE sous la forme IP/20, par exemple 10.100.0.0/20 Si vous ne spécifiez pas cet indicateur, La plage CIDR de taille /20 est automatiquement allouée et attribuée.

Une fois le cluster créé, un message semblable à celui-ci doit s'afficher : suivantes:

NAME             LOCATION       MASTER_VERSION    MASTER_IP     MACHINE_TYPE   NODE_VERSION      NUM_NODES  STATUS
cluster-name  us-central1-b  1.16.15-gke.4901  34.71.245.25  n1-standard-1  1.16.15-gke.4901  3          RUNNING

Demander une ressource Cloud TPU dans la spécification de pod Kubernetes

Dans la spécification de pod Kubernetes :

• Vous devez générer vos modèles dans des conteneurs avec la même version de TensorFlow. Consultez les versions compatibles.

• Spécifiez la ressource Cloud TPU dans la section limits sous la classe resource dans la spécification du conteneur.

  Notez que l'unité de la ressource Cloud TPU est le nombre de cœurs Cloud TPU. Le tableau suivant répertorie des exemples de demandes de ressources valides. Voir Types et zones des TPU pour obtenir la liste complète des ressources TPU valides.

  Si la ressource à utiliser est un pod Cloud TPU, quota de requêtes puisque le quota par défaut Le pod Cloud TPU a la valeur zéro.

  Demande de ressource	Type de ressource Cloud TPU
  cloud-tpus.google.com/v2: 8	Appareil Cloud TPU v2 (8 cœurs)
  cloud-tpus.google.com/preemptible-v2: 8	Appareil Cloud TPU préemptif v2 (8 cœurs)
  cloud-tpus.google.com/v3: 8	Appareil Cloud TPU v3 (8 cœurs)
  cloud-tpus.google.com/preemptible-v3: 8	Appareil Cloud TPU préemptif v3 (8 cœurs)
  cloud-tpus.google.com/v2: 32	Pod Cloud TPU v2-32 (32 cœurs)
  cloud-tpus.google.com/v3: 32	Pod Cloud TPU v3-32 (32 cœurs)

  Pour savoir comment indiquer des ressources et des limites dans la spécification de pod, consultez la documentation Kubernetes.

L'exemple de spécification de pod suivant demande un Cloud TPU préemptif TPU v2-8 avec TensorFlow 2.12.1.

La durée de vie des nœuds Cloud TPU dépend des pods Kubernetes qui les demandent. La ressource Cloud TPU est créée à la demande lors de la programmation du pod Kubernetes et elle est recyclée lorsque celui-ci est supprimé.

apiVersion: v1
kind: Pod
metadata:
  name: gke-tpu-pod
  annotations:
     # The Cloud TPUs that will be created for this Job will support
     # TensorFlow 2.12.1. This version MUST match the
     # TensorFlow version that your model is built on.
     tf-version.cloud-tpus.google.com: "2.12.1"
spec:
  restartPolicy: Never
  containers:
  - name: gke-tpu-container
    # The official TensorFlow 2.12.1 image.
    # https://hub.docker.com/r/tensorflow/tensorflow
    image: tensorflow/tensorflow:2.12.1
    command:
    - python
    - -c
    - |
      import tensorflow as tf
      print("Tensorflow version " + tf.__version__)

      tpu = tf.distribute.cluster_resolver.TPUClusterResolver('$(KUBE_GOOGLE_CLOUD_TPU_ENDPOINTS)')
      print('Running on TPU ', tpu.cluster_spec().as_dict()['worker'])

      tf.config.experimental_connect_to_cluster(tpu)
      tf.tpu.experimental.initialize_tpu_system(tpu)
      strategy = tf.distribute.TPUStrategy(tpu)

      @tf.function
      def add_fn(x,y):
          z = x + y
          return z

      x = tf.constant(1.)
      y = tf.constant(1.)
      z = strategy.run(add_fn, args=(x,y))
      print(z)
    resources:
      limits:
        # Request a single Preemptible v2-8 Cloud TPU device to train the model.
        cloud-tpus.google.com/preemptible-v2: 8

Créer la tâche

Suivez ces étapes pour créer le job dans le cluster GKE : et d'installer kubectl

1. À l'aide d'un éditeur de texte, créez une spécification de pod (example-job.yaml), puis copiez et collez dans la spécification de pod présentée précédemment.

2. Exécutez la tâche :

   $ kubectl create -f example-job.yaml
   

   pod "gke-tpu-pod" created

   Cette commande crée la tâche qui planifie automatiquement le pod.

3. Vérifier que le pod GKE a été planifié et que Cloud TPU a été planifié les nœuds ont été provisionnés. Un pod GKE demandant Les nœuds Cloud TPU peuvent être en attente pendant cinq minutes avant de s'exécuter. Toi jusqu'à ce que le cluster GKE Le pod est programmé.

   $ kubectl get pods -w
   
   NAME          READY     STATUS    RESTARTS   AGE
   gke-tpu-pod   0/1       Pending   0          1m
   

   <ph type="x-smartling-placeholder"></ph> Après cinq minutes environ, le résultat devrait ressembler à ceci:

   NAME          READY     STATUS              RESTARTS   AGE
   gke-tpu-pod   0/1       Pending             0          21s
   gke-tpu-pod   0/1       Pending             0          2m18s
   gke-tpu-pod   0/1       Pending             0          2m18s
   gke-tpu-pod   0/1       ContainerCreating   0          2m18s
   gke-tpu-pod   1/1       Running             0          2m48s
   gke-tpu-pod   0/1       Completed           0          3m8s
   

   Utilisez la combinaison de touches "Ctrl-C" pour quitter la commande "kubectl get".

   Vous pouvez afficher des informations de journal et récupérer des informations plus détaillées sur chaque pod GKE à l'aide des commandes kubectl suivantes. Par exemple, pour afficher la sortie du journal de votre pod GKE, utilisez :

   $ kubectl logs gke-tpu-pod

   Le résultat obtenu doit ressembler à ceci :

   2021-09-24 18:55:25.400699: I tensorflow/core/platform/cpu_feature_guard.cc:142]
   This TensorFlow binary is optimized with oneAPI Deep Neural Network Library
   (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA
   To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
   2021-09-24 18:55:25.405947: I tensorflow/core/distributed_runtime/rpc/grpc_channel.cc:272]
   Initialize GrpcChannelCache for job worker -> {0 -> 10.0.16.2:8470}
   2021-09-24 18:55:25.406058: I tensorflow/core/distributed_runtime/rpc/grpc_channel.cc:272]
   Initialize GrpcChannelCache for job localhost -> {0 -> localhost:32769}
   2021-09-24 18:55:28.091729: I tensorflow/core/distributed_runtime/rpc/grpc_channel.cc:272]
   Initialize GrpcChannelCache for job worker -> {0 -> 10.0.16.2:8470}
   2021-09-24 18:55:28.091896: I tensorflow/core/distributed_runtime/rpc/grpc_channel.cc:272]
   Initialize GrpcChannelCache for job localhost -> {0 -> localhost:32769}
   2021-09-24 18:55:28.092579: I tensorflow/core/distributed_runtime/rpc/grpc_server_lib.cc:427]
   Started server with target: grpc://localhost:32769
   Tensorflow version 2.12.1
   Running on TPU  ['10.0.16.2:8470']
   PerReplica:{
     0: tf.Tensor(2.0, shape=(), dtype=float32),
     1: tf.Tensor(2.0, shape=(), dtype=float32),
     2: tf.Tensor(2.0, shape=(), dtype=float32),
     3: tf.Tensor(2.0, shape=(), dtype=float32),
     4: tf.Tensor(2.0, shape=(), dtype=float32),
     5: tf.Tensor(2.0, shape=(), dtype=float32),
     6: tf.Tensor(2.0, shape=(), dtype=float32),
     7: tf.Tensor(2.0, shape=(), dtype=float32)
   }
   

   Pour afficher une description complète du pod GKE, utilisez :

   $ kubectl describe pod gke-tpu-pod
   

   Pour en savoir plus, consultez la page Présentation et débogage des applications.

Créer et intégrer en conteneur votre modèle dans une image Docker

Consultez la section Créer et intégrer en conteneur votre modèle pour en savoir plus sur ce processus.

Activer la compatibilité avec Cloud TPU sur un cluster existant

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

Pour activer la prise en charge de Cloud TPU sur un cluster GKE existant : effectuer les étapes suivantes dans la Google Cloud CLI:

1. Activez la compatibilité avec Cloud TPU :

   gcloud beta container clusters update cluster-name --enable-tpu
   

   Remplacez cluster-name par le nom de votre cluster.

   Important : Le point de terminaison du serveur d'API d'origine peut ne pas être disponible après la mise à jour du cluster.

2. Mettez à jour l'entrée kubeconfig :

   gcloud container clusters get-credentials cluster-name
   

Définir une plage CIDR personnalisée

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

Par défaut, GKE alloue un bloc CIDR de taille /20 pour les TPU provisionnés par le cluster. Vous pouvez spécifier une plage CIDR personnalisée pour la ressource Cloud TPU en exécutant la commande suivante :

gcloud beta container clusters update cluster-name \
  --enable-tpu \
  --tpu-ipv4-cidr 10.100.0.0/20

Remplacez l'élément suivant :

• cluster-name : nom de votre cluster existant.
• 10.100.0.0/20 : votre plage CIDR personnalisée.

Utiliser des plages CIDR existantes avec un VPC partagé

Remarque :Cette section s'adresse aux utilisateurs qui déploient un cluster dans les réseaux VPC partagés qui doivent utiliser des réseaux Plages CIDR. Si ce n'est pas votre cas d'utilisation, ignorez cette section.

Suivez le guide sur les TPU dans des clusters GKE utilisant un VPC partagé pour vérifier pour votre VPC partagé.

• Cluster GKE avec Cloud TPU utilisant un VPC partagé

Désactiver Cloud TPU dans un cluster

Important :Si vous désactivez la prise en charge de Cloud TPU, tous les TPU seront supprimés. provisionnés par le cluster GKE. Toute charge de travail nécessitant Les Cloud TPU deviennent indisponibles une fois l'opération démarrée.

Pour désactiver la compatibilité de Cloud TPU sur un cluster GKE existant : effectuer les étapes suivantes dans la Google Cloud CLI:

1. Vérifiez qu'aucune de vos charges de travail n'utilise Cloud TPU :

   $ kubectl get tpu
   

2. Désactivez la prise en charge de Cloud TPU dans votre cluster :

   $ gcloud beta container clusters update cluster-name --no-enable-tpu
   

   Remplacez cluster-name par le nom de votre cluster.

   Pour les clusters zonaux, cette opération prend environ cinq minutes. Pour les clusters régionaux, elle prend environ 15 minutes, selon la région du cluster.

3. Une fois les opérations terminées sans erreur, vous pouvez vérifier que les TPU provisionnés par le cluster ont été supprimés :

   $ gcloud compute tpus list
   

   Les noms des TPU créés par Cloud TPU sont au format suivant :

   $ gke-cluster-name-cluster-id-tpu-tpu-id
   

   Remplacez l'élément suivant :

   • cluster-name : nom de votre cluster existant.
   • cluster-id : ID de votre cluster existant.
   • tpu-id : ID de la ressource Cloud TPU.

   Si des TPU apparaissent, vous pouvez les supprimer manuellement en exécutant la commande suivante :

   $ gcloud compute tpus delete gke-cluster-name-cluster-id-tpu-tpu-id
   

Effectuer un nettoyage

Une fois que vous n'avez plus besoin d'utiliser Cloud TPU sur GKE, nettoyez les ressources pour éviter que des frais supplémentaires ne soient imputés à votre compte de facturation Cloud.

1. Exécutez la commande suivante pour supprimer votre cluster GKE : en remplaçant cluster-name par le nom de votre cluster et project-name par votre Nom du projet Google Cloud:

   $ gcloud container clusters delete cluster-name \
   --project=project-name --zone=us-central1-b
   

2. Lorsque vous avez fini d'examiner les données, utilisez la gcloud CLI pour supprimer le bucket Cloud Storage que vous avez créé. Remplacez bucket-name par le nom de votre bucket Cloud Storage :

   $ gcloud storage rm gs://bucket-name --recursive