Exécuter une petite charge de travail par lot avec des GPU et le mode de provisionnement de démarrage Flex

Autopilot Standard

---

Preview — flex-start

Cette fonctionnalité est soumise 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 GPU pour les charges de travail d'entraînement de taille moyenne et petite en utilisant le mode de provisionnement à démarrage flexible. Dans ce guide, vous utilisez flex-start pour déployer une charge de travail composée de deux jobs Kubernetes. Chaque job nécessite un GPU. GKE provisionne automatiquement un nœud unique avec deux GPU A100 pour exécuter les deux jobs.

Si votre charge de travail nécessite un traitement distribué multinœud, envisagez d'utiliser flex-start avec provisionnement en file d'attente. Pour en savoir plus, consultez Exécuter une charge de travail à grande échelle avec le démarrage flexible et le provisionnement en file d'attente.

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 Flex-start

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 les tarifs 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 gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.
  Remarque : Pour les installations de 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 telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location. Vous devrez peut-être spécifier l'emplacement dans certaines commandes si l'emplacement de votre cluster diffère de celui 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 GPU préemptifs dans les emplacements de vos nœuds.

Si vous ne disposez pas de cluster ou si votre cluster ne répond pas aux exigences, vous pouvez créer un cluster régional Standard à l'aide de gcloud CLI. Ajoutez les indicateurs suivants pour en savoir plus sur flex-start :

--location=us-central1 \
--node-locations=us-central1-a,us-central1-b \
--machine-type=g2-standard-8

Lorsque vous créez un pool de nœuds à démarrage flexible, utilisez les options mentionnées précédemment et --accelerator type=nvidia-l4,count=1.

Si vous disposez d'un cluster Standard qui répond aux exigences, les sections suivantes vous guident dans la sélection d'un type d'accélérateur GPU et d'un type de machine pour votre cluster.

Choisir un type d'accélérateur GPU

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

La disponibilité des GPU est spécifique à chaque zone. Vous devez trouver un type d'accélérateur GPU disponible dans une zone où se trouve le cluster Standard. Si vous disposez d'un cluster Standard régional, la zone dans laquelle le type d'accélérateur GPU est disponible doit se trouver dans la région du cluster. Lorsque vous créez le pool de nœuds, vous spécifiez le type d'accélérateur et les zones pour les nœuds. Si vous spécifiez un type d'accélérateur qui n'est pas disponible dans l'emplacement du cluster, la création du pool de nœuds échoue.

Exécutez les commandes suivantes pour obtenir l'emplacement de votre cluster et un type d'accélérateur GPU compatible.

1. Obtenez l'emplacement du cluster :

   gcloud container clusters list
   

   Le résultat ressemble à ce qui suit :

   NAME                LOCATION  MASTER_VERSION      MASTER_IP     MACHINE_TYPE  NODE_VERSION        NUM_NODES  STATUS   STACK_TYPE
   example-cluster-1   us-west2  1.33.2-gke.1111000  34.102.3.122  e2-medium     1.33.2-gke.1111000  9          RUNNING  IPV4
   

2. Listez les types d'accélérateurs GPU disponibles, à l'exclusion des postes de travail virtuels dans le lieu :

   gcloud compute accelerator-types list | grep LOCATION_NAME | grep -v "Workstation"
   

   Remplacez LOCATION_NAME par l'emplacement du cluster.

   Par exemple, pour obtenir la liste des types d'accélérateurs GPU dans la région us-west2, exécutez la commande suivante :

   gcloud compute accelerator-types list | grep us-west2 | grep -v "Workstation"
   

   Le résultat ressemble à ce qui suit :

   nvidia-b200            us-west2-c                 NVIDIA B200 180GB
   nvidia-tesla-p4        us-west2-c                 NVIDIA Tesla P4
   nvidia-tesla-t4        us-west2-c                 NVIDIA T4
   nvidia-tesla-p4        us-west2-b                 NVIDIA Tesla P4
   nvidia-tesla-t4        us-west2-b                 NVIDIA T4
   

Choisir un type de machine compatible

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

Une fois que vous savez quels GPU sont disponibles dans l'emplacement du cluster, vous pouvez déterminer les types de machines compatibles. Google Cloud limite les GPU à des séries de machines spécifiques. Pour trouver un type de machine :

1. Consultez le tableau des modèles de GPU disponibles.
2. Recherchez la ligne correspondant au type d'accélérateur GPU que vous avez choisi.
3. Examinez la colonne "Série de machines" de cette ligne. Cette colonne indique la série de machines que vous devez utiliser.
4. Pour afficher les noms de types de machines que vous pouvez spécifier, cliquez sur le lien de la série de machines.

La seule exception concerne la série de machines N1, qui fournit des conseils supplémentaires sur les types de machines N1 que vous pouvez utiliser avec le type d'accélérateur choisi.

Avant d'utiliser une machine optimisée pour l'accélérateur, assurez-vous qu'elle est compatible avec le mode d'approvisionnement à démarrage flexible, comme indiqué dans Disponibilité des options de consommation par type de machine.

Déterminer le nombre d'accélérateurs

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, vous devez déterminer le nombre d'accélérateurs à associer à chaque nœud du pool de nœuds. Les valeurs valides dépendent de votre type d'accélérateur et de votre type de machine. Chaque type de machine est limité en termes de nombre de GPU qu'il peut prendre en charge. Pour déterminer la valeur à utiliser (en plus de la valeur par défaut 1) :

1. Reportez-vous à la section Types de machines avec GPU.
2. Dans le tableau, recherchez le type d'accélérateur correspondant à votre type de série de machines.
3. Utilisez la valeur de la colonne "Nombre de GPU".

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

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 flex-start activé sur un cluster standard existant, vous pouvez utiliser gcloud CLI ou Terraform.

