Criar e executar um job que usa GPUs

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

Ao criar um job do Batch, é possível 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, leia Começar a usar o Batch e ative o serviço 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 usando papéis personalizados ou outros papéis predefinidos.

Criar um job que usa GPUs

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

  1. Planejar os requisitos de um job que usa GPUs.
  2. Crie um job com os requisitos e métodos identificados. Para 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 dele conforme explicado nas seções a seguir:

  1. Selecione o tipo de máquina de GPU e a opção de consumo
  2. Instale os drivers da GPU.
  3. Definir recursos de VM compatíveis

Etapa 1: selecionar o tipo de máquina de GPU e a opção de consumo

Os requisitos de um job variam de acordo com o tipo de máquina com GPU e a opção de consumo preferidos, e as opções de cada um podem ser interdependentes.

Para selecionar o tipo de máquina de GPU e a opção de consumo do seu job, siga estas etapas:

  1. Identifique e selecione sua prioridade:

  2. Faça a seleção restante com base no que é compatível com sua primeira seleção.

    1. Para identificar as opções compatíveis com sua primeira seleção, consulte Disponibilidade de opções de consumo por tipo de máquina na documentação do Compute Engine.

    2. Consulte a seção restante para Selecionar a opção de consumo ou Selecionar o tipo de máquina com GPU, respectivamente.

Selecione o tipo de máquina de GPU

Para selecionar o tipo de máquina com GPU para um job e entender os requisitos dele, siga estas etapas:

  1. Selecione um tipo de máquina de GPU:para conferir 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 casos de uso recomendados, consulte Tipos de máquina de GPU e Família de máquinas otimizadas para aceleradores na documentação do Compute Engine.

  2. Entenda os requisitos do job para seu tipo de máquina com GPU:Os campos necessários para um job especificar um tipo de máquina com GPU variam de acordo com as categorias na tabela a seguir:

    Tipos de máquina de GPU e requisitos de job

    GPUs para VMs otimizadas para aceleradores: as VMs com um tipo de máquina da família de máquinas otimizadas para aceleradores têm um tipo e um número específicos dessas GPUs anexados automaticamente.

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

    Especificamente, o Batch também permite especificar apenas o tipo e o número de GPUs para VMs otimizadas para aceleradores, mas as opções de vCPU e memória resultantes costumam ser muito limitadas. Por isso, recomendamos que você verifique se as opções de vCPU e memória disponíveis são compatíveis com os requisitos de tarefa do job.

    GPUs para VMs N1: é necessário especificar o tipo e a quantidade a serem anexados a cada VM. Elas 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 que você especifique 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 específico e número de GPUs são bastante flexíveis. A menos que você crie o job usando o console do Google Cloud , deixe o Batch selecionar automaticamente um tipo de máquina que atenda aos requisitos de tarefa do job.
Selecione a opção de consumo

Esta seção resume como selecionar a opção de consumo para um job e os requisitos de job para cada opção.

As opções de consumo disponíveis para o Batch e os requisitos delas são explicados na tabela a seguir, que as lista com base nos casos de uso: da maior para a menor disponibilidade de recursos.

Em resumo, recomendamos que a maioria dos usuários selecione a opção de consumo para um job da seguinte maneira:

  • A menos que uma das outras condições seja verdadeira, use VMs de início flexível (prévia) (preferencial, se atender aos seus requisitos) ou sob demanda.
  • Se o job exigir uma garantia muito alta de disponibilidade de recursos ou se você tiver reservas não utilizadas que não podem ser excluídas, use reservas no modo de calendário (prévia) (preferencial, se atender aos seus requisitos) ou reservas.
  • (Opcional) Se a carga de trabalho for muito tolerante a falhas, talvez seja possível reduzir os custos usando VMs spot.
Opções de consumo e 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 e não puder usar reservas no modo de calendário ou se já tiver reservas que podem não ser usadas.

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

    Saiba mais sobre reservas na documentação do Compute Engine.

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

