Criar e executar um job que usa GPUs

Este documento explica como criar e executar um job que usa uma unidade de processamento gráfico (GPU). Para saber mais sobre os recursos e as restrições de GPUs, consulte Sobre GPUs na documentação do Compute Engine.

Ao criar um job em lote, você pode usar GPUs para acelerar cargas de trabalho específicas. Os casos de uso comuns para jobs que usam GPUs incluem processamento de dados intensivo e cargas de trabalho de inteligência artificial (IA), como machine learning (ML).

Antes de começar

  1. Se você nunca usou o Batch, consulte Começar a usar o Batch e ative o Batch concluindo os pré-requisitos para projetos e usuários.

  2. Para receber as permissões necessárias para criar um job, peça ao administrador para conceder a você os seguintes papéis do IAM:

    Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

    Também é possível conseguir as permissões necessárias por meio de papéis personalizados ou de outros papéis predefinidos.

Criar um job que usa GPUs

Para criar um job que usa GPUs, faça o seguinte:

  1. Planeje os requisitos para um job que usa GPUs.
  2. Crie uma vaga com os requisitos e métodos que você identificou. Para conferir exemplos de como criar um job usando as opções recomendadas, consulte Criar um job de exemplo que usa GPUs neste documento.

Planejar os requisitos de um job que usa GPUs

Antes de criar um job que usa GPUs, planeje os requisitos do job conforme explicado nas seções a seguir:

  1. Selecionar o tipo de máquina de GPU e o método de provisionamento
  2. Instalar os drivers da GPU
  3. Definir recursos de VM compatíveis

Etapa 1: selecionar o tipo de máquina de GPU e o método de provisionamento

Os requisitos de um job variam de acordo com o tipo de máquina de GPU e o método de provisionamento preferidos, e as opções de cada um podem ser interdependentes. Com base nos requisitos e prioridades, você pode selecionar o tipo de máquina de GPU primeiro ou o método de provisionamento. Geralmente, o tipo de máquina GPU afeta principalmente o desempenho e o preço base, e o método de provisionamento afeta principalmente a disponibilidade de recursos e custos ou descontos adicionais.

Selecionar o tipo de máquina de GPU

Os tipos de máquina de GPU disponíveis (as combinações válidas de tipo de GPU, número de GPUs e tipo de máquina (vCPUs e memória)) e os respectivos casos de uso estão listados na página Tipos de máquina de GPU na documentação do Compute Engine.

Os campos necessários para que um job especifique um tipo de máquina de GPU variam com base nas categorias da tabela a seguir:

Tipos de máquina de GPU e os requisitos do job

GPUs para VMs com otimização de acelerador: as VMs com um tipo de máquina da família de máquinas com otimização de acelerador têm um tipo e um número específico de GPUs anexadas automaticamente.

Para usar GPUs em VMs otimizadas para aceleradores, recomendamos especificar o tipo de máquina. Cada tipo de máquina com otimização de acelerador oferece suporte apenas a um tipo e número específicos de GPUs. Portanto, ele é funcionalmente equivalente, independentemente de você especificar ou não esses valores, além do tipo de máquina com otimização de acelerador.

Especificamente, o lote também oferece suporte à especificação apenas do tipo e do número de GPUs para VMs otimizadas para acelerador, mas as opções de vCPU e memória resultantes geralmente são muito limitadas. Por isso, recomendamos verificar se as opções de vCPU e memória disponíveis são compatíveis com os requisitos da tarefa.

GPUs para VMs N1: essas GPUs exigem que você especifique o tipo e a quantidade a serem anexados a cada VM e precisam ser anexadas a VMs com um tipo de máquina da série de máquinas N1.

Para usar GPUs em VMs N1, recomendamos especificar pelo menos o tipo e o número de GPUs. Verifique se a combinação de valores corresponde a uma das opções de GPU válidas para os tipos de máquina N1. As opções de vCPU e memória para VMs N1 que usam qualquer tipo e número de GPUs específicos são bastante flexíveis. A menos que você crie o job usando o console do Google Cloud , é possível permitir que o Batch selecione automaticamente um tipo de máquina que atenda aos requisitos da tarefa.
Selecionar o método de provisionamento

