Esta página foi traduzida pela API Cloud Translation.

Criar e executar um job básico

Este documento explica os conceitos básicos da criação de jobs do Batch: como criar e executar um job baseado em um script ou imagem de contêiner e usar variáveis predefinidas e personalizadas. Para saber mais sobre a criação e a execução de jobs, consulte Visão geral da criação e execução de jobs.

Antes de começar

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.
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:
- Editor de jobs em lote (roles/batch.jobsEditor) no projeto
- Usuário da conta de serviço (roles/iam.serviceAccountUser) na conta de serviço do job, que é a conta de serviço padrão do Compute Engine
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.
Sempre que você criar um job, verifique se ele tem uma configuração de rede válida.
- Se você não tiver requisitos de rede específicos para a carga de trabalho ou o projeto e não tiver modificado a rede padrão do projeto, não será necessário fazer nada.
- Caso contrário, você vai precisar configurar a rede ao criar um job. Aprenda a configurar a rede para um job antes de criar um job básico para modificar os exemplos abaixo e atender aos seus requisitos de rede.
Para mais informações sobre a configuração de rede de um job, consulte Visão geral da rede de lotes.
Sempre que você criar um job, verifique se ele tem um ambiente de sistema operacional (SO) de VM válido.
- Se você não tiver requisitos específicos de imagem do SO da VM ou disco de inicialização para sua carga de trabalho ou projeto, nenhuma ação será necessária.
- Caso contrário, você precisa preparar uma opção válida de ambiente do SO da VM. Antes de criar um job básico, permita a configuração padrão para o ambiente do SO da VM ou aprenda a personalizar o ambiente do SO da VM para modificar os exemplos abaixo de acordo com seus requisitos.
Para mais informações sobre o ambiente do SO da VM para um job, consulte Visão geral do ambiente do SO da VM.

Criar um job básico

Para informações sobre todos os campos que podem ser especificados para um job, consulte a documentação de referência do recurso REST projects.locations.jobs. Resumindo, um job consiste em uma matriz de uma ou mais tarefas que executam um ou mais executáveis, que são os scripts executáveis e/ou contêineres do job. Para explicar os conceitos básicos, esta seção explica como criar um job de exemplo com apenas um executável, um script ou uma imagem de contêiner:

Se você quiser usar o Batch para gravar jobs que executam uma imagem de contêiner, consulte Criar um job de contêiner.
Caso contrário, se você não tiver certeza se quer usar imagens de contêiner ou se não conhece os contêineres, é recomendável criar um job de script.

O exemplo de job para os dois tipos de jobs contém um grupo de tarefas com uma matriz de quatro tarefas. Cada tarefa imprime uma mensagem e o índice dela para a saída padrão e o Cloud Logging. A definição desse job especifica um paralelismo de 2, o que indica que o job precisa ser executado em 2 VMs para permitir que duas tarefas sejam executadas por vez.

Criar um job de contêiner básico

É possível selecionar ou criar uma imagem de contêiner para fornecer o código e as dependências para que o job seja executado em qualquer ambiente de computação. Para mais informações, consulte Como trabalhar com imagens de contêiner e Como executar contêineres em instâncias de VM.

É possível criar um job de contêiner básico usando o console do Google Cloud , a CLI gcloud, a API Batch, Go, Java, Node.js, Python ou C++.

Console

Para criar um job de contêiner básico usando o console do Google Cloud , faça o seguinte:

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

Acessar a lista de jobs
Clique em Criar. A página Criar job em lote é aberta. No painel à esquerda, a página Detalhes do job está selecionada.
Configure a página Detalhes do job:
1. Opcional: no campo Nome do job, personalize o nome do job.
  
  Por exemplo, insira example-basic-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 adicionar um contêiner, faça o seguinte:
    1. Selecione URL da imagem do contêiner (padrão).
    2. No campo URL da imagem do contêiner, insira o URL de uma imagem do contêiner que você quer executar para cada tarefa neste job.
      
      Por exemplo, para usar a imagem do contêiner do Docker busybox, digite o seguinte URL:
      gcr.io/google-containers/busybox
    3. Opcional: para substituir o comando ENTRYPOINT da imagem do contêiner, insira um comando no campo Ponto de entrada.
      
      Por exemplo, insira o seguinte:
      /bin/sh
    4. Opcional: para substituir o comando CMD da imagem do contêiner, faça o seguinte:
      1. Selecione a caixa de seleção Substituir o comando CMD da imagem do contêiner. Um campo vai aparecer.
      2. No campo, insira um ou mais comandos, separando cada um com uma nova linha.
        
        Por exemplo, digite os seguintes comandos:
        
        -c echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.
      3. Clique em Concluído.
  2. No campo Contagem de tarefas, digite o número de tarefas para essa função. O valor precisa ser um número inteiro entre 1 e o limite de tarefas por grupo.
    
    Por exemplo, insira 4.
  3. No campo Paralelismo, insira o número de tarefas a serem executadas simultaneamente. O número não pode ser maior que o total de tarefas e precisa ser um número inteiro entre 1 e o limite de tarefas paralelas por job.
    
    Por exemplo, insira 2.
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. 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.
  Por exemplo, selecione Padrão (padrão).
3. Selecione o local para este trabalho:
  1. No campo Região, selecione uma região.
    
    Por exemplo, selecione us-central1 (Iowa) (padrã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.
    Por exemplo, selecione qualquer (padrão).
4. Selecione uma das seguintes famílias de máquinas:
  - Para cargas de trabalho comuns, clique em Uso geral.
  - Para cargas de trabalho que exigem alto desempenho, clique em Otimização de computação.
  - Para cargas de trabalho com uso intensivo de memória, clique em Otimização de memória.
  - Para cargas de trabalho otimizadas para aceleradores, clique em GPUs. Para mais informações, consulte Criar e executar um job que usa GPUs.
  Por exemplo, clique em Uso geral (padrão).
5. No campo Série, selecione uma série de máquinas para as VMs desse job.
  
  Por exemplo, se você selecionou Uso geral para a família de máquinas, selecione E2 (padrão).
6. No campo Tipo de máquina, selecione um tipo de máquina para as VMs desse job.
  
  Por exemplo, se você selecionou E2 para a série de máquinas, selecione e2-medium (2 vCPU, 4 GB de memória) (padrão).
7. 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).
Opcional: para revisar a configuração do job, no painel esquerdo, clique em Visualizar.
Clique em Criar.

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

