Créer et exécuter une tâche qui utilise des GPU

Ce document explique comment créer et exécuter une tâche qui utilise un processeur graphique (GPU). Pour en savoir plus sur les fonctionnalités et les restrictions des GPU, consultez la section À propos des GPU dans la documentation Compute Engine.

Lorsque vous créez une tâche par lot, vous pouvez éventuellement utiliser des GPU pour accélérer des charges de travail spécifiques. Les cas d'utilisation courants des tâches qui utilisent des GPU incluent le traitement intensif des données et les charges de travail d'intelligence artificielle (IA), telles que le machine learning (ML).

Avant de commencer

  1. Si vous n'avez jamais utilisé Batch, consultez Premiers pas avec Batch et activez Batch en remplissant les conditions préalables pour les projets et les utilisateurs.

  2. Pour obtenir les autorisations nécessaires pour créer un job, demandez à votre administrateur de vous accorder les rôles IAM suivants:

    Pour en savoir plus sur l'attribution de rôles, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations.

    Vous pouvez également obtenir les autorisations requises via des rôles personnalisés ou d'autres rôles prédéfinis.

Créer une tâche qui utilise des GPU

Pour créer une tâche qui utilise des GPU, procédez comme suit:

  1. Planifiez les exigences d'une tâche qui utilise des GPU.
  2. Créez une tâche avec les exigences et les méthodes que vous avez identifiées. Pour savoir comment créer une tâche à l'aide des options recommandées, consultez la section Créer un exemple de tâche qui utilise des GPU de ce document.

Planifier les exigences d'une tâche qui utilise des GPU

Avant de créer une tâche qui utilise des GPU, planifiez les exigences de la tâche comme expliqué dans les sections suivantes:

  1. Sélectionner le type de machine GPU et la méthode de provisionnement
  2. Installer les pilotes de GPU
  3. Définir les ressources de VM compatibles

Étape 1: Sélectionnez le type de machine GPU et la méthode de provisionnement

Les exigences d'une tâche varient en fonction du type de machine GPU et de la méthode de provisionnement que vous préférez. Les options de chacune peuvent être interdépendantes. En fonction de vos exigences et de vos priorités, vous pouvez d'abord sélectionner le type de machine avec GPU ou la méthode de provisionnement. En général, le type de machine GPU affecte principalement les performances et le prix de base, tandis que la méthode de provisionnement affecte principalement la disponibilité des ressources, ainsi que les coûts ou remises supplémentaires.

Sélectionner le type de machine GPU

Les types de machines GPU disponibles (les combinaisons valides de type de GPU, de nombre de GPU et de type de machine (vCPU et mémoire)) et leurs cas d'utilisation sont listés sur la page Types de machines GPU de la documentation Compute Engine.

Les champs requis pour qu'une tâche spécifie un type de machine GPU varient en fonction des catégories du tableau suivant:

Types de machines avec GPU et exigences de tâche

GPU pour les VM optimisées pour les accélérateurs: les VM dont le type de machine appartient à la famille de machines optimisées pour les accélérateurs sont associées automatiquement à un type et un nombre spécifiques de ces GPU.

Pour utiliser des GPU pour les VM optimisées pour les accélérateurs, nous vous recommandons de spécifier le type de machine. Chaque type de machine optimisé pour les accélérateurs n'est compatible qu'avec un type et un nombre spécifiques de GPU. Il est donc fonctionnellement équivalent que vous spécifiiez ou non ces valeurs en plus du type de machine optimisé pour les accélérateurs.

Plus précisément, Batch ne permet également de spécifier que le type et le nombre de GPU pour les VM optimisées pour l'accélérateur, mais les options de processeurs virtuels et de mémoire qui en résultent sont souvent très limitées. C'est pourquoi nous vous recommandons de vérifier que les options de vCPU et de mémoire disponibles sont compatibles avec les exigences de la tâche de l'ordre de travail.

GPU pour les VM N1: vous devez spécifier le type et la quantité à associer à chaque VM. Ils doivent être associés à des VM avec un type de machine de la série de machines N1.

Pour utiliser des GPU pour les VM N1, nous vous recommandons de spécifier au moins le type et le nombre de GPU. Assurez-vous que la combinaison de valeurs correspond à l'une des options de GPU valides pour les types de machines N1. Les options de processeurs virtuels et de mémoire pour les VM N1 qui utilisent un type et un nombre de GPU spécifiques sont très flexibles. Sauf si vous créez la tâche à l'aide de la console Google Cloud, vous pouvez laisser Batch sélectionner automatiquement un type de machine qui répond aux exigences de la tâche de la tâche.
Sélectionner la méthode de provisionnement

Batch utilise différentes méthodes pour provisionner les ressources de VM pour les tâches qui utilisent des GPU en fonction du type de ressources demandées par votre tâche. Les méthodes de provisionnement disponibles et leurs exigences sont expliquées dans le tableau suivant, qui les liste en fonction de leurs cas d'utilisation: de la disponibilité des ressources la plus élevée à la plus faible.

En résumé, nous recommandons à la plupart des utilisateurs d'effectuer les opérations suivantes:

  • Si vous prévoyez d'utiliser des types de machines GPU A3 sans réservation, utilisez le planificateur de charges de travail dynamique pour le traitement par lot (version Preview).

  • Pour tous les autres types de machines GPU, utilisez la méthode de provisionnement par défaut. La méthode de provisionnement par défaut est généralement à la demande. Une exception est faite si votre projet dispose de réservations inutilisées que la tâche peut consommer automatiquement.

Méthodes de provisionnement et exigences liées aux postes