Reservas no modo de calendário (pré-lançamento)

  • Caso de uso: recomendamos reservas no modo de calendário para jobs se você quiser usar um tipo de máquina com GPU que ofereça suporte a reservas no modo de calendário e precisar de um nível muito alto de garantia de disponibilidade de recursos por pelo menos um dia e até 90 dias.

  • Detalhes: antes de criar um job, solicite ou identifique uma reserva no modo de calendário que possa ser consumida. Se o Compute Engine atender a uma solicitação de reserva adiantada no modo de calendário, a reserva criada automaticamente terá o mesmo custo da execução das VMs especificadas durante todo o período de reserva com os preços do Dynamic Workload Scheduler, que oferece descontos de até 53% nos preços sob demanda. Depois de identificar uma reserva de modo de calendário criada automaticamente que você pode usar, criar um job que consome uma reserva de modo de calendário é muito semelhante a criar um job que consome uma reserva.

    Saiba mais sobre reservas no modo de calendário na documentação do Compute Engine.

O Batch usa reservas no modo de calendário para jobs que fazem o seguinte:

VMs de início flexível (pré-lançamento)

  • Caso de uso: recomendamos VMs de início flexível se o job puder tolerar a disponibilidade de melhor esforço em troca de preços com desconto e até 7 dias para terminar a execução.

    Em comparação com as VMs on demand e spot, as VMs de início flexível podem facilitar o acesso simultâneo a muitos recursos de GPU. Por exemplo, as VMs de início flexível podem ser úteis para o agendamento de jobs, mitigando atrasos ou problemas causados pela indisponibilidade de recursos.

  • Detalhes: se uma solicitação para criar um job que usa VMs de início flexível for atendida, as VMs serão cobradas com os preços do Programador Dinâmico de Cargas de Trabalho, que oferecem descontos de até 53% nos preços sob demanda.

    Saiba mais sobre VMs de início flexível na documentação do Compute Engine.

O Batch usa VMs de início flexível para jobs que fazem tudo o que segue:

Sob demanda

  • Caso de uso: recomendamos o uso sob demanda para a maioria dos outros jobs por padrão.1

  • Detalhes: o acesso sob demanda geralmente é a maneira padrão de acessar as VMs do Compute Engine. Com o acesso sob demanda, você pode acessar recursos (se disponíveis) quando solicitado. Os recursos são excluídos até que o job seja concluído ou o limite de tempo de execução seja atingido.

O Batch usa o modelo on demand por padrão para a maioria dos outros jobs. Se você quiser garantir que um job use o modo on demand, faça o seguinte:1

1Exceção: para jobs que usam a série de máquinas A3, o comportamento padrão é exclusivo. Recomendamos que você não use sob demanda e não deixe o campo provisioningModel indefinido. Em vez disso, use os requisitos de job para VMs de início flexível. Não é recomendável usar sob demanda para a série de máquinas A3 devido à baixa disponibilidade de recursos. Consequentemente, se um job usar a série de máquinas A3, bloquear reservas e tiver o campo provisioningModel indefinido ou definido como STANDARD, a opção de consumo padrão será única. O comportamento é semelhante às VMs de início flexível, que limitam o tempo de execução a 7 dias. No entanto, não é recomendável porque esses jobs não recebem descontos dos preços do Programador Dinâmico de Cargas de Trabalho. Se o job com VMs A3 puder tolerar um limite de tempo de execução de sete dias, recomendamos usar VMs de início flexível em vez de sob demanda. Caso contrário, não será possível garantir que os jobs com VMs A3 usem sob demanda, a menos que você defina provisioningModel como STANDARD e verifique manualmente se o job não pode consumir reservas sem definir o campo reservation como NO_RESERVATION.

Spot VMs

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

  • Detalhes: se uma solicitação para criar um job que usa VMs spot for atendida, as VMs serão cobradas com base nos preços das VMs spot, que podem mudar com frequência e oferecer o maior desconto, até 91% de desconto nos preços sob demanda. No entanto, as VMs spot nem sempre estão disponíveis e podem ser interrompidas a qualquer momento.

    Saiba mais sobre VMs spot na documentação do Compute Engine.