gcloud

Para criar um job de contêiner básico usando a CLI gcloud, faça o seguinte:

Crie um arquivo JSON que especifique os detalhes de configuração do job. Por exemplo, para criar um job de contêiner básico, crie um arquivo JSON com o conteúdo a seguir. Para mais informações sobre todos os campos que podem ser especificados para um job, consulte a documentação de referência do recurso REST projects.locations.jobs.
```
{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "container": {
                            CONTAINER
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": CORES,
                    "memoryMib": MEMORY
                },
                "maxRetryCount": MAX_RETRY_COUNT,
                "maxRunDuration": "MAX_RUN_DURATION"
            },
            "taskCount": TASK_COUNT,
            "parallelism": PARALLELISM
        }
    ]
}
```
Substitua:
- CONTAINER: o contêiner em que cada tarefa é executada. No mínimo, um contêiner precisa especificar uma imagem no subcampo imageUri, mas outros subcampos também podem ser necessários. Para mais informações, consulte os subcampos container e o exemplo de job de contêiner nesta seção.
- CORES: opcional. A quantidade de núcleos, especificamente vCPUs, que geralmente representam metade de um núcleo físico, para alocar para cada tarefa em unidades de milliCPU. Se o campo cpuMilli não for especificado, o valor será definido como 2000 (duas vCPUs).
- MEMORY: opcional. A quantidade de memória a ser alocada para cada tarefa em MB. Se o campo memoryMib não for especificado, o valor será definido como 2000 (2 GB).
- MAX_RETRY_COUNT: opcional. O número máximo de novas tentativas de uma tarefa. O valor precisa ser um número inteiro entre 0 e 10. Se o campo maxRetryCount não for especificado, o valor será definido como 0, o que significa não tentar a tarefa novamente. Para mais informações sobre o campo maxRetryCount, consulte Automatizar as novas tentativas de tarefas.
- MAX_RUN_DURATION: opcional. O tempo máximo que uma tarefa pode ser executada antes de ser repetida ou falhar, formatado como um valor em segundos seguido de s. Por exemplo, 3600s para 1 hora. Se o campo maxRunDuration não for especificado, o valor será definido como o tempo máximo de execução de um job. Para mais informações sobre o campo maxRunDuration, consulte Limitar os tempos de execução de tarefas e elementos executáveis usando timeouts.
- TASK_COUNT: opcional. O número de tarefas do job. O valor precisa ser um número inteiro entre 1 e o limite de tarefas por grupo. Se o campo taskCount não for especificado, o valor será definido como 1.
- PARALLELISM: opcional. O número de tarefas que o job executa simultaneamente. O número não pode ser maior que o número de tarefas e precisa ser um número inteiro entre 1 e o limite de tarefas paralelas por job. Se o campo parallelism não for especificado, o valor será definido como 1.
Crie um job usando 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.

Por exemplo, para criar um job que executa tarefas usando a imagem de contêiner do Docker busybox:

Crie um arquivo JSON no diretório atual chamado hello-world-container.json com o seguinte conteúdo:

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "container": {
                            "imageUri": "gcr.io/google-containers/busybox",
                            "entrypoint": "/bin/sh",
                            "commands": [
                                "-c",
                                "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                            ]
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                },
                "maxRetryCount": 2,
                "maxRunDuration": "3600s"
            },
            "taskCount": 4,
            "parallelism": 2
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": { "machineType": "e2-standard-4" }
            }
        ]
    },
    "labels": {
        "department": "finance",
        "env": "testing"
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Execute este comando:

gcloud batch jobs submit example-container-job \
  --location us-central1 \
  --config hello-world-container.json

API

Para criar um job de contêiner básico usando a API Batch, use o método jobs.create. Para mais informações sobre todos os campos que podem ser especificados para um job, consulte a documentação de referência do recurso REST projects.locations.jobs.

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

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "container": {
                            CONTAINER
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": CORES,
                    "memoryMib": MEMORY
                },
                "maxRetryCount": MAX_RETRY_COUNT,
                "maxRunDuration": "MAX_RUN_DURATION"
            },
            "taskCount": TASK_COUNT,
            "parallelism": PARALLELISM
        }
    ]
}

Substitua:

PROJECT_ID: o ID do projeto do seu projeto.
LOCATION: o local do job.
JOB_NAME: o nome do job.
CONTAINER: o contêiner em que cada tarefa é executada. No mínimo, um contêiner precisa especificar uma imagem no subcampo imageUri, mas outros subcampos também podem ser necessários. Para mais informações, consulte os subcampos container e o exemplo de job de contêiner nesta seção.
CORES: opcional. A quantidade de núcleos, especificamente vCPUs, que geralmente representam metade de um núcleo físico, para alocar para cada tarefa em unidades de milliCPU. Se o campo cpuMilli não for especificado, o valor será definido como 2000 (duas vCPUs).
MEMORY: opcional. A quantidade de memória a ser alocada para cada tarefa em MB. Se o campo memoryMib não for especificado, o valor será definido como 2000 (2 GB).
MAX_RETRY_COUNT: opcional. O número máximo de novas tentativas de uma tarefa. O valor precisa ser um número inteiro entre 0 e 10. Se o campo maxRetryCount não for especificado, o valor será definido como 0, o que significa não tentar a tarefa novamente. Para mais informações sobre o campo maxRetryCount, consulte Automatizar as novas tentativas de tarefas.
MAX_RUN_DURATION: opcional. O tempo máximo que uma tarefa pode ser executada antes de ser repetida ou falhar, formatado como um valor em segundos seguido de s. Por exemplo, 3600s para 1 hora. Se o campo maxRunDuration não for especificado, o valor será definido como o tempo máximo de execução de um job. Para mais informações sobre o campo maxRunDuration, consulte Limitar os tempos de execução de tarefas e elementos executáveis usando timeouts.
TASK_COUNT: opcional. O número de tarefas do job, que precisa ser um número inteiro entre 1 e o limite de tarefas por grupo de tarefas. Se o campo taskCount não for especificado, o valor será definido como 1.
PARALLELISM: opcional. O número de tarefas que o job executa simultaneamente. O número não pode ser maior que o número de tarefas e precisa ser um número inteiro entre 1 e o limite de tarefas paralelas por job. Se o campo parallelism não for especificado, o valor será definido como 1.

