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


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 l'utilisateur dans GKE Enterprise.

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.
  • 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.

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

Pour créer un pool de nœuds avec flex-start activé sur un cluster standard existant, vous pouvez utiliser gcloud CLI ou Terraform.

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

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=nvidia-a100-80gb,count=2 \
        --machine-type a2-ultragpu-2g \
        --max-run-duration MAX_RUN_DURATION \
        --flex-start \
        --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.
    • LOCATION_NAME : région de calcul du plan de contrôle du cluster.
    • PROJECT_ID : ID de votre projet.
    • CLUSTER_NAME : nom du cluster Standard que vous souhaitez modifier.
    • 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.

    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 GPU A100 (a2-ultragpu-2g). Ce pool de nœuds met automatiquement à l'échelle les nœuds de zéro à un maximum de cinq nœuds.

  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 :
```hcl
resource "google_container_node_pool" " "gpu_dws_pool" {
name = "gpu-dws-pool"

queued_provisioning {
    enabled = false
}

}
node_config {
    machine_type = "a3-highgpu-8g"
    flex_start = true
}
```

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 Icône d'activation Cloud Shell 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"
          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"
          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>
    

Effectuer un nettoyage

Pour éviter que les ressources utilisées sur cette page ne 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

  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