O lote usa métodos diferentes para provisionar os recursos da VM para jobs que usam GPUs com base no tipo de recursos solicitados. Os métodos de provisionamento disponíveis e os requisitos deles são explicados na tabela a seguir, que os lista com base nos casos de uso: da maior para a menor disponibilidade de recursos.

Em resumo, recomendamos que a maioria dos usuários faça o seguinte:

  • Quando você pretende usar tipos de máquina de GPU A3 sem uma reserva, use o Dynamic Workload Scheduler para lote (pré-lançamento).

  • Para todos os outros tipos de máquina de GPU, use o método de provisionamento padrão. O método de provisionamento padrão geralmente é sob demanda. Uma exceção é se o projeto tiver reservas não utilizadas que a job possa consumir automaticamente.

Métodos de provisionamento e os requisitos de trabalho

Reservas

  • Caso de uso: recomendamos reservas para jobs se você quiser um nível muito alto de garantia de disponibilidade de recursos ou se já tiver reservas que possam estar sem uso.

  • Detalhes: uma reserva gera os custos das VMs especificadas pelo mesmo preço de execução até que você exclua a reserva. As VMs que estão consumindo uma reserva não geram custos separados, mas as reservas geram custos, independentemente do consumo.

O lote usa reservas para jobs que podem consumir reservas não utilizadas. Para mais informações sobre reservas e os requisitos delas, consulte a página Garantir a disponibilidade de recursos usando reservas de VM.

Programador dinâmico de cargas de trabalho para lote (Visualização)

O lote usa o Dynamic Workload Scheduler para jobs que fazem o seguinte:

  • Especifique um tipo de máquina de GPU A3.
  • Bloquear reservas. Especificamente, o job precisa definir o campo reservation como NO_RESERVATION. Para mais informações, consulte Criar e executar um job que não pode consumir VMs reservadas.
  • Não use VMs spot. Especificamente, o job pode omitir o campo provisioningModel ou definir o campo provisioningModel como STANDARD.

Sob demanda

  • Caso de uso: recomendamos on-demand para todos os outros jobs.

  • Detalhes: o acesso sob demanda geralmente é a maneira padrão de acessar VMs do Compute Engine. Com a reserva sob demanda, você pode solicitar e (se disponível) acessar imediatamente os recursos de uma VM por vez.

O lote usa sob demanda para todos os outros jobs.

Spot VMs

  • Caso de uso: recomendamos usar VMs spot para reduzir os custos de cargas de trabalho tolerantes a falhas.

  • Detalhes: as VMs spot oferecem descontos significativos, mas podem não estar sempre disponíveis e podem ser interrompidas a qualquer momento. Para mais informações, consulte VMs do Spot na documentação do Compute Engine.

O lote usa VMs spot para jobs que definem o campo provisioningModel como SPOT.

Etapa 2: instalar os drivers da GPU

Para usar GPUs em um job, é necessário instalar os drivers da GPU. Para instalar os drivers da GPU, selecione um dos seguintes métodos:

  • Instalar drivers de GPU automaticamente (recomendado, se possível): como mostrado nos exemplos, para permitir que o lote busque os drivers de GPU necessários de um local de terceiros e os instale em seu nome, defina o campo installGpuDrivers do job como true. Esse método é recomendado se o trabalho não exigir a instalação manual de drivers.

    Opcionalmente, se você precisar especificar qual versão do driver da GPU será instalada em lote, defina também o campo driverVersion.

  • Instalar drivers de GPU manualmente:esse método é necessário se uma das seguintes condições for verdadeira:

    Para instalar manualmente os drivers de GPU necessários, recomendamos o seguinte método:

    1. Crie uma imagem de VM personalizada que inclua os drivers de GPU.

      1. Para instalar drivers de GPU, execute um script de instalação com base no SO que você quer usar:

      2. Se o job tiver contêineres executáveis e não usar o Container-Optimized OS, também será necessário instalar o NVIDIA Container Toolkit.

    2. Ao criar e enviar um job que usa GPUs, especifique a imagem da VM personalizada que inclui os drivers da GPU e defina o campo installGpuDrivers do job como false (padrão).

Etapa 3: definir recursos de VM compatíveis

Para saber mais sobre os requisitos e as opções para definir os recursos de VM de um job, consulte Recursos de job.