Por exemplo, para criar um job que executa tarefas usando a imagem do contêiner do Docker busybox, use a seguinte solicitação:

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/jobs?job_id=example-container-job

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "container": {
                            "imageUri": "gcr.io/google-containers/busybox",
                            "entrypoint": "/bin/sh",
                            "commands": [
                                "-c",
                                "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                            ]
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                },
                "maxRetryCount": 2,
                "maxRunDuration": "3600s"
            },
            "taskCount": 4,
            "parallelism": 2
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": { "machineType": "e2-standard-4" }
            }
        ]
    },
    "labels": {
        "department": "finance",
        "env": "testing"
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

em que PROJECT_ID é o ID do projeto.

Go

Para mais informações, consulte a documentação de referência da API Batch Go.

Para autenticar no Batch, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

import (
	"context"
	"fmt"
	"io"

	batch "cloud.google.com/go/batch/apiv1"
	"cloud.google.com/go/batch/apiv1/batchpb"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
)

// Creates and runs a job that runs the specified container
func createContainerJob(w io.Writer, projectID, region, jobName string) error {
	// projectID := "your_project_id"
	// region := "us-central1"
	// jobName := "some-job"

	ctx := context.Background()
	batchClient, err := batch.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer batchClient.Close()

	container := &batchpb.Runnable_Container{
		ImageUri:   "gcr.io/google-containers/busybox",
		Commands:   []string{"-c", "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."},
		Entrypoint: "/bin/sh",
	}

	// We can specify what resources are requested by each task.
	resources := &batchpb.ComputeResource{
		// CpuMilli is milliseconds per cpu-second. This means the task requires 2 whole CPUs.
		CpuMilli:  2000,
		MemoryMib: 16,
	}

	taskSpec := &batchpb.TaskSpec{
		Runnables: []*batchpb.Runnable{{
			Executable: &batchpb.Runnable_Container_{Container: container},
		}},
		ComputeResource: resources,
		MaxRunDuration: &durationpb.Duration{
			Seconds: 3600,
		},
		MaxRetryCount: 2,
	}

	// Tasks are grouped inside a job using TaskGroups.
	taskGroups := []*batchpb.TaskGroup{
		{
			TaskCount: 4,
			TaskSpec:  taskSpec,
		},
	}

	// 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 "e2-standard-4" machine type.
	// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
	allocationPolicy := &batchpb.AllocationPolicy{
		Instances: []*batchpb.AllocationPolicy_InstancePolicyOrTemplate{{
			PolicyTemplate: &batchpb.AllocationPolicy_InstancePolicyOrTemplate_Policy{
				Policy: &batchpb.AllocationPolicy_InstancePolicy{
					MachineType: "e2-standard-4",
				},
			},
		}},
	}

	// We use Cloud Logging as it's an out of the box available option
	logsPolicy := &batchpb.LogsPolicy{
		Destination: batchpb.LogsPolicy_CLOUD_LOGGING,
	}

	jobLabels := map[string]string{"env": "testing", "type": "container"}

	// The job's parent is the region in which the job will run
	parent := fmt.Sprintf("projects/%s/locations/%s", projectID, region)

	job := batchpb.Job{
		TaskGroups:       taskGroups,
		AllocationPolicy: allocationPolicy,
		Labels:           jobLabels,
		LogsPolicy:       logsPolicy,
	}

	req := &batchpb.CreateJobRequest{
		Parent: parent,
		JobId:  jobName,
		Job:    &job,
	}

	created_job, err := batchClient.CreateJob(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create job: %w", err)
	}

	fmt.Fprintf(w, "Job created: %v\n", created_job)

	return nil
}

Java

Para mais informações, consulte a documentação de referência da API Batch Java.

Para autenticar no Batch, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

import com.google.cloud.batch.v1.AllocationPolicy;
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.ComputeResource;
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.LogsPolicy.Destination;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.Runnable.Container;
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 CreateWithContainerNoMounting {

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

    createContainerJob(projectId, region, jobName);
  }

  // This method shows how to create a sample Batch Job that will run a simple command inside a
  // container on Cloud Compute instances.
  public static void createContainerJob(String projectId, String region, String jobName)
      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. After completing all of your requests, call
    // the `batchServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {

      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setContainer(
                  Container.newBuilder()
                      .setImageUri("gcr.io/google-containers/busybox")
                      .setEntrypoint("/bin/sh")
                      .addCommands("-c")
                      .addCommands(
                          "echo Hello world! This is task ${BATCH_TASK_INDEX}. "
                              + "This job has a total of ${BATCH_TASK_COUNT} tasks.")
                      .build())
              .build();

      // We can specify what resources are requested by each task.
      ComputeResource computeResource =
          ComputeResource.newBuilder()
              // In milliseconds per cpu-second. This means the task requires 2 whole CPUs.
              .setCpuMilli(2000)
              // In MiB.
              .setMemoryMib(16)
              .build();

      TaskSpec task =
          TaskSpec.newBuilder()
              // Jobs can be divided into tasks. In this case, we have only one task.
              .addRunnables(runnable)
              .setComputeResource(computeResource)
              .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(4).setTaskSpec(task).build();

      // 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 "e2-standard-4" machine type.
      // Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
      InstancePolicy instancePolicy =
          InstancePolicy.newBuilder().setMachineType("e2-standard-4").build();

      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(InstancePolicyOrTemplate.newBuilder().setPolicy(instancePolicy).build())
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "container")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(Destination.CLOUD_LOGGING).build())
              .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());
    }
  }
}

Node.js

Para mais informações, consulte a documentação de referência da API Batch Node.js.

Para autenticar no Batch, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
/**
 * The region you want to the job to run in. The regions that support Batch are listed here:
 * https://cloud.google.com/batch/docs/get-started#locations
 */
// const region = 'us-central-1';
/**
 * The name of the job that will be created.
 * It needs to be unique for each project and region pair.
 */
// const jobName = 'YOUR_JOB_NAME';

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