Réservations

  • Cas d'utilisation: nous vous recommandons de réserver des tâches si vous souhaitez un niveau de garantie très élevé de la disponibilité des ressources ou si vous disposez déjà de réservations qui pourraient être inutilisées.

  • Détails: une réservation entraîne les coûts des VM spécifiées au même prix que l'exécution des VM jusqu'à ce que vous supprimiez la réservation. Les VM qui utilisent une réservation n'entraînent pas de frais distincts, mais les réservations génèrent des frais, quelle que soit la consommation.

Le traitement par lot utilise des réservations pour les tâches pouvant utiliser des réservations inutilisées. Pour en savoir plus sur les réservations et leurs exigences, consultez la page Assurer la disponibilité des ressources à l'aide de réservations de VM.

Planificateur de charge de travail dynamique pour les tâches par lot (aperçu)

  • Cas d'utilisation: nous vous recommandons d'utiliser le planificateur de charges de travail dynamique si vous souhaitez utiliser des GPU pour des VM avec un type de machine de la série de machines A3 sans consommer de réservation.

  • Détails: Le planificateur de charges de travail dynamique peut vous permettre d'accéder plus facilement à de nombreuses ressources qui accélèrent les charges de travail d'IA et de ML. Par exemple, le planificateur de charges de travail dynamique peut être utile pour planifier les tâches en atténuant les retards ou les problèmes causés par la non-disponibilité des ressources.

Le traitement par lot utilise le planificateur de charges de travail dynamique pour les jobs qui remplissent toutes les conditions suivantes:

  • Spécifiez un type de machine GPU A3.
  • Bloquer les réservations Plus précisément, la tâche doit définir le champ reservation sur NO_RESERVATION. Pour en savoir plus, consultez la section Créer et exécuter une tâche qui ne peut pas consommer de VM réservées.
  • N'utilisez pas de VM Spot. Plus précisément, la tâche peut omettre le champ provisioningModel ou définir le champ provisioningModel sur STANDARD.

À la demande

  • Cas d'utilisation: nous vous recommandons d'utiliser la méthode à la demande pour toutes les autres tâches.

  • Détails: l'accès à la demande est généralement le moyen par défaut d'accéder aux VM Compute Engine. Le modèle à la demande vous permet de demander des ressources et d'y accéder immédiatement (si elles sont disponibles) une VM à la fois.

Le traitement par lot utilise le traitement à la demande pour toutes les autres tâches.

Spot VM

  • Cas d'utilisation: nous vous recommandons d'essayer d'utiliser des VM Spot pour réduire les coûts des charges de travail tolérantes aux pannes.

  • Détails: Les VM Spot offrent des remises importantes, mais peuvent ne pas toujours être disponibles et peuvent être préemptées à tout moment. Pour en savoir plus, consultez la section VM Spot dans la documentation Compute Engine.

Le traitement par lot utilise des VM Spot pour les tâches qui définissent le champ provisioningModel sur SPOT.

Étape 2: Installez les pilotes de GPU

Pour utiliser des GPU pour un job, vous devez installer les pilotes de GPU. Pour installer des pilotes de GPU, sélectionnez l'une des méthodes suivantes:

  • Installer automatiquement les pilotes de GPU (recommandé si possible) : comme indiqué dans les exemples, pour autoriser Batch à récupérer les pilotes de GPU requis à partir d'un emplacement tiers et à les installer en votre nom, définissez le champ installGpuDrivers du job sur true. Cette méthode est recommandée si votre tâche ne nécessite pas d'installer manuellement les pilotes.

    Si vous devez spécifier la version du pilote de GPU que Batch installe, vous pouvez également définir le champ driverVersion.

  • Installer manuellement les pilotes de GPU:cette méthode est requise si l'une des conditions suivantes est remplie:

    Pour installer manuellement les pilotes de GPU requis, nous vous recommandons de suivre la méthode suivante:

    1. Créez une image de VM personnalisée qui inclut les pilotes de GPU.

      1. Pour installer des pilotes de GPU, exécutez un script d'installation en fonction de l'OS que vous souhaitez utiliser:

      2. Si votre tâche contient des exécutables de conteneur et n'utilise pas Container-Optimized OS, vous devez également installer le NVIDIA Container Toolkit.

    2. Lorsque vous créez et envoyez une tâche qui utilise des GPU, spécifiez l'image de VM personnalisée qui inclut les pilotes de GPU, puis définissez le champ installGpuDrivers de la tâche sur false (valeur par défaut).

Étape 3: Définir les ressources de VM compatibles

Pour en savoir plus sur les exigences et les options de définition des ressources de VM pour une tâche, consultez la section Ressources de tâche.

En résumé, vous devez effectuer toutes les opérations suivantes lorsque vous définissez les ressources de VM pour une tâche qui utilise des GPU:

  • Assurez-vous que le type de machine GPU est disponible à l'emplacement des VM de votre tâche.

    Pour savoir où les types de machines avec GPU sont disponibles, consultez la page Disponibilité des GPU par région et zone de la documentation Compute Engine.

  • Si vous spécifiez le type de machine de la tâche, assurez-vous qu'il dispose de suffisamment de vCPU et de mémoire pour répondre aux exigences de la tâche. Vous devez spécifier le type de machine de la tâche chaque fois que vous en créez une à l'aide de la console Google Cloud. Il est également recommandé de le faire lorsque vous créez une tâche qui utilise des GPU pour des VM optimisées pour les accélérateurs.

  • Assurez-vous de définir les ressources de VM pour une tâche à l'aide d'une méthode valide:

    • Définissez directement les ressources de la VM à l'aide du champ instances[].policy (recommandé si possible). Cette méthode est illustrée dans les exemples.
    • Définissez les ressources de VM via un modèle à l'aide du champ instances[].instanceTemplate. Cette méthode est requise pour installer manuellement les pilotes de GPU via une image personnalisée. Pour en savoir plus, consultez la section Définir des ressources de tâche à l'aide d'un modèle d'instance de VM.