Em resumo, você precisa fazer o seguinte ao definir os recursos da VM para um job que usa GPUs:

  • Verifique se o tipo de máquina da GPU está disponível no local das VMs do job.

    Para saber onde os tipos de máquina de GPU estão disponíveis, consulte Disponibilidade de GPU por região e zona na documentação do Compute Engine.

  • Se você especificar o tipo de máquina do job, verifique se ele tem vCPUs e memória suficientes para os requisitos da tarefa. Especificar o tipo de máquina do job é necessário sempre que você cria um job usando o console do Google Cloud . É recomendável criar um job que usa GPUs para VMs otimizadas para aceleradores.

  • Defina os recursos da VM para um job usando um método válido:

    • Defina os recursos da VM diretamente usando o campo instances[].policy (recomendado se possível). Esse método é mostrado nos exemplos.
    • Defina os recursos da VM usando um modelo com o campo instances[].instanceTemplate. Esse método é necessário para instalar manualmente os drivers da GPU usando uma imagem personalizada. Para mais informações, consulte Definir recursos de job usando um modelo de instância de VM.

Criar um job de exemplo que usa GPUs

As seções a seguir explicam como criar um job de exemplo para cada tipo de máquina de GPU usando as opções recomendadas. Especificamente, os jobs de exemplo instalam drivers de GPU automaticamente, definem recursos de VM diretamente e especificam o método de provisionamento ou usam o método de provisionamento padrão.

Usar GPUs para VMs A3 com o Dynamic Workload Scheduler para lote (pré-lançamento)

É possível criar um job que usa GPUs para VMs A3 pelo Dynamic Workload Scheduler usando a CLI gcloud ou a API Batch.

gcloud

  1. Crie um arquivo JSON que instale drivers de GPU, especifique um tipo de máquina da série A3, bloqueie reservas e seja executado em um local com o tipo de máquina GPU.

    Por exemplo, para criar um job de script básico que usa GPUs para VMs A3 pelo Dynamic Workload Scheduler, crie um arquivo JSON com o seguinte conteúdo:

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

    Substitua:

    • INSTALL_GPU_DRIVERS: quando definido como true, o lote busca os drivers necessários para o tipo de GPU especificado no campo policy de um local de terceiros e os instala em seu nome. Se você definir esse campo como false (padrão), será necessário instalar os drivers de GPU manualmente para usar GPUs nesse job.

    • MACHINE_TYPE: um tipo de máquina da série de máquinas A3.

    • ALLOWED_LOCATIONS: é possível usar o campo allowedLocations[] para especificar uma região ou zonas específicas em uma região em que as VMs do seu job podem ser executadas. Por exemplo, regions/us-central1 permite todas as zonas na região us-central1. Especifique os locais que oferecem o tipo de máquina de GPU que você quer para esse job. Caso contrário, se você omitir esse campo, verifique se o local do job oferece o tipo de máquina de GPU.

  2. Para criar e executar o job, use o comando gcloud batch jobs submit:

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

    Substitua:

    • JOB_NAME: o nome do job.

    • LOCATION: o local do job.

    • JSON_CONFIGURATION_FILE: o caminho de um arquivo JSON com os detalhes de configuração do job.

API

Faça uma solicitação POST para o método jobs.create que instala drivers de GPU, especifica um tipo de máquina da série A3, bloqueia reservas e é executado em um local que tenha o tipo de máquina GPU.

Por exemplo, para criar um job de script básico que usa GPUs para VMs A3 pelo Dynamic Workload Scheduler, faça a seguinte solicitação:

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

Substitua:

  • PROJECT_ID: o ID do projeto do seu projeto.

  • LOCATION: o local do job.

  • JOB_NAME: o nome do job.

  • INSTALL_GPU_DRIVERS: quando definido como true, o lote busca os drivers necessários para o tipo de GPU especificado no campo policy de um local de terceiros e os instala em seu nome. Se você definir esse campo como false (padrão), será necessário instalar os drivers de GPU manualmente para usar GPUs nesse job.

  • MACHINE_TYPE: um tipo de máquina da série de máquinas A3.

  • ALLOWED_LOCATIONS: é possível usar o campo allowedLocations[] para especificar uma região ou zonas específicas em uma região em que as VMs do seu job podem ser executadas. Por exemplo, regions/us-central1 permite todas as zonas na região us-central1. Especifique os locais que oferecem o tipo de máquina de GPU que você quer para esse job. Caso contrário, se você omitir esse campo, verifique se o local do job oferece o tipo de máquina de GPU.