// Define what will be done as part of the job.
const task = new batch.TaskSpec();
const runnable = new batch.Runnable();
runnable.container = new batch.Runnable.Container();
runnable.container.imageUri = 'gcr.io/google-containers/busybox';
runnable.container.entrypoint = '/bin/sh';
runnable.container.commands = [
  '-c',
  'echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.',
];
task.runnables = [runnable];

// We can specify what resources are requested by each task.
const resources = new batch.ComputeResource();
resources.cpuMilli = 2000; // in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
resources.memoryMib = 16;
task.computeResource = resources;

task.maxRetryCount = 2;
task.maxRunDuration = {seconds: 3600};

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup();
group.taskCount = 4;
group.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 "e2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const allocationPolicy = new batch.AllocationPolicy();
const policy = new batch.AllocationPolicy.InstancePolicy();
policy.machineType = 'e2-standard-4';
const instances = new batch.AllocationPolicy.InstancePolicyOrTemplate();
instances.policy = policy;
allocationPolicy.instances = [instances];

const job = new batch.Job();
job.name = jobName;
job.taskGroups = [group];
job.allocationPolicy = allocationPolicy;
job.labels = {env: 'testing', type: 'container'};
// We use Cloud Logging as it's an option available out of the box
job.logsPolicy = new batch.LogsPolicy();
job.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 callCreateJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

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

await callCreateJob();

Python

Para mais informações, consulte a documentação de referência da API Batch Python.

Para autenticar no Batch, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

from google.cloud import batch_v1


def create_container_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 inside a container on Cloud Compute instances.

    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.
    runnable = batch_v1.Runnable()
    runnable.container = batch_v1.Runnable.Container()
    runnable.container.image_uri = "gcr.io/google-containers/busybox"
    runnable.container.entrypoint = "/bin/sh"
    runnable.container.commands = [
        "-c",
        "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.",
    ]

    # Jobs can be divided into tasks. In this case, we have only one task.
    task = batch_v1.TaskSpec()
    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 "e2-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 = "e2-standard-4"
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    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)

C++

Para mais informações, consulte a documentação de referência da API Batch C++.

Para autenticar no Batch, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

#include "google/cloud/batch/v1/batch_client.h"

  [](std::string const& project_id, std::string const& location_id,
     std::string const& job_id) {
    // Initialize the request; start with the fields that depend on the sample
    // input.
    google::cloud::batch::v1::CreateJobRequest request;
    request.set_parent("projects/" + project_id + "/locations/" + location_id);
    request.set_job_id(job_id);
    // Most of the job description is fixed in this example; use a string to
    // initialize it.
    auto constexpr kText = R"pb(
      task_groups {
        task_count: 4
        task_spec {
          compute_resource { cpu_milli: 500 memory_mib: 16 }
          max_retry_count: 2
          max_run_duration { seconds: 3600 }
          runnables {
            container {
              image_uri: "gcr.io/google-containers/busybox"
              entrypoint: "/bin/sh"
              commands: "-c"
              commands: "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
            }
          }
        }
      }
      allocation_policy {
        instances {
          policy { machine_type: "e2-standard-4" provisioning_model: STANDARD }
        }
      }
      labels { key: "env" value: "testing" }
      labels { key: "type" value: "container" }
      logs_policy { destination: CLOUD_LOGGING }
    )pb";
    auto* job = request.mutable_job();
    if (!google::protobuf::TextFormat::ParseFromString(kText, job)) {
      throw std::runtime_error("Error parsing Job description");
    }
    // Create a client and issue the request.
    auto client = google::cloud::batch_v1::BatchServiceClient(
        google::cloud::batch_v1::MakeBatchServiceConnection());
    auto response = client.CreateJob(request);
    if (!response) throw std::move(response).status();
    std::cout << "Job : " << response->DebugString() << "\n";
  }

Criar um job de script básico

É possível criar um job de script básico usando o console do Google Cloud , a CLI gcloud, a API Batch, Go, Java, Node.js, Python ou C++.

Console

Para criar um job de script básico usando o console do Google Cloud , faça o seguinte:

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

Acessar a lista de jobs
Clique em Criar. A página Criar job em lote é aberta. No painel à esquerda, a página Detalhes do job está selecionada.
Configure a página Detalhes do job:
1. Opcional: no campo Nome do job, personalize o nome do job.
  
  Por exemplo, insira example-basic-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 adicionar um script, faça o seguinte:
    1. Selecionar script. Um campo vai aparecer.
    2. No campo, insira um script que você quer executar para cada tarefa neste job.
      
      Por exemplo, insira o seguinte script:
      echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.
    3. Clique em Concluído.
  2. No campo Contagem de tarefas, insira o número de tarefas para este job. O valor precisa ser um número inteiro entre 1 e o limite de tarefas por grupo de tarefas.
    
    Por exemplo, insira 4.
  3. No campo Paralelismo, insira o número de tarefas a serem executadas simultaneamente. O número não pode ser maior que o total de tarefas e precisa ser um número inteiro entre 1 e o limite de tarefas paralelas por job.
    
    Por exemplo, insira 2.
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. 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.
  Por exemplo, selecione Padrão (padrão).
3. Selecione o local para este trabalho:
  1. No campo Região, selecione uma região.
    
    Por exemplo, selecione us-central1 (Iowa) (padrão).
  2. No campo Zona, faça o seguinte:
    - Se você quiser restringir essa job para que ela seja executada apenas em uma zona específica, selecione uma zona.
    - Caso contrário, selecione qualquer um.
    Por exemplo, selecione qualquer (padrão).
4. Selecione uma das seguintes famílias de máquinas:
  - Para cargas de trabalho comuns, clique em Uso geral.
  - Para cargas de trabalho que exigem alto desempenho, clique em Otimização de computação.
  - Para cargas de trabalho com uso intensivo de memória, clique em Otimização de memória.
  - Para cargas de trabalho otimizadas para aceleradores, clique em GPUs. Para mais informações, consulte Criar e executar um job que usa GPUs.
  Por exemplo, clique em Uso geral (padrão).
5. No campo Série, selecione uma série de máquinas para as VMs desse job.
  
  Por exemplo, se você selecionou Uso geral para a família de máquinas, selecione E2 (padrão).
6. No campo Tipo de máquina, selecione um tipo de máquina para as VMs desse job.
  
  Por exemplo, se você selecionou E2 para a série de máquinas, selecione e2-medium (2 vCPU, 4 GB de memória) (padrão).
