Exécuter des applications Cloud TPU sur GKE

Avertissement :Ces instructions ne s'appliquent qu'aux TPU utilisant l'architecture des nœuds 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 sur TPU v4, v5e ou v5p, consultez la page Déployer 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éez un cluster GKE compatible avec Cloud TPU
• Utiliser TensorBoard pour visualiser les métriques Cloud TPU 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 du workflow améliorées:GKE gère le cycle de vie des TPU. Une fois que vous avez configuré l'initialisation et l'entraînement de Cloud TPU avec GKE, vos charges de travail peuvent être répétées et géré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 des besoins en ressources d'un 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 Deployment) qui peuvent évoluer jusqu'à des centaines de pods GKE et de nœuds TPU.

• Tolérance aux pannes:l'API Job de GKE, ainsi que le mécanisme de point de contrôle TensorFlow, fournissent la sémantique d'exécution jusqu'à la fin. Si des échecs se produisent sur les instances de VM ou les nœuds Cloud TPU, vos tâches d'entraînement sont automatiquement réexécutées avec le dernier état lu à partir du point de contrôle.

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. Pour obtenir la liste des zones disponibles, consultez le document Types et zones.
• Vous devez utiliser des adresses IP conformes à la norme RFC 1918 pour vos clusters GKE. Pour en savoir 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. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

   Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

   Accéder au sélecteur de projet

3. Vérifiez que la facturation est activée pour votre projet Google Cloud.

4. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

   Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

   Accéder au sélecteur de projet

5. Vérifiez que la facturation est activée pour votre projet Google Cloud.

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 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 pour autoriser gcloud à effectuer des appels d'API Google Cloud avec vos identifiants.

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 pouvez vous servir d'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 VPC partagé, exécutez la commande présentée dans la section 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

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

   champs d'application

   Garantit que tous les nœuds du cluster ont accès à votre bucket Cloud Storage. Le cluster et le bucket de stockage doivent toutefois appartenir au même projet. 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 le champ d'application cloud-platform à tous les pods Kubernetes exécutés dans le cluster. Si vous souhaitez limiter l'accès par pod, consultez le guide 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. Spécifiez le IP_RANGE sous la forme IP/20, par exemple 10.100.0.0/20. Si vous ne spécifiez pas cet indicateur, une plage CIDR de taille /20 est automatiquement allouée et attribuée.

Une fois le cluster créé, un message de ce type doit s'afficher :

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 située sous le champ resource de 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. Consultez la section Types et zones des TPU pour obtenir la liste complète des ressources TPU valides.

  Si la ressource que vous prévoyez d'utiliser est un pod Cloud TPU, demandez un quota, car le quota par défaut des pods Cloud TPU est de 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 TPU Cloud TPU préemptif v2-8 avec TensorFlow 2.12.0.

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 la tâche dans le cluster GKE et pour installer kubectl

1. À l'aide d'un éditeur de texte, créez une spécification de pod example-job.yaml, puis copiez-collez 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érifiez que le pod GKE a été planifié et que les nœuds Cloud TPU ont été provisionnés. Un pod GKE demandant des nœuds Cloud TPU peut rester en attente pendant cinq minutes avant de s'exécuter. Tant que le pod GKE n'est pas planifié, un résultat semblable au suivant doit s'afficher.

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

   Au bout de cinq minutes environ, un message semblable à celui-ci devrait s'afficher :

   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

   La sortie obtenue 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 compatibilité avec Cloud TPU sur un cluster GKE existant, procédez comme suit 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 les éléments suivants :

• 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 un réseau VPC partagé et qui doivent utiliser des plages CIDR existantes. Si ce n'est pas votre cas d'utilisation, ignorez cette section.

Suivez le guide sur les TPU dans les clusters GKE utilisant un VPC partagé pour vérifier la configuration correcte de votre VPC partagé.

• Cluster GKE avec Cloud TPU dans un VPC partagé

Désactiver Cloud TPU dans un cluster

Important :La désactivation de la prise en charge de Cloud TPU supprime tous les TPU provisionnés par le cluster GKE. Toute charge de travail nécessitant Cloud TPU devient indisponible une fois l'opération démarrée.

Pour désactiver la compatibilité de Cloud TPU sur un cluster GKE existant, procédez comme suit 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 les éléments suivants :

   • 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 du cluster et project-name par le 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, exécutez la commande gsutil pour supprimer le bucket Cloud Storage que vous avez créé. Remplacez bucket-name par le nom de votre bucket Cloud Storage.

   $ gsutil rm -r gs://bucket-name