Créer un exemple de tâche qui utilise des GPU

Les sections suivantes expliquent comment créer un exemple de tâche pour chaque type de machine GPU à l'aide des options recommandées. Plus précisément, les exemples de jobs installent tous automatiquement les pilotes de GPU, définissent tous directement les ressources de VM et spécifient la méthode de provisionnement ou utilisent la méthode de provisionnement par défaut.

Utiliser des GPU pour les VM A3 via le planificateur de charges de travail dynamique pour le traitement par lot (bêta)

Vous pouvez créer une tâche qui utilise des GPU pour les VM A3 via le planificateur de charges de travail dynamique à l'aide de la gcloud CLI ou de l'API Batch.

gcloud

  1. Créez un fichier JSON qui installe les pilotes de GPU, spécifie un type de machine de la série de machines A3, bloque les réservations et s'exécute dans un emplacement qui possède le type de machine GPU.

    Par exemple, pour créer une tâche de script de base qui utilise des GPU pour les VM A3 via le planificateur de charge de travail dynamique, créez un fichier JSON avec le contenu suivant:

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Remplacez les éléments suivants :

    • INSTALL_GPU_DRIVERS: lorsque la valeur est true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans le champ policy à partir d'un emplacement tiers et les installe en votre nom. Si vous définissez ce champ sur false (valeur par défaut), vous devez installer manuellement les pilotes de GPU pour utiliser des GPU pour ce job.

    • MACHINE_TYPE: type de machine de la série de machines A3.

    • ALLOWED_LOCATIONS: vous pouvez éventuellement utiliser le champ allowedLocations[] pour spécifier une région ou une ou plusieurs zones spécifiques dans une région où les VM de votre tâche sont autorisées à s'exécuter. Par exemple, regions/us-central1 autorise toutes les zones de la région us-central1. Assurez-vous de spécifier les zones qui proposent le type de machine GPU que vous souhaitez pour cette tâche. Sinon, si vous omettez ce champ, assurez-vous que l'emplacement de la tâche propose le type de machine GPU.

  2. Pour créer et exécuter la tâche, utilisez la commande gcloud batch jobs submit:

    gcloud batch jobs submit JOB_NAME \
    --location LOCATION \
    --config JSON_CONFIGURATION_FILE

    Remplacez les éléments suivants :

    • JOB_NAME: nom de la tâche.

    • LOCATION: emplacement de la tâche.

    • JSON_CONFIGURATION_FILE: chemin d'accès à un fichier JSON contenant les détails de configuration de la tâche.

API

Envoyez une requête POST à la méthode jobs.create qui installe les pilotes de GPU, spécifie un type de machine de la série de machines A3, bloque les réservations et s'exécute dans un emplacement disposant du type de machine GPU.

Par exemple, pour créer une tâche de script de base qui utilise des GPU pour les VM A3 via le programmeur de charge de travail dynamique, envoyez la requête suivante:

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Remplacez les éléments suivants :

  • PROJECT_ID: ID de projet de votre projet.

  • LOCATION: emplacement de la tâche.

  • JOB_NAME: nom de la tâche.

  • INSTALL_GPU_DRIVERS: lorsque la valeur est true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans le champ policy à partir d'un emplacement tiers et les installe en votre nom. Si vous définissez ce champ sur false (valeur par défaut), vous devez installer manuellement les pilotes de GPU pour utiliser des GPU pour ce job.

  • MACHINE_TYPE: type de machine de la série de machines A3.

  • ALLOWED_LOCATIONS: vous pouvez éventuellement utiliser le champ allowedLocations[] pour spécifier une région ou une ou plusieurs zones spécifiques dans une région où les VM de votre tâche sont autorisées à s'exécuter. Par exemple, regions/us-central1 autorise toutes les zones de la région us-central1. Assurez-vous de spécifier les zones qui proposent le type de machine GPU que vous souhaitez pour cette tâche. Sinon, si vous omettez ce champ, assurez-vous que l'emplacement de la tâche propose le type de machine GPU.

Utiliser des GPU pour les VM optimisées pour les accélérateurs

Vous pouvez créer un job qui utilise des GPU pour les VM optimisées pour les accélérateurs à l'aide de la console Google Cloud, de gcloud CLI, de l'API Batch, de Java, de Node.js ou de Python.

Console