Usar GPUs para VMs otimizadas para aceleradores

É possível criar um job que usa GPUs para VMs otimizadas para aceleradores usando o console do Google Cloud , a CLI gcloud, a API Batch, Java, Node.js ou Python.

Console

Para criar um job que usa GPUs usando o console do Google Cloud , faça o seguinte:

  1. No console do Google Cloud , acesse a página Lista de jobs.

    Acessar a lista de jobs

  2. Clique em Criar. A página Criar job em lote é aberta. No painel à esquerda, a página Detalhes do job está selecionada.

  3. Configure a página Detalhes do job:

    1. Opcional: no campo Nome do job, personalize o nome do job.

      Por exemplo, insira example-gpu-job.

    2. Configure a seção Detalhes da tarefa:

      1. Na janela New runnable, adicione pelo menos um script ou contêiner para que o job seja executado.

        Por exemplo, para criar um job de script básico, faça o seguinte:

        1. Marque a caixa de seleção Script. Um campo vai aparecer.

        2. No campo, insira o seguinte script:

          echo Hello world from task ${BATCH_TASK_INDEX}.

        3. Clique em Concluído.

      2. No campo Contagem de tarefas, insira o número de tarefas para este job.

        Por exemplo, insira 3.

      3. Opcional: no campo Paralelismo, insira o número de tarefas a serem executadas simultaneamente.

        Por exemplo, insira 1 (padrão).

  4. Configure a página Especificações do recurso:

    1. No painel à esquerda, clique em Especificações de recursos. A página Especificações do recurso é aberta.

    2. Opcional: na seção Modelo de provisionamento de VM, selecione uma das seguintes opções para o modelo de provisionamento das VMs desse job:

      • Se o job puder ser interrompido e você quiser VMs com desconto, selecione Spot.

      • Caso contrário, selecione Padrão (padrão).

    3. Selecione o local do trabalho.

      1. No campo Região, selecione uma região.

      2. No campo Zona, faça o seguinte:

        • Se você quiser restringir a execução desse job apenas em uma zona específica, selecione uma zona.

        • Caso contrário, selecione qualquer um (padrão).

    4. Selecione o tipo de máquina de GPU para as VMs desse job:

      1. Nas opções de família de máquinas, clique em GPUs.

      2. No campo Tipo de GPU, selecione o tipo de GPU. Em seguida, no campo Número de GPUs, selecione o número de GPUs para cada VM.

        Se você selecionou um dos tipos de GPU para VMs otimizadas para acelerador, o campo Tipo de máquina permite apenas uma opção para o tipo de máquina com base no tipo e no número de GPUs selecionados.

      3. Para instalar automaticamente os drivers da GPU, selecione Instalação do driver da GPU (padrão).

    5. Configure a quantidade de recursos de VM necessários para cada tarefa:

      1. No campo Núcleos, insira a quantidade de vCPUs por tarefa.

        Por exemplo, insira 1 (padrão).

      2. No campo Memória, insira a quantidade de RAM em GB por tarefa.

        Por exemplo, insira 0.5 (padrão).

    6. Clique em Concluído.

  5. Opcional: configure os outros campos para esse job.

  6. Opcional: para revisar a configuração do job, no painel esquerdo, clique em Visualizar.

  7. Clique em Criar.

    A página Detalhes do job mostra o job que você criou.

gcloud

  1. Crie um arquivo JSON que instale drivers de GPU, especifique um tipo de máquina da família de máquinas otimizadas para aceleradores e seja executado em um local com o tipo de máquina de GPU.

    Por exemplo, para criar um job de script básico que usa GPUs para VMs otimizadas para acelerador, crie um arquivo JSON com o seguinte conteúdo:

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

    Substitua:

    • INSTALL_GPU_DRIVERS: quando definido como true, o lote busca os drivers necessários para o tipo de GPU especificado no campo policy de um local de terceiros e os instala em seu nome. Se você definir esse campo como false (padrão), será necessário instalar os drivers de GPU manualmente para usar GPUs nesse job.

    • MACHINE_TYPE: um tipo de máquina da família de máquinas com otimização de acelerador.

    • ALLOWED_LOCATIONS: é possível usar o campo allowedLocations[] para especificar uma região ou zonas específicas em uma região em que as VMs do seu job podem ser executadas. Por exemplo, regions/us-central1 permite todas as zonas na região us-central1. Especifique os locais que oferecem o tipo de máquina de GPU que você quer para esse job. Caso contrário, se você omitir esse campo, verifique se o local do job oferece o tipo de máquina de GPU.

  2. Para criar e executar o job, use o comando gcloud batch jobs submit:

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

    Substitua:

    • JOB_NAME: o nome do job.

    • LOCATION: o local do job.

    • JSON_CONFIGURATION_FILE: o caminho de um arquivo JSON com os detalhes de configuração do job.

