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

Ce document explique comment créer et exécuter un job qui utilise un de processeur graphique (GPU). Pour en savoir plus sur les fonctionnalités et applicables aux GPU, consultez la section À propos des GPU documentation Compute Engine.

Lorsque vous créez un job Batch, vous pouvez éventuellement utiliser des GPU pour pour accélérer des charges de travail spécifiques. Voici quelques cas d'utilisation courants de tâches utilisant des GPU : pour le traitement intensive 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 à la création d'un job, demandez à votre administrateur de vous accorder le 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 méthodes 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électionnez le type de machine GPU.
  2. Installer les pilotes de GPU
  3. Définir les ressources de VM compatibles

Étape 1 : Sélectionnez le type de machine GPU

Les types de machines GPU disponibles (combinaisons valides de type de GPU, nombre de les GPU, le type de machine (processeurs virtuels et mémoire) et leurs cas d'utilisation sont répertoriés sur la page Page Types de machines GPU dans Compute Engine dans la documentation Google Cloud.

Les champs requis pour qu'une tâche spécifie un type de machine GPU varient en fonction du catégories dans le 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 dans des VM optimisées pour les accélérateurs, nous vous recommandons 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 processeurs virtuels et de mémoire disponibles sont compatibles avec les exigences de la tâche de l'ordre de travail.

GPU pour les VM N1: avec ces GPU, vous devez spécifier le type et la quantité à rattacher à chaque VM, et doivent être associées aux VM avec une machine à partir de 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 vCPU et de mémoire pour les VM N1 utilisant n'importe quel type et est assez flexible. Si vous le souhaitez, vous pouvez donc laisser Batch qui répond aux exigences de la tâche.

Étape 2 : Installez les pilotes de GPU

Pour installer les pilotes de GPU requis, sélectionnez l'une des méthodes suivantes :

  • Installer automatiquement les pilotes (recommandé si possible) : comme indiqué dans les exemples, pour permettre à Batch de récupérer les pilotes de GPU requis à partir d'un un emplacement tiers et les installer pour vous, définissez le installGpuDrivers pour le job à true. Cette méthode est recommandée si votre travail ne vous oblige pas à installer les pilotes manuellement.

    Si vous devez spécifier la version du pilote de GPU les installations par lot, définissez également Champ driverVersion.

  • Installer les pilotes manuellement : cette méthode est requise dans les cas suivants : sont vrais:

    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 incluant les pilotes de GPU.

      1. Pour installer des pilotes de GPU, exécutez un script d'installation basé sur le système d'exploitation 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. Créez et envoyez une tâche avec l'image de VM personnalisée à l'aide d'un modèle d'instance Compute Engine. 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 sur l'emplacement de votre VM d'un job.

    Pour savoir où les types de machines GPU sont disponibles, consultez Disponibilité des GPU par régions et zones dans la documentation Compute Engine.

  • Si vous spécifiez le type de machine du job, assurez-vous qu'il dispose de suffisamment vCPU et mémoire pour répondre aux exigences des tâches du job. Spécifier la machine du job est requis lors de l'utilisation de GPU pour les VM optimisées pour les accélérateurs et le type lorsque vous utilisez des GPU pour les VM N1.

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

    • Définissez les ressources de VM directement à 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 un l'image. Pour en savoir plus, consultez Définissez les ressources de la tâche à l'aide d'un modèle d'instance de VM.

Créer un exemple de job qui utilise des GPU

Les sections suivantes expliquent comment créer un exemple de tâche pour différents types de machines GPU. Les exemples d'emplois installent tous automatiquement les pilotes de GPU et définissent directement les ressources de VM.

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 gcloud CLI, de l'API Batch, de Java ou de Python.

gcloud

  1. Créez un fichier JSON qui installe les pilotes de GPU, définit le Champ machineType avec un type de machine de la famille de machines optimisées pour les accélérateurs, et utilise un emplacement disposant du type de GPU spécifié.

    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"
            ]
        }
    }
}

    Remplacez les éléments suivants :

    • INSTALL_GPU_DRIVERS: si défini sur true, extrait par lot les pilotes requis pour Type de GPU spécifié dans le champ policy depuis un emplacement tiers, et Batch les installe en votre nom. Si vous définissez ce champ sur false (valeur par défaut), vous devez d'installer manuellement les pilotes de GPU afin d'utiliser n'importe quel GPU pour cette tâche.

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

    • ALLOWED_LOCATIONS : le champ allowedLocations[] définit une région, et éventuellement une ou plusieurs zones, dans lesquelles les instances de VM de votre tâche sont autorisées à s'exécuter. Par exemple, regions/us-central1, zones/us-central1-a autorise la zone us-central1-a. Assurez-vous de spécifier les zones proposant 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 le champ machineType avec le type de machine de la famille de machines optimisées pour les accélérateurs et utilise un emplacement avec le type de GPU spécifié.

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"
            ]
        }
    }
}

Remplacez les éléments suivants :

  • PROJECT_ID: le ID du projet de votre projet.

  • LOCATION: emplacement du travail.

  • 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 d'installer manuellement les pilotes de GPU afin d'utiliser n'importe quel GPU pour cette tâche.

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

  • ALLOWED_LOCATIONS: le Champ allowedLocations[] définit une région, et éventuellement une ou plusieurs zones, où la VM instances de votre job sont autorisées à s'exécuter, exemple, regions/us-central1, zones/us-central1-a autorise la zone us-central1-a Veillez à spécifier qui proposent le type de machine GPU. que vous souhaitez pour ce travail. 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;
    }
  }
}

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 gcloud CLI. API Batch, Java, Node.js ou Python.

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 utilise un emplacement avec le type de GPU spécifié.

    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"
            ]
        }
    }
}

    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 cette tâche.

    • GPU_TYPE: le GPU de mots clés. Vous pouvez afficher une 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: le Champ allowedLocations[] définit une région, et éventuellement une ou plusieurs zones, où la VM instances de votre job sont autorisées à s'exécuter, exemple, regions/us-central1, zones/us-central1-a autorise la zone us-central1-a Assurez-vous de spécifier les zones proposant 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 d'une JSON contenant les détails de la configuration du job.

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 GPU spécifié.

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"
            ]
        }
    }
}

Remplacez les éléments suivants :

  • PROJECT_ID: le ID du 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 cette tâche.

  • 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: le 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 : le champ allowedLocations[] définit une région, et éventuellement une ou plusieurs zones, dans lesquelles les instances de VM de votre tâche sont autorisées à s'exécuter. Par exemple, regions/us-central1, zones/us-central1-a autorise la zone us-central1-a. Assurez-vous de spécifier les zones proposant le type de machine GPU que vous souhaitez pour cette tâche. Sinon, si vous omettez ce champ, que l'emplacement du job 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

Pour créer une tâche avec des GPU à l'aide de Node.js, sélectionnez l'une des options suivantes en fonction du type de machine de votre modèle de GPU :

Créer une tâche qui utilise des GPU avec des VM optimisées pour les accélérateurs

Pour utiliser des GPU avec des VM optimisées pour les accélérateurs, il vous suffit de spécifier le type de machine souhaité pour les VM de la tâche :

// 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();

Créer une tâche qui utilise des GPU avec des VM N1

Pour utiliser des GPU avec des VM N1, vous devez spécifier le nombre et le type de GPU souhaités pour chacune des VM de la tâche:

// 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