O Batch usa VMs do Spot para jobs que atendem a todos os requisitos a seguir:

  • Defina o campo provisioningModel como SPOT.
  • (Opcional) Bloquear reservas. Não é possível usar VMs spot com reservas. Especificamente, o job pode definir opcionalmente o campo reservation como NO_RESERVATION. Para mais informações, consulte Criar e executar um job que não pode consumir VMs reservadas.

Etapa 2: instalar os drivers da GPU

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

Etapa 3: definir recursos de VM compatíveis

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

Em resumo, é preciso fazer o seguinte ao definir os recursos da VM para um job que usa GPUs:

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

    Para saber onde os tipos de máquinas com GPU estão disponíveis, consulte Disponibilidade de aceleradores 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 de tarefa do job. É necessário especificar o tipo de máquina do job sempre que você criar um job usando o console Google Cloud . Isso também é recomendado quando você cria 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 de 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 opção de consumo. Especificamente, os jobs de exemplo usam as opções recomendadas: todos instalam drivers de GPU automaticamente e todos definem recursos de VM diretamente.

Opção de consumo Exemplo de instruções de job
Reservas ou reservas no modo de calendário (pré-lançamento)

Garantir a disponibilidade de recursos usando reservas de VM
VMs de início flexível (pré-lançamento)

Usar GPUs e VMs de início flexível
VMs sob demanda ou spot

Selecione uma das seguintes opções com base no tipo de máquina de GPU:

Usar GPUs e VMs de início flexível

É possível criar um job que usa GPUs para VMs A3 com o 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 de GPU compatível com VMs de início flexível, bloqueie reservas e seja executado em um local que ofereça suporte ao tipo de máquina de GPU.

    Por exemplo, para criar um job de script básico que usa VMs flexíveis de início e GPUs para VMs otimizadas para aceleradores, crie um arquivo JSON com o conteúdo a seguir.

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

    Substitua:

    • INSTALL_GPU_DRIVERS: quando definido como true, o Batch 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 qualquer GPU nesse job.

    • MACHINE_TYPE: um tipo de máquina com GPU que aceita VMs de início flexível. Para mais informações, consulte Disponibilidade de opções de consumo por tipo de máquina na documentação do Compute Engine.

    • ALLOWED_LOCATIONS: você pode 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. Verifique se você especificou locais que oferecem o tipo de máquina com GPU que você quer para este job. Caso contrário, se você omitir esse campo, verifique se o local do job oferece o tipo de máquina com GPU.

  2. Para criar e executar o job, use o comando gcloud alpha 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 para um arquivo JSON com os detalhes de configuração do job.

API

Faça uma solicitação POST para o método jobs.create v1alpha que instala drivers de GPU, especifica um tipo de máquina de GPU compatível com VMs de início flexível, bloqueia reservas e é executado em um local que aceita o tipo de máquina de GPU.

Por exemplo, para criar um job de script básico que usa VMs de início flexível e GPUs para VMs otimizadas para aceleradores, faça a seguinte solicitação:

POST https://batch.googleapis.com/v1alpha/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": {
                    "provisioningModel":"FLEX_START",
                    "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 Batch 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 qualquer GPU nesse job.

  • MACHINE_TYPE: um tipo de máquina com GPU que aceita VMs de início flexível. Para mais informações, consulte Disponibilidade de opções de consumo por tipo de máquina na documentação do Compute Engine.

  • ALLOWED_LOCATIONS: você também pode 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. Verifique se você especificou locais que oferecem o tipo de máquina com GPU que você quer para este job. Caso contrário, se você omitir esse campo, verifique se o local do job oferece o tipo de máquina com GPU.

Usar GPUs para VMs otimizadas para aceleradores

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