Pour créer une tâche qui utilise des GPU à l'aide de la console Google Cloud, procédez comme suit:

  1. Dans la console Google Cloud, accédez à la page Liste des jobs.

    Accéder à la liste des tâches

  2. Cliquez sur Créer. La page Créer une tâche par lot s'ouvre. Dans le volet de gauche, la page Informations sur la tâche est sélectionnée.

  3. Configurez la page Informations sur la tâche:

    1. (Facultatif) Dans le champ Nom de la tâche, personnalisez le nom de la tâche.

      Par exemple, saisissez example-gpu-job.

    2. Configurez la section Détails de la tâche:

      1. Dans la fenêtre Nouvel exécutable, ajoutez au moins un script ou un conteneur pour que cette tâche s'exécute.

        Par exemple, pour créer une tâche de script de base, procédez comme suit:

        1. Cochez la case Script. Un champ s'affiche.

        2. Dans le champ, saisissez le script suivant:

          echo Hello world from task ${BATCH_TASK_INDEX}.

        3. Cliquez sur OK.

      2. Dans le champ Nombre de tâches, saisissez le nombre de tâches pour cette tâche.

        Par exemple, saisissez 3.

      3. Facultatif: dans le champ Parallélisme, saisissez le nombre de tâches à exécuter simultanément.

        Par exemple, saisissez 1 (valeur par défaut).

  4. Configurez la page Spécifications de la ressource:

    1. Dans le volet de gauche, cliquez sur Spécifications des ressources. La page Spécifications des ressources s'ouvre.

    2. Facultatif: dans la section Modèle de provisionnement de VM, sélectionnez l'une des options suivantes pour le modèle de provisionnement des VM de cette tâche:

      • Si votre tâche peut résister à la préemption et que vous souhaitez obtenir des VM à prix réduit, sélectionnez Spot.

      • Sinon, sélectionnez Standard (par défaut).

    3. Sélectionnez l'emplacement de cette tâche.

      1. Dans le champ Région, sélectionnez une région.

      2. Dans le champ Zone, effectuez l'une des opérations suivantes:

        • Si vous souhaitez limiter l'exécution de cette tâche à une zone spécifique, sélectionnez-la.

        • Sinon, sélectionnez Tous (par défaut).

    4. Sélectionnez le type de machine GPU pour les VM de cette tâche:

      1. Dans les options de famille de machines, cliquez sur GPU.

      2. Dans le champ Type de GPU, sélectionnez le type de GPU. Ensuite, dans le champ Nombre de GPU, sélectionnez le nombre de GPU pour chaque VM.

        Si vous avez sélectionné l'un des types de GPU pour les VM optimisées pour l'accélérateur, le champ Type de machine n'autorise qu'une seule option pour le type de machine en fonction du type et du nombre de GPU que vous avez sélectionnés.

      3. Pour installer automatiquement les pilotes de GPU, sélectionnez Installation du pilote de GPU (par défaut).

    5. Configurez la quantité de ressources de VM requise pour chaque tâche:

      1. Dans le champ Cœurs, saisissez le nombre de processeurs virtuels par tâche.

        Par exemple, saisissez 1 (valeur par défaut).

      2. Dans le champ Mémoire, saisissez la quantité de RAM en Go par tâche.

        Par exemple, saisissez 0.5 (valeur par défaut).

    6. Cliquez sur OK.

  5. Facultatif: Configurez les autres champs de cette tâche.

  6. Facultatif: Pour examiner la configuration de la tâche, dans le volet de gauche, cliquez sur Aperçu.

  7. Cliquez sur Créer.

    La page Détails de la tâche affiche la tâche que vous avez créée.

gcloud

  1. Créez un fichier JSON qui installe les pilotes de GPU, spécifie un type de machine de la famille de machines optimisées pour les accélérateurs et s'exécute dans un emplacement qui dispose du type de machine GPU.

    Par exemple, pour créer une tâche de script de base qui utilise des GPU pour les VM optimisées pour les accélérateurs, créez un fichier JSON avec le contenu suivant:

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Remplacez les éléments suivants :

    • INSTALL_GPU_DRIVERS: lorsque la valeur est true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans le champ policy à partir d'un emplacement tiers et les installe en votre nom. Si vous définissez ce champ sur false (valeur par défaut), vous devez installer manuellement les pilotes de GPU pour utiliser des GPU pour ce job.

    • MACHINE_TYPE: type de machine de la famille de machines optimisées pour les accélérateurs.

    • ALLOWED_LOCATIONS: vous pouvez éventuellement utiliser le champ allowedLocations[] pour spécifier une région ou une ou plusieurs zones spécifiques dans une région où les VM de votre tâche sont autorisées à s'exécuter. Par exemple, regions/us-central1 autorise toutes les zones de la région us-central1. Assurez-vous de spécifier les zones qui proposent le type de machine GPU que vous souhaitez pour cette tâche. Sinon, si vous omettez ce champ, assurez-vous que l'emplacement de la tâche propose le type de machine GPU.

  2. Pour créer et exécuter la tâche, utilisez la commande gcloud batch jobs submit:

    gcloud batch jobs submit JOB_NAME \
    --location LOCATION \
    --config JSON_CONFIGURATION_FILE

    Remplacez les éléments suivants :

    • JOB_NAME: nom de la tâche.

    • LOCATION: emplacement de la tâche.

    • JSON_CONFIGURATION_FILE: chemin d'accès à un fichier JSON contenant les détails de configuration de la tâche.

API

Envoyez une requête POST à la méthode jobs.create qui installe les pilotes de GPU, spécifie un type de machine de la famille de machines optimisées pour les accélérateurs et s'exécute dans un emplacement qui possède le type de machine GPU.

Par exemple, pour créer une tâche de script de base qui utilise des GPU pour les VM optimisées pour l'accélérateur, envoyez la requête suivante:

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Remplacez les éléments suivants :

  • PROJECT_ID: ID de projet de votre projet.

  • LOCATION: emplacement de la tâche.

  • JOB_NAME: nom de la tâche.

  • INSTALL_GPU_DRIVERS: lorsque la valeur est true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans le champ policy à partir d'un emplacement tiers et les installe en votre nom. Si vous définissez ce champ sur false (valeur par défaut), vous devez installer manuellement les pilotes de GPU pour utiliser des GPU pour ce job.

  • MACHINE_TYPE: type de machine de la famille de machines optimisées pour les accélérateurs.

  • ALLOWED_LOCATIONS: vous pouvez éventuellement utiliser le champ allowedLocations[] pour spécifier une région ou une ou plusieurs zones spécifiques dans une région où les VM de votre tâche sont autorisées à s'exécuter. Par exemple, regions/us-central1 autorise toutes les zones de la région us-central1. Assurez-vous de spécifier les zones qui proposent le type de machine GPU que vous souhaitez pour cette tâche. Sinon, si vous omettez ce champ, assurez-vous que l'emplacement de la tâche propose le type de machine GPU.