7. 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).
Opcional: para revisar a configuração do job, no painel esquerdo, clique em Visualizar.
Clique em Criar.

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

gcloud

Para criar um job de script básico usando a CLI gcloud, faça o seguinte:

Crie um arquivo JSON que especifique os detalhes de configuração do job. Por exemplo, para criar um job de script básico, crie um arquivo JSON com o seguinte conteúdo. Para mais informações sobre todos os campos que podem ser especificados para um job, consulte a documentação de referência do recurso REST projects.locations.jobs.
```
{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            SCRIPT
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": CORES,
                    "memoryMib": MEMORY
                },
                "maxRetryCount": MAX_RETRY_COUNT,
                "maxRunDuration": "MAX_RUN_DURATION"
            },
            "taskCount": TASK_COUNT,
            "parallelism": PARALLELISM
        }
    ]
}
```
Substitua:
- SCRIPT: o script executado por cada tarefa. Um script precisa ser definido como texto usando o subcampo text ou como o caminho para um arquivo acessível usando o subcampo path. Para mais informações, consulte os subcampos script e o exemplo de job de script nesta seção.
- CORES: opcional. A quantidade de núcleos, especificamente vCPUs, que geralmente representam metade de um núcleo físico, para alocar para cada tarefa em unidades de milliCPU. Se o campo cpuMilli não for especificado, o valor será definido como 2000 (duas vCPUs).
- MEMORY: opcional. A quantidade de memória a ser alocada para cada tarefa em MB. Se o campo memoryMib não for especificado, o valor será definido como 2000 (2 GB).
- MAX_RETRY_COUNT: opcional. O número máximo de novas tentativas de uma tarefa. O valor precisa ser um número inteiro entre 0 e 10. Se o campo maxRetryCount não for especificado, o valor será definido como 0, o que significa não tentar a tarefa novamente. Para mais informações sobre o campo maxRetryCount, consulte Automatizar as novas tentativas de tarefas.
- MAX_RUN_DURATION: opcional. O tempo máximo que uma tarefa pode ser executada antes de ser repetida ou falhar, formatado como um valor em segundos seguido de s. Por exemplo, 3600s para 1 hora. Se o campo maxRunDuration não for especificado, o valor será definido como o tempo máximo de execução de um job. Para mais informações sobre o campo maxRunDuration, consulte Limitar os tempos de execução de tarefas e elementos executáveis usando timeouts.
- TASK_COUNT: opcional. O número de tarefas do job. O valor precisa ser um número inteiro entre 1 e o limite de tarefas por grupo. Se o campo taskCount não for especificado, o valor será definido como 1.
- PARALLELISM: opcional. O número de tarefas que o job executa simultaneamente. O número não pode ser maior que o número de tarefas e precisa ser um número inteiro entre 1 e o limite de tarefas paralelas por job. Se o campo parallelism não for especificado, o valor será definido como 1.
Crie um job usando 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.

Por exemplo, para criar um job que executa tarefas usando um script:

Crie um arquivo JSON no diretório atual chamado hello-world-script.json com o seguinte conteúdo:

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                },
                "maxRetryCount": 2,
                "maxRunDuration": "3600s"
            },
            "taskCount": 4,
            "parallelism": 2
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": { "machineType": "e2-standard-4" }
            }
        ]
    },
    "labels": {
        "department": "finance",
        "env": "testing"
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Execute este comando:

gcloud batch jobs submit example-script-job \
  --location us-central1 \
  --config hello-world-script.json

API

Para criar um job de script básico usando a API Batch, use o método jobs.create. Para mais informações sobre todos os campos que podem ser especificados para um job, consulte a documentação de referência do recurso REST projects.locations.jobs.

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

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            SCRIPT
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": CORES,
                    "memoryMib": MEMORY
                },
                "maxRetryCount": MAX_RETRY_COUNT,
                "maxRunDuration": "MAX_RUN_DURATION"
            },
            "taskCount": TASK_COUNT,
            "parallelism": PARALLELISM
        }
    ]
}

Substitua:

PROJECT_ID: o ID do projeto do seu projeto.
LOCATION: o local do job.
JOB_NAME: o nome do job.
SCRIPT: o script executado por cada tarefa. Um script precisa ser definido como texto usando o subcampo text ou como o caminho para um arquivo acessível usando o subcampo path. Para mais informações, consulte os subcampos script e o exemplo de job de script nesta seção.
CORES: opcional. A quantidade de núcleos, especificamente vCPUs, que geralmente representam metade de um núcleo físico, para alocar para cada tarefa em unidades de milliCPU. Se o campo cpuMilli não for especificado, o valor será definido como 2000 (duas vCPUs).
MEMORY: opcional. A quantidade de memória a ser alocada para cada tarefa em MB. Se o campo memoryMib não for especificado, o valor será definido como 2000 (2 GB).
MAX_RETRY_COUNT: opcional. O número máximo de novas tentativas de uma tarefa. O valor precisa ser um número inteiro entre 0 e 10. Se o campo maxRetryCount não for especificado, o valor será definido como 0, o que significa não tentar a tarefa novamente. Para mais informações sobre o campo maxRetryCount, consulte Automatizar as novas tentativas de tarefas.
MAX_RUN_DURATION: opcional. O tempo máximo que uma tarefa pode ser executada antes de ser repetida ou falhar, formatado como um valor em segundos seguido de s. Por exemplo, 3600s para 1 hora. Se o campo maxRunDuration não for especificado, o valor será definido como o tempo máximo de execução de um job. Para mais informações sobre o campo maxRunDuration, consulte Limitar os tempos de execução de tarefas e elementos executáveis usando timeouts.
TASK_COUNT: opcional. O número de tarefas do job. O valor precisa ser um número inteiro entre 1 e o limite de tarefas por grupo. Se o campo taskCount não for especificado, o valor será definido como 1.
PARALLELISM: opcional. O número de tarefas que o job executa simultaneamente. O número não pode ser maior que o número de tarefas e precisa ser um número inteiro entre 1 e o limite de tarefas paralelas por job. Se o campo parallelism não for especificado, o valor será definido como 1.