gcloud

1. Créez un pool de nœuds avec flex-start :

   gcloud container node-pools create NODE_POOL_NAME \
       --cluster CLUSTER_NAME \
       --location LOCATION_NAME \
       --project PROJECT_ID \
       --accelerator type=ACCELERATOR_TYPE,count=COUNT \
       --machine-type MACHINE_TYPE \
       --max-run-duration MAX_RUN_DURATION \
       --flex-start \
       --node-locations NODE_ZONES \
       --num-nodes 0 \
       --enable-autoscaling \
       --total-min-nodes 0 \
       --total-max-nodes 5 \
       --location-policy ANY \
       --reservation-affinity none \
       --no-enable-autorepair
   

   Remplacez les éléments suivants :

   • NODE_POOL_NAME : nom que vous avez choisi pour votre pool de nœuds.
   • CLUSTER_NAME : nom du cluster Standard que vous souhaitez modifier.
   • LOCATION_NAME : région de calcul du plan de contrôle du cluster.
   • PROJECT_ID : ID de votre projet.
   • ACCELERATOR_TYPE : type spécifique d'accélérateur (par exemple, nvidia-tesla-t4 pour NVIDIA T4) à associer aux instances.
   • COUNT : nombre d'accélérateurs à associer aux instances. La valeur par défaut est 1.
   • MACHINE_TYPE : type de machine à utiliser pour les nœuds.
   • MAX_RUN_DURATION (facultatif) : Durée d'exécution maximale d'un nœud en secondes, jusqu'à la valeur par défaut de sept jours. Le numéro que vous saisissez doit se terminer par s. Par exemple, pour spécifier un jour, saisissez 86400s.
   • 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.

   Dans cette commande, l'indicateur --flex-start demande à gcloud de créer un pool de nœuds avec le démarrage Flex activé.

   GKE crée un pool de nœuds avec des nœuds contenant deux instances du type d'accélérateur spécifié. Le pool de nœuds ne contient initialement aucun nœud et l'autoscaling est activé.

2. Vérifiez l'état du démarrage flexible dans le pool de nœuds :

   gcloud container node-pools describe NODE_POOL_NAME \
       --cluster CLUSTER_NAME \
       --location LOCATION_NAME \
       --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.

Terraform

Vous pouvez utiliser flex-start avec des GPU à l'aide d'un module Terraform.

1. Ajoutez le bloc suivant à votre configuration Terraform :

resource "google_container_node_pool" " "gpu_dws_pool" {
name = "gpu-dws-pool"

queued_provisioning {
    enabled = false
}

}
node_config {
    machine_type = "MACHINE_TYPE"
    accelerator_type = "ACCELERATOR_TYPE"
    accelerator_count = COUNT
    node_locations = ["NODE_ZONES"]
    flex_start = true
}

Remplacez les éléments suivants :

• MACHINE_TYPE : type de machine à utiliser pour les nœuds.
• ACCELERATOR_TYPE : type spécifique d'accélérateur (par exemple, nvidia-tesla-t4 pour NVIDIA T4) à associer aux instances.
• COUNT : nombre d'accélérateurs à associer aux instances. La valeur par défaut est 1.
• 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.

Terraform appelle les API Google Cloud pour créer un cluster avec un pool de nœuds qui utilise le démarrage flexible avec des GPU. Le pool de nœuds ne contient initialement aucun nœud et l'autoscaling est activé. Pour en savoir plus sur Terraform, consultez la spécification de ressource google_container_node_pool sur terraform.io.

Exécuter une charge de travail par lot

Dans cette section, vous allez créer deux Jobs Kubernetes qui nécessitent chacun un GPU. 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.

1. Dans la Google Cloud console, 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 .

2. Créez un fichier nommé 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-accelerator: ACCELERATOR_TYPE
         containers:
         - name: container-1
           image: gcr.io/k8s-staging-perf-tests/sleep:latest
           args: ["10s"] # Sleep for 10 seconds
           resources:
             requests:
                 nvidia.com/gpu: 1
             limits:
                 nvidia.com/gpu: 1
         restartPolicy: OnFailure
   ---
   apiVersion: batch/v1
   kind: Job
   metadata:
     name: job-2
   spec:
     template:
       spec:
         nodeSelector:
           cloud.google.com/gke-flex-start: "true"
           cloud.google.com/gke-accelerator: ACCELERATOR_TYPE
         containers:
         - name: container-2
           image: gcr.io/k8s-staging-perf-tests/sleep:latest
           args: ["10s"] # Sleep for 10 seconds
           resources:
             requests:
                 nvidia.com/gpu: 1
             limits:
                 nvidia.com/gpu: 1
         restartPolicy: OnFailure
   

3. Appliquez le fichier manifeste dws-flex-start.yaml :

   kubectl apply -f dws-flex-start.yaml
   

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

   kubectl get pods -l "job-name in (job-1,job-2)" -o wide
   

   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>
   job-2   0/1     Completed   0          19m   10.(...) gke-flex-zonal-a2  <none>           <none>
   

Opération réussie : vous avez déployé deux jobs sur le même nœud à l'aide de flex-start. GKE a déployé deux jobs sur un nœud à démarrage flexible nouvellement provisionné.

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

Attention : La suppression d'un projet aura les effets suivants :
• Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
• Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.
1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Supprimer la ressource individuelle

1. Supprimez les jobs :

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

2. Supprimez le pool de nœuds :

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

3. Supprimez le cluster à l'aide de la commande suivante :

   gcloud container clusters delete CLUSTER_NAME
   

Étapes suivantes

• Apprenez-en plus sur les GPU 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.