Java 


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.Accelerator;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicyOrTemplate;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.Runnable.Script;
import com.google.cloud.batch.v1.TaskGroup;
import com.google.cloud.batch.v1.TaskSpec;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateGpuJob {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the region you want to use to run the job. Regions that are
    // available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
    String region = "europe-central2";
    // The name of the job that will be created.
    // It needs to be unique for each project and region pair.
    String jobName = "JOB_NAME";
    // Optional. When set to true, Batch fetches the drivers required for the GPU type
    // that you specify in the policy field from a third-party location,
    // and Batch installs them on your behalf. If you set this field to false (default),
    // you need to install GPU drivers manually to use any GPUs for this job.
    boolean installGpuDrivers = false;
    // Accelerator-optimized machine types are available to Batch jobs. See the list
    // of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
    String machineType = "g2-standard-4";

    createGpuJob(projectId, region, jobName, installGpuDrivers, machineType);
  }

  // Create a job that uses GPUs
  public static Job createGpuJob(String projectId, String region, String jobName,
                                  boolean installGpuDrivers, String machineType)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {
      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(
                          "echo Hello world! This is task ${BATCH_TASK_INDEX}. "
                                  + "This job has a total of ${BATCH_TASK_COUNT} tasks.")
                      // You can also run a script from a file. Just remember, that needs to be a
                      // script that's already on the VM that will be running the job.
                      // Using setText() and setPath() is mutually exclusive.
                      // .setPath("/tmp/test.sh")
                      .build())
              .build();

      TaskSpec task = TaskSpec.newBuilder()
                  // Jobs can be divided into tasks. In this case, we have only one task.
                  .addRunnables(runnable)
                  .setMaxRetryCount(2)
                  .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
                  .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder()
          .setTaskCount(3)
          .setParallelism(1)
          .setTaskSpec(task)
          .build();

      // Policies are used to define on what kind of virtual machines the tasks will run.
      // Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
      InstancePolicy instancePolicy =
          InstancePolicy.newBuilder().setMachineType(machineType).build();  

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setInstallGpuDrivers(installGpuDrivers)
                      .setPolicy(instancePolicy)
                      .build())
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(LogsPolicy.Destination.CLOUD_LOGGING))
              .build();

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run.
              .setParent(String.format("projects/%s/locations/%s", projectId, region))
              .setJob(job)
              .setJobId(jobName)
              .build();

      Job result =
          batchServiceClient
              .createJobCallable()
              .futureCall(createJobRequest)
              .get(5, TimeUnit.MINUTES);

      System.out.printf("Successfully created the job: %s", result.getName());

      return result;
    }
  }
}

Node.js 

// Imports the Batch library
const batchLib = require('@google-cloud/batch');
const batch = batchLib.protos.google.cloud.batch.v1;

// Instantiates a client
const batchClient = new batchLib.v1.BatchServiceClient();

/**
 * TODO(developer): Update these variables before running the sample.
 */
// Project ID or project number of the Google Cloud project you want to use.
const projectId = await batchClient.getProjectId();
// Name of the region you want to use to run the job. Regions that are
// available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
const region = 'europe-central2';
// The name of the job that will be created.
// It needs to be unique for each project and region pair.
const jobName = 'batch-gpu-job';
// The GPU type. You can view a list of the available GPU types
// by using the `gcloud compute accelerator-types list` command.
const gpuType = 'nvidia-l4';
// The number of GPUs of the specified type.
const gpuCount = 1;
// Optional. When set to true, Batch fetches the drivers required for the GPU type
// that you specify in the policy field from a third-party location,
// and Batch installs them on your behalf. If you set this field to false (default),
// you need to install GPU drivers manually to use any GPUs for this job.
const installGpuDrivers = false;
// Accelerator-optimized machine types are available to Batch jobs. See the list
// of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
const machineType = 'g2-standard-4';

// Define what will be done as part of the job.
const runnable = new batch.Runnable({
  script: new batch.Runnable.Script({
    commands: ['-c', 'echo Hello world! This is task ${BATCH_TASK_INDEX}.'],
  }),
});

const task = new batch.TaskSpec({
  runnables: [runnable],
  maxRetryCount: 2,
  maxRunDuration: {seconds: 3600},
});

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup({
  taskCount: 3,
  taskSpec: task,
});

// Policies are used to define on what kind of virtual machines the tasks will run on.
// In this case, we tell the system to use "g2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const instancePolicy = new batch.AllocationPolicy.InstancePolicy({
  machineType,
  // Accelerator describes Compute Engine accelerators to be attached to the VM
  accelerators: [
    new batch.AllocationPolicy.Accelerator({
      type: gpuType,
      count: gpuCount,
      installGpuDrivers,
    }),
  ],
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{installGpuDrivers, policy: instancePolicy}],
});

const job = new batch.Job({
  name: jobName,
  taskGroups: [group],
  labels: {env: 'testing', type: 'script'},
  allocationPolicy,
  // We use Cloud Logging as it's an option available out of the box
  logsPolicy: new batch.LogsPolicy({
    destination: batch.LogsPolicy.Destination.CLOUD_LOGGING,
  }),
});
// The job's parent is the project and region in which the job will run
const parent = `projects/${projectId}/locations/${region}`;

async function callCreateBatchGPUJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

  // Run request
  const [response] = await batchClient.createJob(request);
  console.log(JSON.stringify(response));
}

await callCreateBatchGPUJob();

Python 

from google.cloud import batch_v1