Por exemplo, para criar um job que executa tarefas usando um script, use a seguinte solicitação:

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/jobs?job_id=example-script-job

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                },
                "maxRetryCount": 2,
                "maxRunDuration": "3600s"
            },
            "taskCount": 4,
            "parallelism": 2
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": { "machineType": "e2-standard-4" }
            }
        ]
    },
    "labels": {
        "department": "finance",
        "env": "testing"
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

em que PROJECT_ID é o ID do projeto.

Go

Para mais informações, consulte a documentação de referência da API Batch Go.

Para autenticar no Batch, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

import (
	"context"
	"fmt"
	"io"

	batch "cloud.google.com/go/batch/apiv1"
	"cloud.google.com/go/batch/apiv1/batchpb"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
)

// Creates and runs a job that executes the specified script
func createScriptJob(w io.Writer, projectID, region, jobName string) error {
	// projectID := "your_project_id"
	// region := "us-central1"
	// jobName := "some-job"

	ctx := context.Background()
	batchClient, err := batch.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer batchClient.Close()

	// Define what will be done as part of the job.
	command := &batchpb.Runnable_Script_Text{
		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.
	// command := &batchpb.Runnable_Script_Path{
	// 	Path: "/tmp/test.sh",
	// }

	// We can specify what resources are requested by each task.
	resources := &batchpb.ComputeResource{
		// CpuMilli is milliseconds per cpu-second. This means the task requires 2 whole CPUs.
		CpuMilli:  2000,
		MemoryMib: 16,
	}

	taskSpec := &batchpb.TaskSpec{
		Runnables: []*batchpb.Runnable{{
			Executable: &batchpb.Runnable_Script_{
				Script: &batchpb.Runnable_Script{Command: command},
			},
		}},
		ComputeResource: resources,
		MaxRunDuration: &durationpb.Duration{
			Seconds: 3600,
		},
		MaxRetryCount: 2,
	}

	// Tasks are grouped inside a job using TaskGroups.
	taskGroups := []*batchpb.TaskGroup{
		{
			TaskCount: 4,
			TaskSpec:  taskSpec,
		},
	}

	// 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 "e2-standard-4" machine type.
	// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
	allocationPolicy := &batchpb.AllocationPolicy{
		Instances: []*batchpb.AllocationPolicy_InstancePolicyOrTemplate{{
			PolicyTemplate: &batchpb.AllocationPolicy_InstancePolicyOrTemplate_Policy{
				Policy: &batchpb.AllocationPolicy_InstancePolicy{
					MachineType: "e2-standard-4",
				},
			},
		}},
	}

	// We use Cloud Logging as it's an out of the box available option
	logsPolicy := &batchpb.LogsPolicy{
		Destination: batchpb.LogsPolicy_CLOUD_LOGGING,
	}

	jobLabels := map[string]string{"env": "testing", "type": "script"}

	// The job's parent is the region in which the job will run
	parent := fmt.Sprintf("projects/%s/locations/%s", projectID, region)

	job := batchpb.Job{
		TaskGroups:       taskGroups,
		AllocationPolicy: allocationPolicy,
		Labels:           jobLabels,
		LogsPolicy:       logsPolicy,
	}

	req := &batchpb.CreateJobRequest{
		Parent: parent,
		JobId:  jobName,
		Job:    &job,
	}

	created_job, err := batchClient.CreateJob(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create job: %w", err)
	}

	fmt.Fprintf(w, "Job created: %v\n", created_job)

	return nil
}

Java

Para mais informações, consulte a documentação de referência da API Batch Java.

Para autenticar no Batch, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

import com.google.cloud.batch.v1.AllocationPolicy;
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.ComputeResource;
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.LogsPolicy.Destination;
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 CreateWithScriptNoMounting {

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

    createScriptJob(projectId, region, jobName);
  }

  // This method shows how to create a sample Batch Job that will run
  // a simple command on Cloud Compute instances.
  public static void createScriptJob(String projectId, String region, String jobName)
      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. After completing all of your requests, call
    // the `batchServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    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();

      // We can specify what resources are requested by each task.
      ComputeResource computeResource =
          ComputeResource.newBuilder()
              // In milliseconds per cpu-second. This means the task requires 2 whole CPUs.
              .setCpuMilli(2000)
              // In MiB.
              .setMemoryMib(16)
              .build();

      TaskSpec task =
          TaskSpec.newBuilder()
              // Jobs can be divided into tasks. In this case, we have only one task.
              .addRunnables(runnable)
              .setComputeResource(computeResource)
              .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(4).setTaskSpec(task).build();

      // 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 "e2-standard-4" machine type.
      // Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
      InstancePolicy instancePolicy =
          InstancePolicy.newBuilder().setMachineType("e2-standard-4").build();

      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(InstancePolicyOrTemplate.newBuilder().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(Destination.CLOUD_LOGGING).build())
              .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());
    }
  }
}

Node.js

Para mais informações, consulte a documentação de referência da API Batch Node.js.

Para autenticar no Batch, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
/**
 * The region you want to the job to run in. The regions that support Batch are listed here:
 * https://cloud.google.com/batch/docs/get-started#locations
 */
// const region = 'us-central-1';
/**
 * The name of the job that will be created.
 * It needs to be unique for each project and region pair.
 */
// const jobName = 'YOUR_JOB_NAME';

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

// Define what will be done as part of the job.
const task = new batch.TaskSpec();
const runnable = new batch.Runnable();
runnable.script = new batch.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.
const resources = new batch.ComputeResource();
resources.cpuMilli = 2000; // in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
resources.memoryMib = 16;
task.computeResource = resources;

task.maxRetryCount = 2;
task.maxRunDuration = {seconds: 3600};

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup();
group.taskCount = 4;
group.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 "e2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const allocationPolicy = new batch.AllocationPolicy();
const policy = new batch.AllocationPolicy.InstancePolicy();
policy.machineType = 'e2-standard-4';
const instances = new batch.AllocationPolicy.InstancePolicyOrTemplate();
instances.policy = policy;
allocationPolicy.instances = [instances];

const job = new batch.Job();
job.name = jobName;
job.taskGroups = [group];
job.allocationPolicy = allocationPolicy;
job.labels = {env: 'testing', type: 'script'};
// We use Cloud Logging as it's an option available out of the box
job.logsPolicy = new batch.LogsPolicy();
job.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 callCreateJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

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

await callCreateJob();

Python