API

Faça uma solicitação POST para o método jobs.create que instala drivers de GPU, especifica um tipo de máquina da família de máquinas otimizadas para aceleradores e é executado em um local com o tipo de máquina de GPU.

Por exemplo, para criar um job de script básico que usa GPUs para VMs otimizadas para acelerador, faça a seguinte solicitação:

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

Substitua:

  • PROJECT_ID: o ID do projeto do seu projeto.

  • LOCATION: o local do job.

  • JOB_NAME: o nome do job.

  • INSTALL_GPU_DRIVERS: quando definido como true, o lote busca os drivers necessários para o tipo de GPU especificado no campo policy de um local de terceiros e os instala em seu nome. Se você definir esse campo como false (padrão), será necessário instalar os drivers de GPU manualmente para usar GPUs nesse job.

  • MACHINE_TYPE: um tipo de máquina da família de máquinas com otimização de acelerador.

  • ALLOWED_LOCATIONS: é possível usar o campo allowedLocations[] para especificar uma região ou zonas específicas em uma região em que as VMs do seu job podem ser executadas. Por exemplo, regions/us-central1 permite todas as zonas na região us-central1. Especifique os locais que oferecem o tipo de máquina de GPU que você quer para esse job. Caso contrário, se você omitir esse campo, verifique se o local do job oferece o tipo de máquina de 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)

Usar GPUs para VMs N1

É possível criar um job que usa GPUs para VMs N1 usando o console do Google Cloud , CLI gcloud, a API Batch, Java, Node.js ou Python.

Console

Para criar um job que usa GPUs usando o console do Google Cloud , faça o seguinte:

  1. No console do Google Cloud , acesse a página Lista de jobs.

    Acessar a lista de jobs

  2. Clique em Criar. A página Criar job em lote é aberta. No painel à esquerda, a página Detalhes do job está selecionada.

  3. Configure a página Detalhes do job:

    1. Opcional: no campo Nome do job, personalize o nome do job.

      Por exemplo, insira example-gpu-job.

    2. Configure a seção Detalhes da tarefa:

      1. Na janela New runnable, adicione pelo menos um script ou contêiner para que o job seja executado.

        Por exemplo, para criar um job de script básico, faça o seguinte:

        1. Marque a caixa de seleção Script. Um campo vai aparecer.

        2. No campo, insira o seguinte script:

          echo Hello world from task ${BATCH_TASK_INDEX}.

        3. Clique em Concluído.

      2. No campo Contagem de tarefas, insira o número de tarefas para este job.

        Por exemplo, insira 3.

      3. Opcional: no campo Paralelismo, insira o número de tarefas a serem executadas simultaneamente.

        Por exemplo, insira 1 (padrão).

  4. Configure a página Especificações do recurso:

    1. No painel à esquerda, clique em Especificações de recursos. A página Especificações do recurso é aberta.

    2. Opcional: na seção Modelo de provisionamento de VM, selecione uma das seguintes opções para o modelo de provisionamento das VMs desse job:

      • Se o job puder ser interrompido e você quiser VMs com desconto, selecione Spot.

      • Caso contrário, selecione Padrão (padrão).

    3. Selecione o local do trabalho.

      1. No campo Região, selecione uma região.

      2. No campo Zona, faça o seguinte:

        • Se você quiser restringir a execução desse job apenas em uma zona específica, selecione uma zona.

        • Caso contrário, selecione qualquer um (padrão).

    4. Selecione o tipo de máquina de GPU para as VMs desse job:

      1. Nas opções de família de máquinas, clique em GPUs.

      2. No campo Tipo de GPU, selecione o tipo de GPU.

        Se você selecionou um dos tipos de GPU para VMs N1, o campo Série é definido como N1.

      3. No campo Número de GPUs, selecione o número de GPUs para cada VM.

      4. No campo Tipo de máquina, selecione o tipo de máquina.

      5. Para instalar automaticamente os drivers da GPU, selecione Instalação do driver da GPU (padrão).

    5. Configure a quantidade de recursos de VM necessários para cada tarefa:

      1. No campo Núcleos, insira a quantidade de vCPUs por tarefa.

        Por exemplo, insira 1 (padrão).

      2. No campo Memória, insira a quantidade de RAM em GB por tarefa.

        Por exemplo, insira 0.5 (padrão).

    6. Clique em Concluído.

  5. Opcional: configure os outros campos para esse job.

  6. Opcional: para revisar a configuração do job, no painel esquerdo, clique em Visualizar.

  7. Clique em Criar.

    A página Detalhes do job mostra o job que você criou.