Console

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

  1. No console 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 Novo executável, 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 script a seguir:

          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 de recursos:

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

    2. Na seção Modelo de provisionamento de VM, selecione uma das seguintes opções de opção de consumo para as VMs do job:

      • Se o job puder resistir à preempção e você quiser VMs spot com desconto, selecione Spot.

      • Caso contrário, para usar VMs sob demanda, selecione Padrão (padrão).

    3. Selecione o local para este job.

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

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

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

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

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

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

      2. No campo Tipo de GPU, selecione o tipo de GPUs. 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 de tipo de máquina com base no tipo e no número de GPUs selecionados.

      3. Para instalar automaticamente os drivers de GPU, selecione Instalação do driver de 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 deste 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 que tenha o tipo de máquina de GPU.

    Por exemplo, para criar um job de script básico que usa GPUs para VMs otimizadas para aceleradores, 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": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Substitua:

    • INSTALL_GPU_DRIVERS: quando definido como true, o Batch 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 manualmente os drivers de GPU para usar qualquer GPU nesse job.

    • PROVISIONING_MODEL: o modelo de provisionamento da sua opção de consumo: STANDARD para VMs sob demanda ou SPOT para VMs spot.

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

    • ALLOWED_LOCATIONS: você pode 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. Verifique se você especificou locais que oferecem o tipo de máquina com GPU que você quer para este job. Caso contrário, se você omitir esse campo, verifique se o local do job oferece o tipo de máquina com 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 para um arquivo JSON com os detalhes de configuração do job.

API

Faça uma solicitação POST ao 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 que tem o tipo de máquina de GPU.

Por exemplo, para criar um job de script básico que usa GPUs para VMs otimizadas para aceleradores, 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": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "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 Batch busca os drivers necessários para o tipo de GPU especificado no campo policy em 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 qualquer GPU nesse job.

  • PROVISIONING_MODEL: o modelo de provisionamento da sua opção de consumo: STANDARD para VMs sob demanda ou SPOT para VMs spot.

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

  • ALLOWED_LOCATIONS: você também pode 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. Verifique se você especificou locais que oferecem o tipo de máquina com GPU que você quer para este job. Caso contrário, se você omitir esse campo, verifique se o local do job oferece o tipo de máquina com 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 Google Cloud , a CLI gcloud, a API Batch, Java, Node.js ou Python.

Console

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

  1. No console 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 Novo executável, 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 script a seguir:

          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 de recursos:

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

    2. Na seção Modelo de provisionamento de VM, selecione uma das seguintes opções de opção de consumo para as VMs do job:

      • Se o job puder resistir à preempção e você quiser VMs spot com desconto, selecione Spot.

      • Caso contrário, para usar VMs sob demanda, selecione Padrão (padrão).

    3. Selecione o local para este job.

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

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

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

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

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

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

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

        Se você selecionou um dos tipos de GPU para VMs N1, o campo Série será 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 de GPU, selecione Instalação do driver de 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 deste 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 Batch 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": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "reservation": "NO_RESERVATION",
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Substitua:

    • INSTALL_GPU_DRIVERS: quando definido como true, o Batch busca os drivers necessários para o tipo de GPU especificado no campo policy em 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 qualquer GPU nesse job.

    • PROVISIONING_MODEL: o modelo de provisionamento da sua opção de consumo: STANDARD para VMs sob demanda ou SPOT para VMs spot.

    • 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 os tipos de máquinas com GPU para a série de máquinas N1. Use este campo apenas para GPUs de VMs N1.

    • ALLOWED_LOCATIONS: você também pode 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. Verifique se você especificou locais que oferecem o tipo de máquina com GPU que você quer para este job. Caso contrário, se você omitir esse campo, verifique se o local do job oferece o tipo de máquina com 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 para 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 tem 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 Batch 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": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "reservation": "NO_RESERVATION",
                    "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 Batch 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 qualquer GPU nesse job.

  • PROVISIONING_MODEL: o modelo de provisionamento da sua opção de consumo: STANDARD para VMs sob demanda ou SPOT para VMs spot.

  • 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 com GPU para a série de máquinas N1. Use este campo apenas para GPUs de VMs N1.

  • ALLOWED_LOCATIONS: você também pode 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. Verifique se você especificou locais que oferecem o tipo de máquina com GPU que você quer para este job. Caso contrário, se você omitir esse campo, verifique se o local do job oferece o tipo de máquina com 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