Para mais informações, consulte a documentação de referência da API Batch Python.

Para autenticar no Batch, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

from google.cloud import batch_v1


def create_script_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.

    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
    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 "e2-standard-4" machine type.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    allocation_policy = batch_v1.AllocationPolicy()
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "e2-standard-4"
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    allocation_policy.instances = [instances]

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "script"}
    # 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)

C++

Para mais informações, consulte a documentação de referência da API Batch C++.

Para autenticar no Batch, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

#include "google/cloud/batch/v1/batch_client.h"

  [](std::string const& project_id, std::string const& location_id,
     std::string const& job_id) {
    // Initialize the request; start with the fields that depend on the sample
    // input.
    google::cloud::batch::v1::CreateJobRequest request;
    request.set_parent("projects/" + project_id + "/locations/" + location_id);
    request.set_job_id(job_id);
    // Most of the job description is fixed in this example; use a string to
    // initialize it.
    auto constexpr kText = R"pb(
      task_groups {
        task_count: 4
        task_spec {
          compute_resource { cpu_milli: 500 memory_mib: 16 }
          max_retry_count: 2
          max_run_duration { seconds: 3600 }
          runnables {
            script {
              text: "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
            }
          }
        }
      }
      allocation_policy {
        instances {
          policy { machine_type: "e2-standard-4" provisioning_model: STANDARD }
        }
      }
      labels { key: "env" value: "testing" }
      labels { key: "type" value: "script" }
      logs_policy { destination: CLOUD_LOGGING }
    )pb";
    auto* job = request.mutable_job();
    if (!google::protobuf::TextFormat::ParseFromString(kText, job)) {
      throw std::runtime_error("Error parsing Job description");
    }
    // Create a client and issue the request.
    auto client = google::cloud::batch_v1::BatchServiceClient(
        google::cloud::batch_v1::MakeBatchServiceConnection());
    auto response = client.CreateJob(request);
    if (!response) throw std::move(response).status();
    std::cout << "Job : " << response->DebugString() << "\n";
  }

Usar variáveis de ambiente

Use variáveis de ambiente ao escrever uma imagem de contêiner ou um script para executar um job. É possível usar qualquer uma das variáveis de ambiente predefinidas para todos os jobs em lote e qualquer variável de ambiente personalizada definida durante a criação do job.

Usar variáveis de ambiente predefinidas

Por padrão, os runnables no job podem usar as seguintes variáveis de ambiente predefinidas:

BATCH_TASK_COUNT: o número total de tarefas neste grupo.
BATCH_TASK_INDEX: o número de índice dessa tarefa no grupo de tarefas. O índice da primeira tarefa é 0 e é incrementado para cada tarefa adicional.
BATCH_HOSTS_FILE: o caminho para um arquivo que lista todas as instâncias de VM em execução neste grupo de tarefas. Para usar essa variável de ambiente, o campo requireHostsFile precisa ser definido como true.
BATCH_TASK_RETRY_ATTEMPT: o número de vezes que essa tarefa já foi tentada. O valor é 0 durante a primeira tentativa de uma tarefa e é incrementado para cada nova tentativa. O número total de novas tentativas permitidas para uma tarefa é determinado pelo valor do campo maxRetryCount, que é 0 se indefinido. Para mais informações sobre novas tentativas, consulte Automatizar novas tentativas de tarefas.

Para conferir um exemplo de como usar variáveis de ambiente predefinidas, consulte os exemplos de executáveis anteriores em Criar um job básico neste documento.

Definir e usar variáveis de ambiente personalizadas

Também é possível definir uma ou mais variáveis de ambiente personalizadas em um job.

Você define cada variável em um ambiente específico com base no escopo desejado dos dados:

Para uma variável que tem o mesmo valor para todas as tarefas, use uma destas opções:
- Se a variável tiver o mesmo valor para todos os executáveis, use o ambiente de todos os executáveis (subcampo environment de taskSpec).
- Caso contrário, se a variável tiver um valor separado para todos os executáveis, use um ou mais ambientes de executáveis específicos (subcampo environment de runnables[]).
Caso contrário, para uma variável matriz com um valor separado para cada tarefa, use o ambiente de todas as tarefas (taskEnvironment).

No ambiente selecionado, você define o nome e os valores de cada variável usando um dos seguintes subcampos de ambiente:

Para definir a variável diretamente no arquivo JSON de configuração do job, use o subcampo variáveis padrão (variables), conforme mostrado nesta seção. Essa opção é recomendada para dados que você não quer criptografar.
Para definir a variável usando dados criptografados, use o Gerenciador de segredos ou o Cloud Key Management Service:
- Para usar o conteúdo criptografado de um secret do Secret Manager, use o subcampo variáveis secretas (secretVariables). Para mais informações sobre o uso de secrets em um job, consulte Proteger dados sensíveis usando o Secret Manager.
- Para usar o conteúdo criptografado de uma chave do Cloud Key Management Service, use o subcampo variáveis criptografadas (encryptedVariables). Para mais informações sobre as chaves do Cloud KMS, consulte a documentação do Cloud Key Management Service.

É possível definir e usar variáveis de ambiente personalizadas para seu job usando a CLI gcloud ou a API Batch. Os exemplos a seguir explicam como criar dois jobs que definem e usam variáveis padrão. O primeiro job de exemplo tem uma variável para um executável específico. O segundo job de exemplo tem uma variável de matriz, que tem um valor diferente para cada tarefa.

gcloud

Se você quiser definir um job que transmita uma variável de ambiente para um executável que cada tarefa executa, consulte o exemplo sobre como definir e usar uma variável de ambiente para um executável. Caso contrário, se você quiser definir um job que transmita uma lista de variáveis de ambiente para diferentes tarefas com base no índice de tarefas, consulte o exemplo de como definir e usar uma variável de ambiente para cada tarefa.

Definir e usar uma variável de ambiente para um executável

Para criar um job que transmita variáveis de ambiente para um executável usando a CLI gcloud, use o comando gcloud batch jobs submit e especifique as variáveis de ambiente no arquivo de configuração do job.

Por exemplo, para criar um job de script que define uma variável de ambiente e a transmite aos scripts de três tarefas, faça a seguinte solicitação:

Crie um arquivo JSON no diretório atual chamado hello-world-environment-variables.json com o seguinte conteúdo:

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello ${VARIABLE_NAME}! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                        },
                        "environment": {
                            "variables": {
                                "VARIABLE_NAME": "VARIABLE_VALUE"
                            }
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                }
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "machineType": "e2-standard-4"
                }
            }
        ]
    }
}

Substitua:

VARIABLE_NAME: o nome da variável de ambiente transmitida para cada tarefa. Por convenção, os nomes das variável de ambiente são letras maiúsculas.
VARIABLE_VALUE: opcional. O valor da variável de ambiente transmitido para cada tarefa.

Execute este comando:

gcloud batch jobs submit example-environment-variables-job \
  --location us-central1 \
  --config hello-world-environment-variables.json

Definir e usar uma variável de ambiente para cada tarefa

Para criar um job que transmita variáveis de ambiente para uma tarefa com base no índice de tarefas usando a CLI gcloud, use o comando gcloud batch jobs submit e especifique o campo de matriz taskEnvironments no arquivo de configuração do job.

Por exemplo, para criar um job que inclua uma matriz de três variáveis de ambiente com nomes correspondentes e valores diferentes e transmita as variáveis de ambiente aos scripts das tarefas cujos índices correspondem aos índices das variáveis de ambiente na matriz:

Crie um arquivo JSON no diretório atual chamado hello-world-task-environment-variables.json com o seguinte conteúdo:

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello ${TASK_VARIABLE_NAME}! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                        },
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                }
            },
            "taskCount": 3,
            "taskEnvironments": [
                {
                    "variables": {
                        "TASK_VARIABLE_NAME": "TASK_VARIABLE_VALUE_0"
                    }
                },
                {
                    "variables": {
                        "TASK_VARIABLE_NAME": "TASK_VARIABLE_VALUE_1"
                    }
                },
                {
                    "variables": {
                        "TASK_VARIABLE_NAME": "TASK_VARIABLE_VALUE_2"
                    }
                }
            ]
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "machineType": "e2-standard-4"
                }
            }
        ]
    }
}

Substitua:

TASK_VARIABLE_NAME: o nome das variáveis de ambiente da tarefa transmitidas às tarefas com índices correspondentes. Por convenção, os nomes das variável de ambiente são letras maiúsculas.
TASK_VARIABLE_VALUE_0: o valor da variável de ambiente transmitida para a primeira tarefa, para a qual BATCH_TASK_INDEX é igual a 0.
TASK_VARIABLE_VALUE_1: o valor da variável de ambiente transmitida para a segunda tarefa, para a qual BATCH_TASK_INDEX é igual a 1.
TASK_VARIABLE_VALUE_2: o valor da variável de ambiente transmitida para a terceira tarefa, para a qual BATCH_TASK_INDEX é igual a 2.

Execute este comando:

gcloud batch jobs submit example-task-environment-variables-job \
  --location us-central1 \
  --config hello-world-task-environment-variables.json

API

Definir e usar uma variável de ambiente para um executável

Para criar um job que transmita variáveis de ambiente para um executável usando a API Batch, use o comando gcloud batch jobs submit e especifique as variáveis de ambiente no campo environment.

Por exemplo, para criar um job que inclua uma variável de ambiente e a transmita aos scripts de três tarefas, faça a seguinte solicitação:

POST https://batch.googleapis.com/v1/projects/<var>PROJECT_ID</var>/locations/us-central1/jobs?job_id=example-environment-variables-job

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello ${VARIABLE_NAME}! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                        },
                        "environment": {
                            "variables": {
                                "VARIABLE_NAME": "VARIABLE_VALUE"
                            }
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                }
            },
            "taskCount": 3,
            "parallelism": 1
        }

    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "machineType": "e2-standard-4"
                }
            }
        ]
    }
}

Substitua:

PROJECT_ID: o ID do projeto do seu projeto.
VARIABLE_NAME: o nome da variável de ambiente transmitida para cada tarefa. Por convenção, os nomes de variável de ambiente são escritos com letras maiúsculas.
VARIABLE_VALUE: o valor da variável de ambiente transmitido para cada tarefa.

Definir e usar uma variável de ambiente para cada tarefa

Para criar um job que transmita variáveis de ambiente para uma tarefa com base no índice de tarefas usando a API Batch, use o método jobs.create e especifique as variáveis de ambiente no campo de matriz taskEnvironments.

Por exemplo, para criar um job que inclua uma matriz de três variáveis de ambiente com nomes correspondentes e valores diferentes e transmita as variáveis de ambiente aos scripts de três tarefas com base nos índices, faça a seguinte solicitação:

POST https://batch.googleapis.com/v1/projects/<var>PROJECT_ID</var>/locations/us-central1/jobs?job_id=example-task-environment-variables-job

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello ${TASK_VARIABLE_NAME}! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                        },
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                }
            },
            "taskCount": 3,
            "taskEnvironments": [
                {
                    "variables": {
                        "TASK_VARIABLE_NAME": "TASK_VARIABLE_VALUE_0"
                    }
                },
                {
                    "variables": {
                        "TASK_VARIABLE_NAME": "TASK_VARIABLE_VALUE_1"
                    }
                },
                {
                    "variables": {
                        "TASK_VARIABLE_NAME": "TASK_VARIABLE_VALUE_2"
                    }
                }
            ]
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": { "machineType": "e2-standard-4" }
            }
        ]
    }
}

Substitua:

PROJECT_ID: o ID do projeto do seu projeto.
TASK_VARIABLE_NAME: o nome das variáveis de ambiente transmitidas às tarefas com índices correspondentes. Por convenção, os nomes variável de ambiente são com letra maiúscula.
TASK_VARIABLE_VALUE_0: o valor da variável de ambiente transmitida para a primeira tarefa, para a qual BATCH_TASK_INDEX é igual a 0.
TASK_VARIABLE_VALUE_1: o valor da variável de ambiente transmitida para a segunda tarefa, para a qual BATCH_TASK_INDEX é igual a 1.
TASK_VARIABLE_VALUE_2: o valor da variável de ambiente transmitida para a terceira tarefa, para a qual BATCH_TASK_INDEX é igual a 2.

A seguir

Se você tiver problemas para criar ou executar um job, consulte Solução de problemas.
Conferir jobs e tarefas.
Saiba mais sobre as opções de criação de jobs.