gcloud

  1. Crie um arquivo JSON que instale drivers de GPU, defina os subcampos type e count do campo accelerators[] e seja executado em um local com o tipo de máquina de GPU.

    Por exemplo, para criar um job de script básico que usa GPUs para VMs N1 e permite que o lote selecione o tipo de máquina N1 exato, crie um arquivo JSON com o seguinte conteúdo:

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

    Substitua:

    • INSTALL_GPU_DRIVERS: quando definido como true, o lote busca os drivers necessários para o tipo de GPU especificado no campo policy de um local de terceiros e os instala em seu nome. Se você definir esse campo como false (padrão), será necessário instalar os drivers de GPU manualmente para usar GPUs nesse job.

    • GPU_TYPE: o tipo de GPU. Para conferir uma lista dos tipos de GPU disponíveis, use o comando gcloud compute accelerator-types list. Use esse campo apenas para GPUs de VMs N1.

    • GPU_COUNT: o número de GPUs do tipo especificado. Para mais informações sobre as opções válidas, consulte os tipos de máquinas de GPU para a série de máquinas N1. Use este campo apenas para GPUs de VMs N1.

    • ALLOWED_LOCATIONS: é possível usar o campo allowedLocations[] para especificar uma região ou zonas específicas em uma região em que as VMs do seu job podem ser executadas. Por exemplo, regions/us-central1 permite todas as zonas na região us-central1. Especifique os locais que oferecem o tipo de máquina de GPU que você quer para esse job. Caso contrário, se você omitir esse campo, verifique se o local do job oferece o tipo de máquina de GPU.

  2. Para criar e executar o job, use o comando gcloud batch jobs submit:

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

    Substitua:

    • JOB_NAME: o nome do job.

    • LOCATION: o local do job.

    • JSON_CONFIGURATION_FILE: o caminho de um arquivo JSON com os detalhes de configuração do job.

API

Faça uma solicitação POST para o método jobs.create que instala drivers de GPU, define os subcampos type e count do campo accelerators[] e usa um local que tenha o tipo de máquina de GPU.

Por exemplo, para criar um job de script básico que use GPUs para VMs N1 e permita que o lote selecione o tipo de máquina N1 exato, faça a seguinte solicitação:

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

Substitua:

  • PROJECT_ID: o ID do projeto do seu projeto.

  • LOCATION: o local do job.

  • JOB_NAME: o nome do job.

  • INSTALL_GPU_DRIVERS: quando definido como true, o lote busca os drivers necessários para o tipo de GPU especificado no campo policy de um local de terceiros e os instala em seu nome. Se você definir esse campo como false (padrão), será necessário instalar os drivers de GPU manualmente para usar GPUs nesse job.

  • GPU_TYPE: o tipo de GPU. Para conferir uma lista dos tipos de GPU disponíveis, use o comando gcloud compute accelerator-types list. Use este campo apenas para GPUs de VMs N1.

  • GPU_COUNT: o número de GPUs do tipo especificado. Para mais informações sobre as opções válidas, consulte Tipos de máquinas de GPU para séries de máquinas N1. Use este campo apenas para GPUs de VMs N1.

  • ALLOWED_LOCATIONS: é possível usar o campo allowedLocations[] para especificar uma região ou zonas específicas em uma região em que as VMs do seu job podem ser executadas. Por exemplo, regions/us-central1 permite todas as zonas na região us-central1. Especifique os locais que oferecem o tipo de máquina de GPU que você quer para esse job. Caso contrário, se você omitir esse campo, verifique se o local do job oferece o tipo de máquina de 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)

A seguir