def create_gpu_job(project_id: str, region: str, job_name: str) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command on Cloud Compute instances on GPU machines.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use to run the job. Regions that are
            available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.

    Returns:
        A job object representing the job created.
    """
    client = batch_v1.BatchServiceClient()

    # Define what will be done as part of the job.
    task = batch_v1.TaskSpec()
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
    # You can also run a script from a file. Just remember, that needs to be a script that's
    # already on the VM that will be running the job. Using runnable.script.text and runnable.script.path is mutually
    # exclusive.
    # runnable.script.path = '/tmp/test.sh'
    task.runnables = [runnable]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 2000  # in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
    resources.memory_mib = 16  # in MiB
    task.compute_resource = resources

    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    # Tasks are grouped inside a job using TaskGroups.
    # Currently, it's possible to have only one task group.
    group = batch_v1.TaskGroup()
    group.task_count = 4
    group.task_spec = task

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # In this case, we tell the system to use "g2-standard-4" machine type.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "g2-standard-4"

    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    instances.install_gpu_drivers = True
    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "container"}
    # We use Cloud Logging as it's an out of the box available option
    job.logs_policy = batch_v1.LogsPolicy()
    job.logs_policy.destination = batch_v1.LogsPolicy.Destination.CLOUD_LOGGING

    create_request = batch_v1.CreateJobRequest()
    create_request.job = job
    create_request.job_id = job_name
    # The job's parent is the region in which the job will run
    create_request.parent = f"projects/{project_id}/locations/{region}"

    return client.create_job(create_request)

Utiliser des GPU pour les VM N1

Vous pouvez créer un job qui utilise des GPU pour les VM N1 à l'aide de la console Google Cloud, de gcloud CLI, de l'API Batch, de Java, de Node.js ou de Python.

Console

Pour créer une tâche qui utilise des GPU à l'aide de la console Google Cloud, procédez comme suit:

  1. Dans la console Google Cloud, accédez à la page Liste des jobs.

    Accéder à la liste des tâches

  2. Cliquez sur Créer. La page Créer une tâche par lot s'ouvre. Dans le volet de gauche, la page Informations sur la tâche est sélectionnée.

  3. Configurez la page Informations sur la tâche:

    1. (Facultatif) Dans le champ Nom de la tâche, personnalisez le nom de la tâche.

      Par exemple, saisissez example-gpu-job.

    2. Configurez la section Détails de la tâche:

      1. Dans la fenêtre Nouvel exécutable, ajoutez au moins un script ou un conteneur pour que cette tâche s'exécute.

        Par exemple, pour créer une tâche de script de base, procédez comme suit:

        1. Cochez la case Script. Un champ s'affiche.

        2. Dans le champ, saisissez le script suivant:

          echo Hello world from task ${BATCH_TASK_INDEX}.

        3. Cliquez sur OK.

      2. Dans le champ Nombre de tâches, saisissez le nombre de tâches pour cette tâche.

        Par exemple, saisissez 3.

      3. Facultatif: dans le champ Parallélisme, saisissez le nombre de tâches à exécuter simultanément.

        Par exemple, saisissez 1 (valeur par défaut).

  4. Configurez la page Spécifications de la ressource:

    1. Dans le volet de gauche, cliquez sur Spécifications des ressources. La page Spécifications des ressources s'ouvre.

    2. Facultatif: dans la section Modèle de provisionnement de VM, sélectionnez l'une des options suivantes pour le modèle de provisionnement des VM de cette tâche:

      • Si votre tâche peut résister à la préemption et que vous souhaitez obtenir des VM à prix réduit, sélectionnez Spot.

      • Sinon, sélectionnez Standard (par défaut).

    3. Sélectionnez l'emplacement de cette tâche.

      1. Dans le champ Région, sélectionnez une région.

      2. Dans le champ Zone, effectuez l'une des opérations suivantes:

        • Si vous souhaitez limiter l'exécution de cette tâche à une zone spécifique, sélectionnez-la.

        • Sinon, sélectionnez Tous (par défaut).

    4. Sélectionnez le type de machine GPU pour les VM de cette tâche:

      1. Dans les options de famille de machines, cliquez sur GPU.

      2. Dans le champ Type de GPU, sélectionnez le type de GPU.

        Si vous avez sélectionné l'un des types de GPU pour les VM N1, le champ Series (Série) est défini sur N1.

      3. Dans le champ Nombre de GPU, sélectionnez le nombre de GPU pour chaque VM.

      4. Dans le champ Type de machine, sélectionnez le type de machine.

      5. Pour installer automatiquement les pilotes de GPU, sélectionnez Installation du pilote de GPU (par défaut).

    5. Configurez la quantité de ressources de VM requise pour chaque tâche:

      1. Dans le champ Cœurs, saisissez le nombre de processeurs virtuels par tâche.

        Par exemple, saisissez 1 (valeur par défaut).

      2. Dans le champ Mémoire, saisissez la quantité de RAM en Go par tâche.

        Par exemple, saisissez 0.5 (valeur par défaut).

    6. Cliquez sur OK.

  5. Facultatif: Configurez les autres champs de cette tâche.

  6. Facultatif: Pour examiner la configuration de la tâche, dans le volet de gauche, cliquez sur Aperçu.

  7. Cliquez sur Créer.

    La page Détails de la tâche affiche la tâche que vous avez créée.

gcloud

  1. Créez un fichier JSON qui installe les pilotes de GPU, définit les sous-champs type et count du champ accelerators[] et s'exécute dans un emplacement qui possède le type de machine GPU.

    Par exemple, pour créer une tâche de script de base qui utilise des GPU pour les VM N1 et permet à Batch de sélectionner le type de machine N1 exact, créez un fichier JSON contenant les éléments suivants:

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Remplacez les éléments suivants :

    • INSTALL_GPU_DRIVERS: lorsque la valeur est true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans le champ policy à partir d'un emplacement tiers et les installe en votre nom. Si vous définissez ce champ sur false (valeur par défaut), vous devez installer manuellement les pilotes de GPU pour utiliser des GPU pour ce job.

    • GPU_TYPE: type de GPU. Vous pouvez afficher la liste des types de GPU disponibles à l'aide de la commande gcloud compute accelerator-types list. N'utilisez ce champ que pour les GPU des VM N1.

    • GPU_COUNT: nombre de GPU du type spécifié. Pour en savoir plus sur les options valides, consultez la section Types de machines GPU pour la série de machines N1. N'utilisez ce champ que pour les GPU des VM N1.

    • ALLOWED_LOCATIONS: vous pouvez éventuellement utiliser le champ allowedLocations[] pour spécifier une région ou une ou plusieurs zones spécifiques dans une région où les VM de votre tâche sont autorisées à s'exécuter. Par exemple, regions/us-central1 autorise toutes les zones de la région us-central1. Assurez-vous de spécifier les zones qui proposent le type de machine GPU que vous souhaitez pour cette tâche. Sinon, si vous omettez ce champ, assurez-vous que l'emplacement de la tâche propose le type de machine GPU.

  2. Pour créer et exécuter la tâche, utilisez la commande gcloud batch jobs submit:

    gcloud batch jobs submit JOB_NAME \
    --location LOCATION \
    --config JSON_CONFIGURATION_FILE

    Remplacez les éléments suivants :

    • JOB_NAME: nom de la tâche.

    • LOCATION: emplacement de la tâche.

    • JSON_CONFIGURATION_FILE: chemin d'accès à un fichier JSON contenant les détails de configuration de la tâche.

API

Envoyez une requête POST à la méthode jobs.create qui installe les pilotes de GPU, définit les sous-champs type et count du champ accelerators[] et utilise un emplacement avec le type de machine GPU.

Par exemple, pour créer une tâche de script de base qui utilise des GPU pour les VM N1 et permet à Batch de sélectionner le type de machine N1 exact, effectuez la requête suivante:

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Remplacez les éléments suivants :

  • PROJECT_ID: ID de projet de votre projet.

  • LOCATION: emplacement de la tâche.

  • JOB_NAME: nom de la tâche.

  • INSTALL_GPU_DRIVERS: lorsque la valeur est true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans le champ policy à partir d'un emplacement tiers et les installe en votre nom. Si vous définissez ce champ sur false (valeur par défaut), vous devez installer manuellement les pilotes de GPU pour utiliser des GPU pour ce job.

  • GPU_TYPE: type de GPU. Vous pouvez afficher la liste des types de GPU disponibles à l'aide de la commande gcloud compute accelerator-types list. N'utilisez ce champ que pour les GPU des VM N1.

  • GPU_COUNT: nombre de GPU du type spécifié. Pour en savoir plus sur les options valides, consultez la section Types de machines GPU pour la série de machines N1. N'utilisez ce champ que pour les GPU des VM N1.

  • ALLOWED_LOCATIONS: vous pouvez éventuellement utiliser le champ allowedLocations[] pour spécifier une région ou une ou plusieurs zones spécifiques dans une région où les VM de votre tâche sont autorisées à s'exécuter. Par exemple, regions/us-central1 autorise toutes les zones de la région us-central1. Assurez-vous de spécifier les zones qui proposent le type de machine GPU que vous souhaitez pour cette tâche. Sinon, si vous omettez ce champ, assurez-vous que l'emplacement de la tâche propose le type de machine GPU.

Java 


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.Accelerator;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicyOrTemplate;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.Runnable.Script;
import com.google.cloud.batch.v1.TaskGroup;
import com.google.cloud.batch.v1.TaskSpec;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateGpuJobN1 {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the region you want to use to run the job. Regions that are
    // available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
    String region = "europe-central2";
    // The name of the job that will be created.
    // It needs to be unique for each project and region pair.
    String jobName = "JOB_NAME";
    // Optional. When set to true, Batch fetches the drivers required for the GPU type
    // that you specify in the policy field from a third-party location,
    // and Batch installs them on your behalf. If you set this field to false (default),
    // you need to install GPU drivers manually to use any GPUs for this job.
    boolean installGpuDrivers = false;
    // The GPU type. You can view a list of the available GPU types
    // by using the `gcloud compute accelerator-types list` command.
    String gpuType = "nvidia-tesla-t4";
    // The number of GPUs of the specified type.
    int gpuCount = 2;

    createGpuJob(projectId, region, jobName, installGpuDrivers, gpuType, gpuCount);
  }

  // Create a job that uses GPUs
  public static Job createGpuJob(String projectId, String region, String jobName,
                                  boolean installGpuDrivers, String gpuType, int gpuCount)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {
      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(
                          "echo Hello world! This is task ${BATCH_TASK_INDEX}. "
                                  + "This job has a total of ${BATCH_TASK_COUNT} tasks.")
                      // You can also run a script from a file. Just remember, that needs to be a
                      // script that's already on the VM that will be running the job.
                      // Using setText() and setPath() is mutually exclusive.
                      // .setPath("/tmp/test.sh")
                      .build())
              .build();

      TaskSpec task = TaskSpec.newBuilder()
                  // Jobs can be divided into tasks. In this case, we have only one task.
                  .addRunnables(runnable)
                  .setMaxRetryCount(2)
                  .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
                  .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder()
          .setTaskCount(3)
          .setParallelism(1)
          .setTaskSpec(task)
          .build();

      // Accelerator describes Compute Engine accelerators to be attached to the VM.
      Accelerator accelerator = Accelerator.newBuilder()
          .setType(gpuType)
          .setCount(gpuCount)
          .build();

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setInstallGpuDrivers(installGpuDrivers)
                      .setPolicy(InstancePolicy.newBuilder().addAccelerators(accelerator))
                      .build())
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(LogsPolicy.Destination.CLOUD_LOGGING))
              .build();

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run.
              .setParent(String.format("projects/%s/locations/%s", projectId, region))
              .setJob(job)
              .setJobId(jobName)
              .build();

      Job result =
          batchServiceClient
              .createJobCallable()
              .futureCall(createJobRequest)
              .get(5, TimeUnit.MINUTES);

      System.out.printf("Successfully created the job: %s", result.getName());

      return result;
    }
  }
}

Node.js 

// Imports the Batch library
const batchLib = require('@google-cloud/batch');
const batch = batchLib.protos.google.cloud.batch.v1;

// Instantiates a client
const batchClient = new batchLib.v1.BatchServiceClient();

/**
 * TODO(developer): Update these variables before running the sample.
 */
// Project ID or project number of the Google Cloud project you want to use.
const projectId = await batchClient.getProjectId();
// Name of the region you want to use to run the job. Regions that are
// available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
const region = 'europe-central2';
// The name of the job that will be created.
// It needs to be unique for each project and region pair.
const jobName = 'batch-gpu-job-n1';
// The GPU type. You can view a list of the available GPU types
// by using the `gcloud compute accelerator-types list` command.
const gpuType = 'nvidia-tesla-t4';
// The number of GPUs of the specified type.
const gpuCount = 1;
// Optional. When set to true, Batch fetches the drivers required for the GPU type
// that you specify in the policy field from a third-party location,
// and Batch installs them on your behalf. If you set this field to false (default),
// you need to install GPU drivers manually to use any GPUs for this job.
const installGpuDrivers = false;
// Accelerator-optimized machine types are available to Batch jobs. See the list
// of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
const machineType = 'n1-standard-16';

// Define what will be done as part of the job.
const runnable = new batch.Runnable({
  script: new batch.Runnable.Script({
    commands: ['-c', 'echo Hello world! This is task ${BATCH_TASK_INDEX}.'],
  }),
});

const task = new batch.TaskSpec({
  runnables: [runnable],
  maxRetryCount: 2,
  maxRunDuration: {seconds: 3600},
});

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup({
  taskCount: 3,
  taskSpec: task,
});

// Policies are used to define on what kind of virtual machines the tasks will run on.
// In this case, we tell the system to use "g2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const instancePolicy = new batch.AllocationPolicy.InstancePolicy({
  machineType,
  // Accelerator describes Compute Engine accelerators to be attached to the VM
  accelerators: [
    new batch.AllocationPolicy.Accelerator({
      type: gpuType,
      count: gpuCount,
      installGpuDrivers,
    }),
  ],
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{installGpuDrivers, policy: instancePolicy}],
});

const job = new batch.Job({
  name: jobName,
  taskGroups: [group],
  labels: {env: 'testing', type: 'script'},
  allocationPolicy,
  // We use Cloud Logging as it's an option available out of the box
  logsPolicy: new batch.LogsPolicy({
    destination: batch.LogsPolicy.Destination.CLOUD_LOGGING,
  }),
});
// The job's parent is the project and region in which the job will run
const parent = `projects/${projectId}/locations/${region}`;

async function callCreateBatchGPUJobN1() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

  // Run request
  const [response] = await batchClient.createJob(request);
  console.log(JSON.stringify(response));
}

await callCreateBatchGPUJobN1();

Python 

from google.cloud import batch_v1


def create_gpu_job(
    project_id: str, region: str, zone: str, job_name: str
) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command on Cloud Compute instances on GPU machines.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use to run the job. Regions that are
            available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
        zone: name of the zone you want to use to run the job. Important in regard to GPUs availability.
            GPUs availability can be found here: https://cloud.google.com/compute/docs/gpus/gpu-regions-zones
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.

    Returns:
        A job object representing the job created.
    """
    client = batch_v1.BatchServiceClient()

    # Define what will be done as part of the job.
    task = batch_v1.TaskSpec()
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
    # You can also run a script from a file. Just remember, that needs to be a script that's
    # already on the VM that will be running the job. Using runnable.script.text and runnable.script.path is mutually
    # exclusive.
    # runnable.script.path = '/tmp/test.sh'
    task.runnables = [runnable]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 2000  # in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
    resources.memory_mib = 16  # in MiB
    task.compute_resource = resources

    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    # Tasks are grouped inside a job using TaskGroups.
    # Currently, it's possible to have only one task group.
    group = batch_v1.TaskGroup()
    group.task_count = 4
    group.task_spec = task

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "n1-standard-16"

    accelerator = batch_v1.AllocationPolicy.Accelerator()
    # Note: not every accelerator is compatible with instance type
    # Read more here: https://cloud.google.com/compute/docs/gpus#t4-gpus
    accelerator.type_ = "nvidia-tesla-t4"
    accelerator.count = 1

    policy.accelerators = [accelerator]
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    instances.install_gpu_drivers = True
    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    location = batch_v1.AllocationPolicy.LocationPolicy()
    location.allowed_locations = ["zones/us-central1-b"]
    allocation_policy.location = location

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "container"}
    # We use Cloud Logging as it's an out of the box available option
    job.logs_policy = batch_v1.LogsPolicy()
    job.logs_policy.destination = batch_v1.LogsPolicy.Destination.CLOUD_LOGGING

    create_request = batch_v1.CreateJobRequest()
    create_request.job = job
    create_request.job_id = job_name
    # The job's parent is the region in which the job will run
    create_request.parent = f"projects/{project_id}/locations/{region}"

    return client.create_job(create_request)

Étape suivante