Crie e execute uma tarefa que use volumes de armazenamento

Este documento explica como criar e executar uma tarefa em lote que usa um ou mais volumes de armazenamento externos. As opções de armazenamento externo incluem um disco persistente novo ou existente, SSDs locais novos, contentores do Cloud Storage existentes e um sistema de ficheiros de rede (NFS) existente, como uma partilha de ficheiros do Filestore.

Independentemente de adicionar volumes de armazenamento externo, cada VM do Compute Engine para uma tarefa tem um disco de arranque, que fornece armazenamento para a imagem e as instruções do sistema operativo (SO) da tarefa. Para obter informações sobre a configuração do disco de arranque para uma tarefa, consulte o artigo Vista geral do ambiente do SO da VM.

Antes de começar

  1. Se nunca usou o Batch, reveja o artigo Comece a usar o Batch e ative o Batch concluindo os pré-requisitos para projetos e utilizadores.

  2. Para receber as autorizações de que precisa para criar uma tarefa, peça ao seu administrador para lhe conceder as seguintes funções de IAM:

    Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

    Também pode conseguir as autorizações necessárias através de funções personalizadas ou outras funções predefinidas.

Crie uma tarefa que use volumes de armazenamento

Opcionalmente, uma tarefa pode usar um ou mais de cada um dos seguintes tipos de volumes de armazenamento externo. Para mais informações acerca de todos os tipos de volumes de armazenamento e das diferenças e restrições de cada um, consulte a documentação sobre as opções de armazenamento de VMs do Compute Engine.

Pode permitir que uma tarefa use cada volume de armazenamento, incluindo-o na definição da tarefa e especificando o respetivo caminho de montagem (mountPath) nos ficheiros executáveis. Para saber como criar uma tarefa que use volumes de armazenamento, consulte uma ou mais das seguintes secções:

Use um disco persistente

Uma tarefa que usa discos persistentes tem as seguintes restrições:

  • Todos os discos persistentes: reveja as restrições para todos os discos persistentes.

  • Discos persistentes novos versus existentes: cada disco persistente num trabalho pode ser novo (definido e criado com o trabalho) ou existente (já criado no seu projeto e especificado no trabalho). Para usar um disco persistente, tem de ser formatado e montado nas VMs do trabalho, que têm de estar na mesma localização que o disco persistente. O Batch monta todos os discos persistentes que incluir num trabalho e formata todos os novos discos persistentes, mas tem de formatar e desmontar todos os discos persistentes existentes que quer que um trabalho use.

    As opções de localização, opções de formato> e opções de montagem suportadas variam entre discos persistentes novos e existentes, conforme descrito na seguinte tabela:

    Novos discos persistentes Discos persistentes existentes
    Opções de formato

    O disco persistente é formatado automaticamente com um ext4sistema de ficheiros.

    Tem de formatar o disco persistente para usar um ext4 sistema de ficheiros antes de o usar para uma tarefa.

    Opções de montagem

    Todas as opções são suportadas.

    Todas as opções, exceto a escrita, são suportadas. Isto deve-se a restrições do modo de vários autores.

    Tem de desassociar o disco persistente de todas as VMs às quais está associado antes de o usar para uma tarefa.
    Opções de localização

    Só pode criar discos persistentes zonais.

    Pode selecionar qualquer localização para o seu trabalho. Os discos persistentes são criados na zona em que o seu projeto é executado.

    Pode selecionar discos persistentes zonais e regionais.


    Tem de definir a localização da tarefa (ou, se especificado, apenas as localizações permitidas) para apenas localizações que contenham todos os discos persistentes da tarefa. Por exemplo, para um disco persistente zonal, a localização da tarefa tem de ser a zona do disco; para um disco persistente regional, a localização da tarefa tem de ser a região do disco ou, se especificar zonas, uma ou ambas as zonas específicas onde o disco persistente regional está localizado.

  • Modelos de instâncias: se quiser usar um modelo de instância de VM ao criar esta tarefa, tem de anexar todos os discos persistentes para esta tarefa no modelo de instância. Caso contrário, se não quiser usar um modelo de instância, tem de anexar todos os discos persistentes diretamente na definição da tarefa.

Pode criar uma tarefa que use um disco persistente através da Google Cloud consola, da CLI gcloud, da API Batch, C++, Go, Java, Node.js ou Python.

Consola

Usando a Google Cloud consola, o exemplo seguinte cria uma tarefa que executa um script para ler um ficheiro de um disco persistente zonal existente que está localizado na zona us-central1-a. O script de exemplo pressupõe que a tarefa tem um disco persistente zonal existente que contém um ficheiro de texto denominado example.txt no diretório raiz.

Opcional: crie um disco persistente zonal de exemplo

Se quiser criar um disco persistente zonal que possa usar para executar o script de exemplo, faça o seguinte antes de criar a tarefa:

  1. Anexe um novo disco persistente vazio denominado example-disk a uma VM do Linux na zona us-central1-a e, em seguida, execute comandos na VM para formatar e montar o disco. Para ver instruções, consulte o artigo Adicione um disco persistente à sua VM.

    Não se desligue ainda da VM.

  2. Para criar example.txt no disco persistente, execute os seguintes comandos na VM:

    1. Para alterar o diretório de trabalho atual para o diretório raiz do disco persistente, escreva o seguinte comando:

      cd VM_MOUNT_PATH

      Substitua VM_MOUNT_PATH pelo caminho para o diretório onde o disco persistente foi montado nesta VM no passo anterior, por exemplo, /mnt/disks/example-disk.

    2. Prima Enter.

    3. Para criar e definir um ficheiro denominado example.txt, escreva o seguinte comando:

      cat > example.txt

    4. Prima Enter.

    5. Escreva o conteúdo do ficheiro. Por exemplo, escreva Hello world!.

    6. Para guardar o ficheiro, prima Ctrl+D (ou Command+D no macOS).

    Quando terminar, pode desligar-se da VM.

  3. Desassocie o disco persistente da VM.

    • Se já não precisar da VM, pode eliminá-la, o que desanexa automaticamente o disco persistente.

    • Caso contrário, desassocie o disco persistente. Para ver instruções, consulte o artigo Desassociar e voltar a associar discos de arranque e desassocie o disco persistente example-disk em vez do disco de arranque da VM.

Crie uma tarefa que use o disco persistente zonal existente

Para criar uma tarefa que use discos persistentes zonais existentes através da consolaGoogle Cloud , faça o seguinte:

  1. Na Google Cloud consola, aceda à página Lista de tarefas.

    Aceda à lista de trabalhos

  2. Clique em Criar. É apresentada a página Criar tarefa em lote. No painel do lado esquerdo, a página Detalhes da tarefa está selecionada.

  3. Configure a página Detalhes da tarefa:

    1. Opcional: no campo Nome da tarefa, personalize o nome da tarefa.

      Por exemplo, introduza example-disk-job.

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

      1. Na janela Novo executável, adicione, pelo menos, um script ou um contentor para que esta tarefa seja executada.

        Por exemplo, para executar um script que imprime o conteúdo de um ficheiro denominado example.txt e localizado no diretório de raiz do disco persistente que esta tarefa usa, faça o seguinte:

        1. Selecione a caixa de verificação Script. É apresentada uma caixa de texto.

        2. Na caixa de texto, introduza o seguinte script:

          echo "Here is the content of the example.txt file in the persistent disk."
cat MOUNT_PATH/example.txt

          Substitua MOUNT_PATH pelo caminho para onde planeia montar o disco persistente nas VMs para esta tarefa, por exemplo, /mnt/disks/example-disk.

        3. Clique em Concluído.

      2. No campo Número de tarefas, introduza o número de tarefas para este trabalho.

        Por exemplo, introduza 1 (predefinição).

      3. No campo Paralelismo, introduza o número de tarefas a executar em simultâneo.

        Por exemplo, introduza 1 (predefinição).

  4. Configure a página Especificações de recursos:

    1. No painel esquerdo, clique em Especificações de recursos. É apresentada a página Especificações dos recursos.

    2. Selecione a localização para este trabalho. Para usar um disco persistente zonal existente, as VMs de uma tarefa têm de estar localizadas na mesma zona.

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

        Por exemplo, para usar o disco persistente zonal de exemplo, selecione us-central1 (Iowa) (predefinição).

      2. No campo Zona, selecione uma zona.

        Por exemplo, selecione us-central1-a (Iowa).

  5. Configure a página Configurações adicionais:

    1. No painel esquerdo, clique em Configurações adicionais. É apresentada a página Configurações adicionais.

    2. Para cada disco persistente zonal existente que quer montar nesta tarefa, faça o seguinte:

      1. Na secção Volume de armazenamento, clique em Adicionar novo volume. É apresentada a janela Novo volume.

      2. Na janela Novo volume, faça o seguinte:

        1. Na secção Tipo de volume, selecione Disco persistente (predefinição).

        2. Na lista Disco, selecione um disco persistente zonal existente que quer montar neste trabalho. O disco tem de estar localizado na mesma zona que esta tarefa.

          Por exemplo, selecione o disco persistente zonal existente que preparou, que se encontra na zona us-central1-a e contém o ficheiro example.txt.

        3. Opcional: se quiser mudar o nome deste disco persistente zonal, faça o seguinte:

          1. Selecione Personalizar o nome do dispositivo.

          2. No campo Nome do dispositivo, introduza o novo nome do disco.

        4. No campo Caminho de montagem, introduza o caminho de montagem (MOUNT_PATH) para este Persistent Disk:

          Por exemplo, introduza o seguinte:

          /mnt/disks/EXISTING_PERSISTENT_DISK_NAME

          Substitua EXISTING_PERSISTENT_DISK_NAME pelo nome do disco. Se mudou o nome do disco persistente zonal, use o novo nome.

          Por exemplo, substitua EXISTING_PERSISTENT_DISK_NAME por example-disk.

        5. Clique em Concluído.

  6. Opcional: configure os outros campos desta tarefa.

  7. Opcional: para rever a configuração da tarefa, no painel esquerdo, clique em Pré-visualizar.

  8. Clique em Criar.

A página Detalhes do trabalho apresenta o trabalho que criou.

gcloud

Usando a CLI gcloud, o exemplo seguinte cria uma tarefa que anexa e monta um disco persistente existente e um novo disco persistente. A tarefa tem 3 tarefas que executam um script para criar um ficheiro no novo disco persistente denominado output_task_TASK_INDEX.txt, onde TASK_INDEX é o índice de cada tarefa: 0, 1 e 2.

Para criar uma tarefa que use discos persistentes através da CLI gcloud, use o comando gcloud batch jobs submit. No ficheiro de configuração JSON da tarefa, especifique os discos persistentes no campo instances e monte o disco persistente no campo volumes.

  1. Crie um ficheiro JSON.

    • Se não estiver a usar um modelo de instância para esta tarefa, crie um ficheiro JSON com o seguinte conteúdo:

      {
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "disks": [
                        {
                            "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                            "existingDisk": "projects/PROJECT_ID/EXISTING_PERSISTENT_DISK_LOCATION/disks/EXISTING_PERSISTENT_DISK_NAME"
                        },
                        {
                            "newDisk": {
                                "sizeGb": NEW_PERSISTENT_DISK_SIZE,
                                "type": "NEW_PERSISTENT_DISK_TYPE"
                            },
                            "deviceName": "NEW_PERSISTENT_DISK_NAME"
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "EXISTING_PERSISTENT_DISK_LOCATION"
            ]
        }
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "NEW_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/NEW_PERSISTENT_DISK_NAME",
                        "mountOptions": "rw,async"
                    },
                    {

                        "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/EXISTING_PERSISTENT_DISK_NAME"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

      Substitua o seguinte:

      • PROJECT_ID: o ID do projeto do seu projeto.
      • EXISTING_PERSISTENT_DISK_NAME: o nome de um disco persistente existente.
      • EXISTING_PERSISTENT_DISK_LOCATION: a localização de um disco persistente existente. Para cada disco persistente zonal existente, a localização da tarefa tem de ser a zona do disco; para cada disco persistente regional existente, a localização da tarefa tem de ser a região do disco ou, se especificar zonas, uma ou ambas as zonas específicas onde o disco persistente regional está localizado. Se não estiver a especificar discos persistentes existentes, pode selecionar qualquer localização. Saiba mais acerca do campo allowedLocations.
      • NEW_PERSISTENT_DISK_SIZE: o tamanho do novo disco persistente em GB. Os tamanhos permitidos dependem do tipo de disco persistente, mas o mínimo é frequentemente 10 GB (10) e o máximo é frequentemente 64 TB (64000).
      • NEW_PERSISTENT_DISK_TYPE: o tipo de disco do novo disco persistente, pd-standard, pd-balanced, pd-ssd ou pd-extreme. O tipo de disco predefinido para discos persistentes não de arranque é pd-standard.
      • NEW_PERSISTENT_DISK_NAME: o nome do novo disco persistente.

    • Se estiver a usar um modelo de instância de VM para esta tarefa, crie um ficheiro JSON, conforme mostrado anteriormente, exceto que deve substituir o instances campo pelo seguinte:

      "instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],

      onde INSTANCE_TEMPLATE_NAME é o nome do modelo de instância para esta tarefa. Para uma tarefa que usa discos persistentes, este modelo de instância tem de definir e anexar os discos persistentes que quer que a tarefa use. Para este exemplo, o modelo tem de definir e anexar um novo disco persistente denominado NEW_PERSISTENT_DISK_NAME e anexar um disco persistente existente denominado EXISTING_PERSISTENT_DISK_NAME.

  2. Execute o seguinte comando:

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

    Substitua o seguinte:

    • JOB_NAME: o nome da tarefa.

    • LOCATION: a localização do trabalho.

    • JSON_CONFIGURATION_FILE: o caminho para um ficheiro JSON com os detalhes de configuração da tarefa.

API

Usando a API Batch, o exemplo seguinte cria uma tarefa que anexa e monta um disco persistente existente e um novo disco persistente. A tarefa tem 3 tarefas que executam um script para criar um ficheiro no novo disco persistente denominado output_task_TASK_INDEX.txt, onde TASK_INDEX é o índice de cada tarefa: 0, 1 e 2.

Para criar uma tarefa que use discos persistentes com a API Batch, use o método jobs.create. No pedido, especifique os discos persistentes no campo instances e monte o disco persistente no campo volumes.

  • Se não estiver a usar um modelo de instância para esta tarefa, faça o seguinte pedido:

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

{
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "disks": [
                        {
                            "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                            "existingDisk": "projects/PROJECT_ID/EXISTING_PERSISTENT_DISK_LOCATION/disks/EXISTING_PERSISTENT_DISK_NAME"
                        },
                        {
                            "newDisk": {
                                "sizeGb": NEW_PERSISTENT_DISK_SIZE,
                                "type": "NEW_PERSISTENT_DISK_TYPE"
                            },
                            "deviceName": "NEW_PERSISTENT_DISK_NAME"
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "EXISTING_PERSISTENT_DISK_LOCATION"
            ]
        }
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "NEW_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/NEW_PERSISTENT_DISK_NAME",
                        "mountOptions": "rw,async"
                    },
                    {

                        "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/EXISTING_PERSISTENT_DISK_NAME"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Substitua o seguinte:

    • PROJECT_ID: o ID do projeto do seu projeto.
    • LOCATION: a localização do trabalho.
    • JOB_NAME: o nome da tarefa.
    • EXISTING_PERSISTENT_DISK_NAME: o nome de um disco persistente existente.
    • EXISTING_PERSISTENT_DISK_LOCATION: a localização de um disco persistente existente. Para cada disco persistente zonal existente, a localização da tarefa tem de ser a zona do disco. Para cada disco persistente regional existente, a localização da tarefa tem de ser a região do disco ou, se especificar zonas, uma ou ambas as zonas específicas onde o disco persistente regional está localizado. Se não estiver a especificar discos persistentes existentes, pode selecionar qualquer localização. Saiba mais acerca do campo allowedLocations.
    • NEW_PERSISTENT_DISK_SIZE: o tamanho do novo disco persistente em GB. Os tamanhos permitidos dependem do tipo de disco persistente, mas o mínimo é frequentemente 10 GB (10) e o máximo é frequentemente 64 TB (64000).
    • NEW_PERSISTENT_DISK_TYPE: o tipo de disco do novo disco persistente, pd-standard, pd-balanced, pd-ssd ou pd-extreme. O tipo de disco predefinido para discos persistentes não de arranque é pd-standard.
    • NEW_PERSISTENT_DISK_NAME: o nome do novo disco persistente.

  • Se estiver a usar um modelo de instância de VM para esta tarefa, crie um ficheiro JSON, conforme mostrado anteriormente, exceto que deve substituir o instances campo pelo seguinte:

    "instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],
...

    Onde INSTANCE_TEMPLATE_NAME é o nome do modelo de instância para esta tarefa. Para uma tarefa que usa discos persistentes, este modelo de instância tem de definir e anexar os discos persistentes que quer que a tarefa use. Para este exemplo, o modelo tem de definir e anexar um novo disco persistente denominado NEW_PERSISTENT_DISK_NAME e anexar um disco persistente existente denominado EXISTING_PERSISTENT_DISK_NAME.

C++

Para criar uma tarefa em lote que use discos persistentes novos ou existentes com as bibliotecas de cliente do Google Cloud para C++, use a função CreateJob e inclua o seguinte:

  • Para anexar discos persistentes às VMs de uma tarefa, inclua um dos seguintes:
    • Se não estiver a usar um modelo de instância de VM para esta tarefa, use o método set_remote_path.
    • Se estiver a usar um modelo de instância de VM para esta tarefa, use o método set_instance_template.
  • Para montar os discos persistentes na tarefa, use o campo volumes com os campos deviceName e mountPath. Para novos discos persistentes, também pode usar o campo mountOptions para ativar a escrita.

Para ver um exemplo de código de um exemplo de utilização semelhante, consulte o artigo Use um contentor do Cloud Storage.

Ir

Para criar uma tarefa em lote que use discos persistentes novos ou existentes através das bibliotecas de cliente do Google Cloud para Go, use a função CreateJob e inclua o seguinte:

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 with persistent disk
func createJobWithPD(w io.Writer, projectID, jobName, pdName string) error {
	// jobName := job-name
	// pdName := disk-name
	ctx := context.Background()
	batchClient, err := batch.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("batchClient error: %w", err)
	}
	defer batchClient.Close()

	runn := &batchpb.Runnable{
		Executable: &batchpb.Runnable_Script_{
			Script: &batchpb.Runnable_Script{
				Command: &batchpb.Runnable_Script_Text{
					Text: "echo Hello world from script 1 for task ${BATCH_TASK_INDEX}",
				},
			},
		},
	}
	volume := &batchpb.Volume{
		MountPath: fmt.Sprintf("/mnt/disks/%v", pdName),
		Source: &batchpb.Volume_DeviceName{
			DeviceName: pdName,
		},
	}

	// The disk type of the new persistent disk, either pd-standard,
	// pd-balanced, pd-ssd, or pd-extreme. For Batch jobs, the default is pd-balanced
	disk := &batchpb.AllocationPolicy_Disk{
		Type:   "pd-balanced",
		SizeGb: 10,
	}

	taskSpec := &batchpb.TaskSpec{
		ComputeResource: &batchpb.ComputeResource{
			// CpuMilli is milliseconds per cpu-second. This means the task requires 1 CPU.
			CpuMilli:  1000,
			MemoryMib: 16,
		},
		MaxRunDuration: &durationpb.Duration{
			Seconds: 3600,
		},
		MaxRetryCount: 2,
		Runnables:     []*batchpb.Runnable{runn},
		Volumes:       []*batchpb.Volume{volume},
	}

	taskGroups := []*batchpb.TaskGroup{
		{
			TaskCount: 4,
			TaskSpec:  taskSpec,
		},
	}

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

	// Policies are used to define on what kind of virtual machines the tasks will run on.
	// Read more about local disks here: https://cloud.google.com/compute/docs/disks/persistent-disks
	allocationPolicy := &batchpb.AllocationPolicy{
		Instances: []*batchpb.AllocationPolicy_InstancePolicyOrTemplate{{
			PolicyTemplate: &batchpb.AllocationPolicy_InstancePolicyOrTemplate_Policy{
				Policy: &batchpb.AllocationPolicy_InstancePolicy{
					MachineType: "n1-standard-1",
					Disks: []*batchpb.AllocationPolicy_AttachedDisk{
						{
							Attached: &batchpb.AllocationPolicy_AttachedDisk_NewDisk{
								NewDisk: disk,
							},
							DeviceName: pdName,
						},
					},
				},
			},
		}},
	}

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

	job := &batchpb.Job{
		Name:             jobName,
		TaskGroups:       taskGroups,
		AllocationPolicy: allocationPolicy,
		Labels:           labels,
		LogsPolicy:       logsPolicy,
	}

	request := &batchpb.CreateJobRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s", projectID, "us-central1"),
		JobId:  jobName,
		Job:    job,
	}

	created_job, err := batchClient.CreateJob(ctx, request)
	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 criar uma tarefa em lote que use discos persistentes novos ou existentes através das bibliotecas de cliente do Google Cloud para Java, use a classeCreateJobRequest e inclua o seguinte:

Por exemplo, use o seguinte exemplo de código:


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.AttachedDisk;
import com.google.cloud.batch.v1.AllocationPolicy.Disk;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicyOrTemplate;
import com.google.cloud.batch.v1.AllocationPolicy.LocationPolicy;
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.cloud.batch.v1.Volume;
import com.google.common.collect.Lists;
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 CreatePersistentDiskJob {

  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";
    // The size of the new persistent disk in GB.
    // The allowed sizes depend on the type of persistent disk,
    // but the minimum is often 10 GB (10) and the maximum is often 64 TB (64000).
    int diskSize = 10;
    // The name of the new persistent disk.
    String newPersistentDiskName = "DISK-NAME";
    // The name of an existing persistent disk.
    String existingPersistentDiskName = "EXISTING-DISK-NAME";
    // The location of an existing persistent disk. For more info :
    // https://cloud.google.com/batch/docs/create-run-job-storage#gcloud
    String location = "regions/us-central1";
    // The disk type of the new persistent disk, either pd-standard,
    // pd-balanced, pd-ssd, or pd-extreme. For Batch jobs, the default is pd-balanced.
    String newDiskType = "pd-balanced";

    createPersistentDiskJob(projectId, region, jobName, newPersistentDiskName,
            diskSize, existingPersistentDiskName, location, newDiskType);
  }

  // Creates a job that attaches and mounts an existing persistent disk and a new persistent disk
  public static Job createPersistentDiskJob(String projectId, String region, String jobName,
                                            String newPersistentDiskName, int diskSize,
                                            String existingPersistentDiskName,
                                            String location, String newDiskType)
      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.
      String text = "echo Hello world from task ${BATCH_TASK_INDEX}. "
              + ">> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt";
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(text)
                      // 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.
              .addAllVolumes(volumes(newPersistentDiskName, existingPersistentDiskName))
              .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 the type of virtual machines the tasks will run on.
      InstancePolicy policy = InstancePolicy.newBuilder()
              .addAllDisks(attachedDisks(newPersistentDiskName, diskSize, newDiskType,
                  projectId, location, existingPersistentDiskName))
              .build();

      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setPolicy(policy))
                  .setLocation(LocationPolicy.newBuilder().addAllowedLocations(location))
              .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 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;
    }
  }

  // Creates link to existing disk and creates configuration for new disk
  private static Iterable<AttachedDisk> attachedDisks(String newPersistentDiskName, int diskSize,
                                                      String newDiskType, String projectId,
                                                      String existingPersistentDiskLocation,
                                                      String existingPersistentDiskName) {
    AttachedDisk newDisk = AttachedDisk.newBuilder()
            .setDeviceName(newPersistentDiskName)
            .setNewDisk(Disk.newBuilder().setSizeGb(diskSize).setType(newDiskType))
            .build();

    String diskPath = String.format("projects/%s/%s/disks/%s", projectId,
            existingPersistentDiskLocation, existingPersistentDiskName);

    AttachedDisk existingDisk = AttachedDisk.newBuilder()
            .setDeviceName(existingPersistentDiskName)
            .setExistingDisk(diskPath)
            .build();

    return Lists.newArrayList(existingDisk, newDisk);
  }

  // Describes a volume and parameters for it to be mounted to a VM.
  private static Iterable<Volume> volumes(String newPersistentDiskName,
                                          String existingPersistentDiskName) {
    Volume newVolume = Volume.newBuilder()
            .setDeviceName(newPersistentDiskName)
            .setMountPath("/mnt/disks/" + newPersistentDiskName)
            .addMountOptions("rw")
            .addMountOptions("async")
            .build();

    Volume existingVolume = Volume.newBuilder()
            .setDeviceName(existingPersistentDiskName)
            .setMountPath("/mnt/disks/" + existingPersistentDiskName)
            .build();

    return Lists.newArrayList(newVolume, existingVolume);
  }
}

Node.js

Para criar uma tarefa em lote que use discos persistentes novos ou existentes com as bibliotecas de cliente do Google Cloud para Node.js, use o método createJob e inclua o seguinte:

  • Para anexar discos persistentes às VMs de uma tarefa, inclua um dos seguintes:
  • Para montar os discos persistentes na tarefa, use a classe Volume com a propriedade deviceName e a propriedade mountPath. Para novos discos persistentes, também pode usar a propriedade mountOptions para ativar a escrita.
// 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();
// The name of the job that will be created.
// It needs to be unique for each project and region pair.
const jobName = 'batch-create-persistent-disk-job';
// 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 an existing persistent disk.
const existingPersistentDiskName = 'existing-persistent-disk-name';
// The name of the new persistent disk.
const newPersistentDiskName = 'new-persistent-disk-name';
// The size of the new persistent disk in GB.
// The allowed sizes depend on the type of persistent disk,
// but the minimum is often 10 GB (10) and the maximum is often 64 TB (64000).
const diskSize = 10;
// The location of an existing persistent disk. For more info :
// https://cloud.google.com/batch/docs/create-run-job-storage#gcloud
const location = 'regions/us-central1';
// The disk type of the new persistent disk, either pd-standard,
// pd-balanced, pd-ssd, or pd-extreme. For Batch jobs, the default is pd-balanced.
const newDiskType = 'pd-balanced';

// 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}.' +
        '>> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt',
    ],
  }),
});

// Define volumes and their parameters to be mounted to a VM.
const newVolume = new batch.Volume({
  deviceName: newPersistentDiskName,
  mountPath: `/mnt/disks/${newPersistentDiskName}`,
  mountOptions: ['rw', 'async'],
});

const existingVolume = new batch.Volume({
  deviceName: existingPersistentDiskName,
  mountPath: `/mnt/disks/${existingPersistentDiskName}`,
});

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

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

const newDisk = new batch.AllocationPolicy.Disk({
  type: newDiskType,
  sizeGb: diskSize,
});

// Policies are used to define on what kind of virtual machines the tasks will run on.
// Read more about local disks here: https://cloud.google.com/compute/docs/disks/persistent-disks
const instancePolicy = new batch.AllocationPolicy.InstancePolicy({
  disks: [
    // Create configuration for new disk
    new batch.AllocationPolicy.AttachedDisk({
      deviceName: newPersistentDiskName,
      newDisk,
    }),
    // Create link to existing disk
    new batch.AllocationPolicy.AttachedDisk({
      existingDisk: `projects/${projectId}/${location}/disks/${existingPersistentDiskName}`,
      deviceName: existingPersistentDiskName,
    }),
  ],
});

const locationPolicy = new batch.AllocationPolicy.LocationPolicy({
  allowedLocations: [location],
});

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

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 callCreateBatchPersistentDiskJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

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

await callCreateBatchPersistentDiskJob();

Python

Para criar uma tarefa em lote que use discos persistentes novos ou existentes com as bibliotecas cliente do Google Cloud para Python, use a função CreateJob e inclua o seguinte:

  • Para anexar discos persistentes às VMs de uma tarefa, inclua um dos seguintes:
    • Se não estiver a usar um modelo de instância de VM para esta tarefa, inclua a classe AttachedDisk.
    • Se estiver a usar um modelo de instância de VM para esta tarefa, inclua o atributo instance_template.
  • Para montar os discos persistentes na tarefa, use a classe Volume com o atributo device_name e o atributo mount_path. Para novos discos persistentes, use também o atributo mount_options para ativar a escrita.

Por exemplo, use o seguinte exemplo de código:

from google.cloud import batch_v1


def create_with_pd_job(
    project_id: str,
    region: str,
    job_name: str,
    disk_name: str,
    zone: str,
    existing_disk_name=None,
) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command on Cloud Compute instances with mounted persistent disk.

    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.
        disk_name: name of the disk to be mounted for your Job.
        existing_disk_name(optional): existing disk name, which you want to attach to a job

    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 from task ${BATCH_TASK_INDEX}. >> /mnt/disks/"
        + disk_name
        + "/output_task_${BATCH_TASK_INDEX}.txt"
    )
    task.runnables = [runnable]
    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    volume = batch_v1.Volume()
    volume.device_name = disk_name
    volume.mount_path = f"/mnt/disks/{disk_name}"
    task.volumes = [volume]

    if existing_disk_name:
        volume2 = batch_v1.Volume()
        volume2.device_name = existing_disk_name
        volume2.mount_path = f"/mnt/disks/{existing_disk_name}"
        task.volumes.append(volume2)

    # 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

    disk = batch_v1.AllocationPolicy.Disk()
    # The disk type of the new persistent disk, either pd-standard,
    # pd-balanced, pd-ssd, or pd-extreme. For Batch jobs, the default is pd-balanced
    disk.type_ = "pd-balanced"
    disk.size_gb = 10

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

    attached_disk = batch_v1.AllocationPolicy.AttachedDisk()
    attached_disk.new_disk = disk
    attached_disk.device_name = disk_name
    policy.disks = [attached_disk]

    if existing_disk_name:
        attached_disk2 = batch_v1.AllocationPolicy.AttachedDisk()
        attached_disk2.existing_disk = (
            f"projects/{project_id}/zones/{zone}/disks/{existing_disk_name}"
        )
        attached_disk2.device_name = existing_disk_name
        policy.disks.append(attached_disk2)

    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy

    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    location = batch_v1.AllocationPolicy.LocationPolicy()
    location.allowed_locations = [f"zones/{zone}"]
    allocation_policy.location = location

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "script"}

    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)

Use um SSD local

Uma tarefa que usa SSDs locais tem as seguintes restrições:

Pode criar uma tarefa que use um SSD local através da CLI gcloud, da API Batch, do Java ou do Python. O exemplo seguinte descreve como criar uma tarefa que cria, anexa e monta um SSD local. A tarefa também tem 3 tarefas que executam um script para criar um ficheiro no SSD local com o nome output_task_TASK_INDEX.txt, em que TASK_INDEX é o índice de cada tarefa: 0, 1 e 2.

gcloud

Para criar uma tarefa que use SSDs locais através da CLI gcloud, use o comando gcloud batch jobs submit. No ficheiro de configuração JSON da tarefa, crie e anexe os SSDs locais no campo instances e monte os SSDs locais no campo volumes.

  1. Crie um ficheiro JSON.

    • Se não estiver a usar um modelo de instância para esta tarefa, crie um ficheiro JSON com o seguinte conteúdo:

      {
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "machineType": MACHINE_TYPE,
                    "disks": [
                        {
                            "newDisk": {
                                "sizeGb": LOCAL_SSD_SIZE,
                                "type": "local-ssd"
                            },
                            "deviceName": "LOCAL_SSD_NAME"
                        }
                    ]
                }
            }
        ]
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/LOCAL_SSD_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "LOCAL_SSD_NAME",
                        "mountPath": "/mnt/disks/LOCAL_SSD_NAME",
                        "mountOptions": "rw,async"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

      Substitua o seguinte:

      • MACHINE_TYPE: o tipo de máquina, que pode ser predefinido ou personalizado, das VMs da tarefa. O número permitido de SSDs locais depende do tipo de máquina das VMs da tarefa.
      • LOCAL_SSD_NAME: o nome de um SSD local criado para esta tarefa.
      • LOCAL_SSD_SIZE: o tamanho de todos os SSDs locais em GB. Cada SSD local tem 375 GB, pelo que este valor tem de ser um múltiplo de 375 GB. Por exemplo, para 2 SSDs locais, defina este valor como 750 GB.

    • Se estiver a usar um modelo de instância de VM para esta tarefa, crie um ficheiro JSON, conforme mostrado anteriormente, exceto que deve substituir o instances campo pelo seguinte:

      "instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],

      onde INSTANCE_TEMPLATE_NAME é o nome do modelo de instância para esta tarefa. Para uma tarefa que usa SSDs locais, este modelo de instância tem de definir e anexar os SSDs locais que quer que a tarefa use. Para este exemplo, o modelo tem de definir e anexar um SSD local denominado LOCAL_SSD_NAME.

  2. Execute o seguinte comando:

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

    Substitua o seguinte:

    • JOB_NAME: o nome da tarefa.
    • LOCATION: a localização do trabalho.
    • JSON_CONFIGURATION_FILE: o caminho para um ficheiro JSON com os detalhes de configuração da tarefa.

API

Para criar uma tarefa que use SSDs locais através da API Batch, use o método jobs.create. Na solicitação, crie e anexe os SSDs locais no campo instances e monte os SSDs locais no campo volumes.

  • Se não estiver a usar um modelo de instância para esta tarefa, faça o seguinte pedido:

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

{
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "machineType": MACHINE_TYPE,
                    "disks": [
                        {
                            "newDisk": {
                                "sizeGb": LOCAL_SSD_SIZE,
                                "type": "local-ssd"
                            },
                            "deviceName": "LOCAL_SSD_NAME"
                        }
                    ]
                }
            }
        ]
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/LOCAL_SSD_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "LOCAL_SSD_NAME",
                        "mountPath": "/mnt/disks/LOCAL_SSD_NAME",
                        "mountOptions": "rw,async"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Substitua o seguinte:

    • PROJECT_ID: o ID do projeto do seu projeto.
    • LOCATION: a localização do trabalho.
    • JOB_NAME: o nome da tarefa.
    • MACHINE_TYPE: o tipo de máquina, que pode ser predefinido ou personalizado, das VMs da tarefa. O número permitido de SSDs locais depende do tipo de máquina das VMs da tarefa.
    • LOCAL_SSD_NAME: o nome de um SSD local criado para esta tarefa.
    • LOCAL_SSD_SIZE: o tamanho de todos os SSDs locais em GB. Cada SSD local tem 375 GB, pelo que este valor tem de ser um múltiplo de 375 GB. Por exemplo, para 2 SSDs locais, defina este valor como 750 GB.

  • Se estiver a usar um modelo de instância de VM para esta tarefa, crie um ficheiro JSON, conforme mostrado anteriormente, exceto que deve substituir o instances campo pelo seguinte:

    "instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],
...

    Onde INSTANCE_TEMPLATE_NAME é o nome do modelo de instância para esta tarefa. Para uma tarefa que usa SSDs locais, este modelo de instância tem de definir e anexar os SSDs locais que quer que a tarefa use. Para este exemplo, o modelo tem de definir e anexar um SSD local denominado LOCAL_SSD_NAME.

Ir 

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 with local SSD
// Note: local SSD does not guarantee Local SSD data persistence.
// More details here: https://cloud.google.com/compute/docs/disks/local-ssd#data_persistence
func createJobWithSSD(w io.Writer, projectID, jobName, ssdName string) error {
	// jobName := job-name
	// ssdName := disk-name
	ctx := context.Background()
	batchClient, err := batch.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("batchClient error: %w", err)
	}
	defer batchClient.Close()

	runn := &batchpb.Runnable{
		Executable: &batchpb.Runnable_Script_{
			Script: &batchpb.Runnable_Script{
				Command: &batchpb.Runnable_Script_Text{
					Text: "echo Hello world from script 1 for task ${BATCH_TASK_INDEX}",
				},
			},
		},
	}
	volume := &batchpb.Volume{
		MountPath: fmt.Sprintf("/mnt/disks/%v", ssdName),
		Source: &batchpb.Volume_DeviceName{
			DeviceName: ssdName,
		},
	}

	// The size of all the local SSDs in GB. Each local SSD is 375 GB,
	// so this value must be a multiple of 375 GB.
	// For example, for 2 local SSDs, set this value to 750 GB.
	disk := &batchpb.AllocationPolicy_Disk{
		Type:   "local-ssd",
		SizeGb: 375,
	}

	taskSpec := &batchpb.TaskSpec{
		ComputeResource: &batchpb.ComputeResource{
			// CpuMilli is milliseconds per cpu-second. This means the task requires 1 CPU.
			CpuMilli:  1000,
			MemoryMib: 16,
		},
		MaxRunDuration: &durationpb.Duration{
			Seconds: 3600,
		},
		MaxRetryCount: 2,
		Runnables:     []*batchpb.Runnable{runn},
		Volumes:       []*batchpb.Volume{volume},
	}

	taskGroups := []*batchpb.TaskGroup{
		{
			TaskCount: 4,
			TaskSpec:  taskSpec,
		},
	}

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

	allocationPolicy := &batchpb.AllocationPolicy{
		Instances: []*batchpb.AllocationPolicy_InstancePolicyOrTemplate{{
			PolicyTemplate: &batchpb.AllocationPolicy_InstancePolicyOrTemplate_Policy{
				Policy: &batchpb.AllocationPolicy_InstancePolicy{
					// The allowed number of local SSDs depends on the machine type for your job's VMs.
					// In this case, we tell the system to use "n1-standard-1" machine type, which require to attach local ssd manually.
					// Read more about local disks here: https://cloud.google.com/compute/docs/disks/local-ssd#lssd_disk_options
					MachineType: "n1-standard-1",
					Disks: []*batchpb.AllocationPolicy_AttachedDisk{
						{
							Attached: &batchpb.AllocationPolicy_AttachedDisk_NewDisk{
								NewDisk: disk,
							},
							DeviceName: ssdName,
						},
					},
				},
			},
		}},
	}

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

	job := &batchpb.Job{
		Name:             jobName,
		TaskGroups:       taskGroups,
		AllocationPolicy: allocationPolicy,
		Labels:           labels,
		LogsPolicy:       logsPolicy,
	}

	request := &batchpb.CreateJobRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s", projectID, "us-central1"),
		JobId:  jobName,
		Job:    job,
	}

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

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

Java 


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.AttachedDisk;
import com.google.cloud.batch.v1.AllocationPolicy.Disk;
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.cloud.batch.v1.Volume;
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 CreateLocalSsdJob {

  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";
    // The name of a local SSD created for this job.
    String localSsdName = "SSD-NAME";
    // The machine type, which can be predefined or custom, of the job's VMs.
    // The allowed number of local SSDs depends on the machine type
    // for your job's VMs are listed on: https://cloud.google.com/compute/docs/disks#localssds
    String machineType = "c3d-standard-8-lssd";
    // The size of all the local SSDs in GB. Each local SSD is 375 GB,
    // so this value must be a multiple of 375 GB.
    // For example, for 2 local SSDs, set this value to 750 GB.
    int ssdSize = 375;

    createLocalSsdJob(projectId, region, jobName, localSsdName, ssdSize, machineType);
  }

  // Create a job that uses local SSDs
  public static Job createLocalSsdJob(String projectId, String region, String jobName,
                                      String localSsdName, int ssdSize, 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();

      Volume volume = Volume.newBuilder()
          .setDeviceName(localSsdName)
          .setMountPath("/mnt/disks/" + localSsdName)
          .addMountOptions("rw")
          .addMountOptions("async")
          .build();

      TaskSpec task = TaskSpec.newBuilder()
          // Jobs can be divided into tasks. In this case, we have only one task.
          .addVolumes(volume)
          .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 on.
      InstancePolicy policy = InstancePolicy.newBuilder()
          .setMachineType(machineType)
          .addDisks(AttachedDisk.newBuilder()
              .setDeviceName(localSsdName)
              // For example, local SSD uses type "local-ssd".
              // Persistent disks and boot disks use "pd-balanced", "pd-extreme", "pd-ssd"
              // or "pd-standard".
              .setNewDisk(Disk.newBuilder().setSizeGb(ssdSize).setType("local-ssd")))
          .build();

      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setPolicy(policy)
                      .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-local-ssd-job';
// The name of a local SSD created for this job.
const localSsdName = 'ssd-name';
// The machine type, which can be predefined or custom, of the job's VMs.
// The allowed number of local SSDs depends on the machine type
// for your job's VMs are listed on: https://cloud.google.com/compute/docs/disks#localssds
const machineType = 'c3d-standard-8-lssd';
// The size of all the local SSDs in GB. Each local SSD is 375 GB,
// so this value must be a multiple of 375 GB.
// For example, for 2 local SSDs, set this value to 750 GB.
const ssdSize = 375;

// 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}. This job has a total of ${BATCH_TASK_COUNT} tasks.',
    ],
  }),
});

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.
const instancePolicy = new batch.AllocationPolicy.InstancePolicy({
  machineType,
  disks: [
    new batch.AllocationPolicy.AttachedDisk({
      deviceName: localSsdName,
      // For example, local SSD uses type "local-ssd".
      // Persistent disks and boot disks use "pd-balanced", "pd-extreme", "pd-ssd"
      // or "pd-standard".
      newDisk: new batch.AllocationPolicy.AttachedDisk({
        type: 'local-ssd',
        sizeGb: ssdSize,
      }),
    }),
  ],
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{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_local_ssd_job(
    project_id: str, region: str, job_name: str, ssd_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 with mounted local SSD.
    Note: local SSD does not guarantee Local SSD data persistence.
    More details here: https://cloud.google.com/compute/docs/disks/local-ssd#data_persistence

    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.
        ssd_name: name of the local ssd to be mounted for your Job.

    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."
    task.runnables = [runnable]
    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    volume = batch_v1.Volume()
    volume.device_name = ssd_name
    volume.mount_path = f"/mnt/disks/{ssd_name}"
    task.volumes = [volume]

    # 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

    disk = batch_v1.AllocationPolicy.Disk()
    disk.type_ = "local-ssd"
    # The size of all the local SSDs in GB. Each local SSD is 375 GB,
    # so this value must be a multiple of 375 GB.
    # For example, for 2 local SSDs, set this value to 750 GB.
    disk.size_gb = 375
    assert disk.size_gb % 375 == 0

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # The allowed number of local SSDs depends on the machine type for your job's VMs.
    # In this case, we tell the system to use "n1-standard-1" machine type, which require to attach local ssd manually.
    # Read more about local disks here: https://cloud.google.com/compute/docs/disks/local-ssd#lssd_disk_options
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "n1-standard-1"

    attached_disk = batch_v1.AllocationPolicy.AttachedDisk()
    attached_disk.new_disk = disk
    attached_disk.device_name = ssd_name
    policy.disks = [attached_disk]

    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": "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)

Use um contentor do Cloud Storage

Para criar uma tarefa que use um contentor do Cloud Storage existente, selecione um dos seguintes métodos:

  • Recomendado: monte um contentor diretamente nas VMs da tarefa especificando o contentor na definição da tarefa, conforme mostrado nesta secção. Quando a tarefa é executada, o contentor é montado automaticamente nas VMs da sua tarefa através do Cloud Storage FUSE.
  • Crie uma tarefa com tarefas que acedam diretamente a um contentor do Cloud Storage através da CLI gcloud ou das bibliotecas cliente para a API Cloud Storage. Para saber como aceder a um contentor do Cloud Storage diretamente a partir de uma VM, consulte a documentação do Compute Engine para escrever e ler dados de contentores do Cloud Storage.

Antes de criar uma tarefa que use um contentor, crie um contentor ou identifique um contentor existente. Para mais informações, consulte os artigos Crie contentores e Liste contentores.

Pode criar uma tarefa que use um contentor do Cloud Storage através da Google Cloud consola, da CLI gcloud, da API Batch, do C++, do Go, do Java, do Node.js ou do Python.

O exemplo seguinte descreve como criar uma tarefa que monta um contentor do Cloud Storage. A tarefa também tem 3 tarefas que executam cada uma um script para criar um ficheiro no contentor com o nome output_task_TASK_INDEX.txt onde TASK_INDEX é o índice de cada tarefa: 0, 1 e 2.

Consola

Para criar uma tarefa que use um contentor do Cloud Storage através da Google Cloud consola, faça o seguinte:

  1. Na Google Cloud consola, aceda à página Lista de tarefas.

    Aceda à lista de trabalhos

  2. Clique em Criar. É apresentada a página Criar tarefa em lote. No painel do lado esquerdo, a página Detalhes da tarefa está selecionada.

  3. Configure a página Detalhes da tarefa:

    1. Opcional: no campo Nome da tarefa, personalize o nome da tarefa.

      Por exemplo, introduza example-bucket-job.

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

      1. Na janela Novo executável, adicione, pelo menos, um script ou um contentor para que esta tarefa seja executada.

        Por exemplo, faça o seguinte:

        1. Selecione a caixa de verificação Script. É apresentada uma caixa de texto.

        2. Na caixa de texto, introduza o seguinte script:

          echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt

          Substitua MOUNT_PATH pelo caminho de montagem que os executáveis desta tarefa usam para aceder a um contentor do Cloud Storage existente. O caminho tem de começar com /mnt/disks/ seguido de um diretório ou um caminho à sua escolha. Por exemplo, se quiser representar este contentor com um diretório denominado my-bucket, defina o caminho de montagem como /mnt/disks/my-bucket.

        3. Clique em Concluído.

      2. No campo Número de tarefas, introduza o número de tarefas para este trabalho.

        Por exemplo, introduza 3.

      3. No campo Paralelismo, introduza o número de tarefas a executar em simultâneo.

        Por exemplo, introduza 1 (predefinição).

  4. Configure a página Configurações adicionais:

    1. No painel esquerdo, clique em Configurações adicionais. É apresentada a página Configurações adicionais.

    2. Para cada contentor do Cloud Storage que quer montar neste trabalho, faça o seguinte:

      1. Na secção Volume de armazenamento, clique em Adicionar novo volume. É apresentada a janela Novo volume.

      2. Na janela Novo volume, faça o seguinte:

        1. Na secção Tipo de volume, selecione Recipiente do Cloud Storage.

        2. No campo Nome do contentor de armazenamento, introduza o nome de um contentor existente.

          Por exemplo, introduza o contentor que especificou no ficheiro executável desta tarefa.

        3. No campo Caminho de montagem, introduza o caminho de montagem do contentor (MOUNT_PATH), que especificou no ficheiro executável.

        4. Clique em Concluído.

  5. Opcional: configure os outros campos desta tarefa.

  6. Opcional: para rever a configuração da tarefa, no painel esquerdo, clique em Pré-visualizar.

  7. Clique em Criar.

A página Detalhes do trabalho apresenta o trabalho que criou.

gcloud

Para criar uma tarefa que use um contentor do Cloud Storage através da CLI gcloud, use o comando gcloud batch jobs submit. No ficheiro de configuração JSON da tarefa, monte o contentor no campo volumes.

Por exemplo, para criar uma tarefa que produz ficheiros para um Cloud Storage:

  1. Crie um ficheiro JSON com o seguinte conteúdo:

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "gcs": {
                            "remotePath": "BUCKET_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Substitua o seguinte:

    • BUCKET_PATH: o caminho do diretório do contentor que quer que esta tarefa aceda, que tem de começar com o nome do contentor. Por exemplo, para um contentor denominado BUCKET_NAME, o caminho BUCKET_NAME representa o diretório raiz do contentor e o caminho BUCKET_NAME/subdirectory representa o subdiretório subdirectory.
    • MOUNT_PATH: o caminho de montagem que os executáveis da tarefa usam para aceder a este contentor. O caminho tem de começar com /mnt/disks/ seguido de um diretório ou um caminho à sua escolha. Por exemplo, se quiser representar este contentor com um diretório denominado my-bucket, defina o caminho de montagem como /mnt/disks/my-bucket.

  2. Execute o seguinte comando:

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

    Substitua o seguinte:

    • JOB_NAME: o nome da tarefa.
    • LOCATION: a localização do trabalho.
    • JSON_CONFIGURATION_FILE: o caminho para um ficheiro JSON com os detalhes de configuração da tarefa.

API

Para criar uma tarefa que use um contentor do Cloud Storage através da API Batch, use o método jobs.create e monte o contentor no campo volumes.

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}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "gcs": {
                            "remotePath": "BUCKET_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
            "destination": "CLOUD_LOGGING"
    }
}

Substitua o seguinte:

  • PROJECT_ID: o ID do projeto do seu projeto.
  • LOCATION: a localização do trabalho.
  • JOB_NAME: o nome da tarefa.
  • BUCKET_PATH: o caminho do diretório do contentor que quer que esta tarefa aceda, que tem de começar com o nome do contentor. Por exemplo, para um contentor denominado BUCKET_NAME, o caminho BUCKET_NAME representa o diretório raiz do contentor e o caminho BUCKET_NAME/subdirectory representa o subdiretório subdirectory.
  • MOUNT_PATH: o caminho de montagem que os executáveis da tarefa usam para aceder a este contentor. O caminho tem de começar com /mnt/disks/ seguido de um diretório ou um caminho à sua escolha. Por exemplo, se quiser representar este contentor com um diretório denominado my-bucket, defina o caminho de montagem como /mnt/disks/my-bucket.

C++

C++

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

Para se autenticar no Batch, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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, std::string const& bucket_name) {
    // 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, and then override the GCS remote path.
    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 from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt"
            }
          }
          volumes { mount_path: "/mnt/share" }
        }
      }
      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");
    }
    job->mutable_task_groups(0)
        ->mutable_task_spec()
        ->mutable_volumes(0)
        ->mutable_gcs()
        ->set_remote_path(bucket_name);
    // 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";
  }

Ir

Go

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

Para se autenticar no Batch, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 createScriptJobWithBucket(w io.Writer, projectID, region, jobName, bucketName string) error {
	// projectID := "your_project_id"
	// region := "us-central1"
	// jobName := "some-job"
	// jobName := "some-bucket"

	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 from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt",
	}

	// Specify the Google Cloud Storage bucket to mount
	volume := &batchpb.Volume{
		Source: &batchpb.Volume_Gcs{
			Gcs: &batchpb.GCS{
				RemotePath: bucketName,
			},
		},
		MountPath:    "/mnt/share",
		MountOptions: []string{},
	}

	// We can specify what resources are requested by each task.
	resources := &batchpb.ComputeResource{
		// CpuMilli is milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
		CpuMilli:  500,
		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,
		Volumes:       []*batchpb.Volume{volume},
	}

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

Java

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

Para se autenticar no Batch, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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.GCS;
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.cloud.batch.v1.Volume;
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 CreateWithMountedBucket {

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

    // Name of the bucket to be mounted for your Job.
    String bucketName = "BUCKET_NAME";

    createScriptJobWithBucket(projectId, region, jobName, bucketName);
  }

  // This method shows how to create a sample Batch Job that will run
  // a simple command on Cloud Compute instances.
  public static void createScriptJobWithBucket(String projectId, String region, String jobName,
      String bucketName)
      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 from task ${BATCH_TASK_INDEX}. >> "
                              + "/mnt/share/output_task_${BATCH_TASK_INDEX}.txt")
                      // 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();

      Volume volume = Volume.newBuilder()
          .setGcs(GCS.newBuilder()
              .setRemotePath(bucketName)
              .build())
          .setMountPath("/mnt/share")
          .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 50% of a single CPUs.
              .setCpuMilli(500)
              // 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)
              .addVolumes(volume)
              .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")
              .putLabels("mount", "bucket")
              // 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

Node.js

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

Para se autenticar no Batch, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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';
/**
 * The name of the bucket to be mounted.
 */
// const bucketName = 'YOUR_BUCKET_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 from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt';
// 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];

const gcsBucket = new batch.GCS();
gcsBucket.remotePath = bucketName;
const gcsVolume = new batch.Volume();
gcsVolume.gcs = gcsBucket;
gcsVolume.mountPath = '/mnt/share';
task.volumes = [gcsVolume];

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

Python

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

Para se autenticar no Batch, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local. 

from google.cloud import batch_v1


def create_script_job_with_bucket(
    project_id: str, region: str, job_name: str, bucket_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.
        bucket_name: name of the bucket to be mounted for your Job.

    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 from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt"
    task.runnables = [runnable]

    gcs_bucket = batch_v1.GCS()
    gcs_bucket.remote_path = bucket_name
    gcs_volume = batch_v1.Volume()
    gcs_volume.gcs = gcs_bucket
    gcs_volume.mount_path = "/mnt/share"
    task.volumes = [gcs_volume]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 500  # in milliseconds per cpu-second. This means the task requires 50% of a single 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", "mount": "bucket"}
    # 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)

Use um sistema de ficheiros de rede

Pode criar uma tarefa que use um sistema de ficheiros de rede (NFS) existente, como uma partilha de ficheiros do Filestore, usando a Google Cloud consola, a CLI gcloud ou a API Batch.

Antes de criar uma tarefa que use um NFS, certifique-se de que a firewall da sua rede está configurada corretamente para permitir o tráfego entre as VMs da sua tarefa e o NFS. Para mais informações, consulte o artigo Configurar regras de firewall para o Filestore.

O exemplo seguinte descreve como criar uma tarefa que especifica e monta um NFS. A tarefa também tem 3 tarefas que executam um script para criar um ficheiro no NFS denominado output_task_TASK_INDEX.txt onde TASK_INDEX é o índice de cada tarefa: 0, 1 e 2.

Consola

Para criar uma tarefa que use um NFS através da Google Cloud consola, faça o seguinte:

  1. Na Google Cloud consola, aceda à página Lista de tarefas.

    Aceda à lista de trabalhos

  2. Clique em Criar. É apresentada a página Criar tarefa em lote. No painel do lado esquerdo, a página Detalhes da tarefa está selecionada.

  3. Configure a página Detalhes da tarefa:

    1. Opcional: no campo Nome da tarefa, personalize o nome da tarefa.

      Por exemplo, introduza example-nfs-job.

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

      1. Na janela Novo executável, adicione, pelo menos, um script ou um contentor para que esta tarefa seja executada.

        Por exemplo, faça o seguinte:

        1. Selecione a caixa de verificação Script. É apresentada uma caixa de texto.

        2. Na caixa de texto, introduza o seguinte script:

          echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt

          Substitua MOUNT_PATH pelo caminho de montagem que o executável da tarefa usa para aceder a este NFS. O caminho tem de começar com /mnt/disks/ seguido de um diretório ou um caminho à sua escolha. Por exemplo, se quiser representar este NFS com um diretório denominado my-nfs, defina o caminho de montagem como /mnt/disks/my-nfs.

        3. Clique em Concluído.

      2. No campo Número de tarefas, introduza o número de tarefas para este trabalho.

        Por exemplo, introduza 3.

      3. No campo Paralelismo, introduza o número de tarefas a executar em simultâneo.

        Por exemplo, introduza 1 (predefinição).

  4. Configure a página Configurações adicionais:

    1. No painel esquerdo, clique em Configurações adicionais. É apresentada a página Configurações adicionais.

    2. Para cada contentor do Cloud Storage que quer montar neste trabalho, faça o seguinte:

      1. Na secção Volume de armazenamento, clique em Adicionar novo volume. É apresentada a janela Novo volume.

      2. Na janela Novo volume, faça o seguinte:

        1. Na secção Tipo de volume, selecione Sistema de ficheiros de rede.

        2. No campo Servidor de ficheiros, introduza o endereço IP do servidor onde se encontra o NFS especificado no executável desta tarefa.

          Por exemplo, se o seu NFS for uma partilha de ficheiros do Filestore, especifique o endereço IP da instância do Filestore, que pode obter ao descrever a instância do Filestore.

        3. No campo Caminho remoto, introduza um caminho que possa aceder ao NFS especificado no passo anterior.

          O caminho do diretório NFS tem de começar com / seguido do diretório raiz do NFS.

        4. No campo Caminho de montagem, introduza o caminho de montagem para o NFS (MOUNT_PATH), que especificou no passo anterior.

    3. Clique em Concluído.

  5. Opcional: configure os outros campos desta tarefa.

  6. Opcional: para rever a configuração da tarefa, no painel esquerdo, clique em Pré-visualizar.

  7. Clique em Criar.

A página Detalhes do trabalho apresenta o trabalho que criou.

gcloud

Para criar uma tarefa que use um NFS através da CLI gcloud, use o comando gcloud batch jobs submit. No ficheiro de configuração JSON da tarefa, monte o NFS no campo volumes.

  1. Crie um ficheiro JSON com o seguinte conteúdo:

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "nfs": {
                            "server": "NFS_IP_ADDRESS",
                            "remotePath": "NFS_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Substitua o seguinte:

    • NFS_IP_ADDRESS: o endereço IP do NFS. Por exemplo, se o seu NFS for uma partilha de ficheiros do Filestore, especifique o endereço IP da instância do Filestore, que pode obter descrevendo a instância do Filestore.
    • NFS_PATH: o caminho do diretório NFS ao qual quer que esta tarefa aceda, que tem de começar com / seguido do diretório raiz do NFS. Por exemplo, para uma partilha de ficheiros do Filestore denominada FILE_SHARE_NAME, o caminho /FILE_SHARE_NAME representa o diretório raiz da partilha de ficheiros e o caminho /FILE_SHARE_NAME/subdirectory representa o subdiretório subdirectory.
    • MOUNT_PATH: o caminho de montagem que os elementos executáveis da tarefa usam para aceder a este NFS. O caminho tem de começar com /mnt/disks/ seguido de um diretório ou um caminho à sua escolha. Por exemplo, se quiser representar este NFS com um diretório denominado my-nfs, defina o caminho de montagem como /mnt/disks/my-nfs.

  2. Execute o seguinte comando:

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

    Substitua o seguinte:

    • JOB_NAME: o nome da tarefa.
    • LOCATION: a localização do trabalho.
    • JSON_CONFIGURATION_FILE: o caminho para um ficheiro JSON com os detalhes de configuração da tarefa.

API

Para criar uma tarefa que use um NFS através da API Batch, use o método jobs.create e monte o NFS no campo volumes.

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}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "nfs": {
                            "server": "NFS_IP_ADDRESS",
                            "remotePath": "NFS_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Substitua o seguinte:

  • PROJECT_ID: o ID do projeto do seu projeto.
  • LOCATION: a localização do trabalho.
  • JOB_NAME: o nome da tarefa.
  • NFS_IP_ADDRESS: o endereço IP do sistema de ficheiros de rede. Por exemplo, se o seu NFS for uma partilha de ficheiros do Filestore, especifique o endereço IP da instância do Filestore, que pode obter descrevendo a instância do Filestore.
  • NFS_PATH: o caminho do diretório NFS ao qual quer que esta tarefa aceda, que tem de começar com / seguido do diretório raiz do NFS. Por exemplo, para uma partilha de ficheiros do Filestore denominada FILE_SHARE_NAME, o caminho /FILE_SHARE_NAME representa o diretório raiz da partilha de ficheiros e o caminho /FILE_SHARE_NAME/subdirectory representa um subdiretório.
  • MOUNT_PATH: o caminho de montagem que os elementos executáveis da tarefa usam para aceder a este NFS. O caminho tem de começar com /mnt/disks/ seguido de um diretório ou um caminho à sua escolha. Por exemplo, se quiser representar este NFS com um diretório denominado my-nfs, defina o caminho de montagem como /mnt/disks/my-nfs.

Java 


import com.google.cloud.batch.v1.AllocationPolicy;
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.NFS;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.TaskGroup;
import com.google.cloud.batch.v1.TaskSpec;
import com.google.cloud.batch.v1.Volume;
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 CreateScriptJobWithNfs {

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

    // The path of the NFS directory that you want this job to access.
    String nfsPath = "NFS_PATH";
    // The IP address of the Network File System.
    String nfsIpAddress = "NFS_IP_ADDRESS";

    createScriptJobWithNfs(projectId, region, jobName, nfsPath, nfsIpAddress);
  }

  // This method shows how to create a batch script job that specifies and mounts a NFS.
  public static Job createScriptJobWithNfs(String projectId, String region, String jobName,
                                            String nfsPath, String nfsIpAddress)
      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(
                  Runnable.Script.newBuilder()
                      .setText(
                          "echo Hello world from task ${BATCH_TASK_INDEX}. >> "
                              + "/mnt/share/output_task_${BATCH_TASK_INDEX}.txt")
                      // 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();

      // Describes a volume and parameters for it to be mounted to a VM.
      Volume volume = Volume.newBuilder()
          .setNfs(NFS.newBuilder()
              .setServer(nfsIpAddress)
              .setRemotePath(nfsPath)
              .build())
          .setMountPath("/mnt/share")
          .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 50% of a single CPUs.
              .setCpuMilli(500)
              // 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)
              .addVolumes(volume)
              .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
      AllocationPolicy.InstancePolicy instancePolicy =
          AllocationPolicy.InstancePolicy.newBuilder().setMachineType("e2-standard-4").build();

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

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

      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-nfs-job';
// The path of the NFS directory that you want this job to access.
const nfsPath = '/your_nfs_path';
// The IP address of the Network File System.
const nfsIpAddress = '0.0.0.0';
// The mount path that the job's tasks use to access the NFS.
const mountPath = '/mnt/disks';

// 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 from task ${BATCH_TASK_INDEX}. >> ' +
        '/mnt/share/output_task_${BATCH_TASK_INDEX}.txt',
    ],
  }),
});

// Define a volume that uses NFS.
const volume = new batch.Volume({
  nfs: new batch.NFS({
    server: nfsIpAddress,
    remotePath: nfsPath,
  }),
  mountPath,
});

// Specify what resources are requested by each task.
const computeResource = new batch.ComputeResource({
  // In milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
  cpuMilli: 500,
  // In MiB.
  memoryMib: 16,
});

const task = new batch.TaskSpec({
  runnables: [runnable],
  volumes: [volume],
  computeResource,
  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 "e2-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: 'e2-standard-4',
});

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

const job = new batch.Job({
  name: jobName,
  taskGroups: [group],
  allocationPolicy,
  labels: {env: 'testing', type: 'script'},
  // 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 callCreateBatchNfsJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

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

await callCreateBatchNfsJob();

Python 

from google.cloud import batch_v1


def create_job_with_network_file_system(
    project_id: str,
    region: str,
    job_name: str,
    mount_path: str,
    nfs_ip_address: str,
    nfs_path: str,
) -> batch_v1.Job:
    """
    Creates a Batch job with status events that mounts a Network File System (NFS).
    Function mounts an NFS volume using the provided NFS server, IP address and path.

    Args:
        project_id (str): project ID or project number of the Cloud project you want to use.
        region (str): 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/locations
        job_name (str): the name of the job that will be created.
            It needs to be unique for each project and region pair.
        mount_path (str): The mount path that the job's tasks use to access the NFS.
        nfs_ip_address (str): The IP address of the NFS server (e.g., Filestore instance).
            Documentation on how to create a
            Filestore instance is available here: https://cloud.google.com/filestore/docs/create-instance-gcloud
        nfs_path (str): The path of the NFS directory that the job accesses.
            The path must start with a / followed by the root directory of the NFS.

    Returns:
        batch_v1.Job: The created Batch job object containing configuration details.
    """
    client = batch_v1.BatchServiceClient()

    # Create a runnable with a script that writes a message to a file
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = f"echo Hello world from task ${{BATCH_TASK_INDEX}}. >> {mount_path}/output_task_${{BATCH_TASK_INDEX}}.txt"

    # Define a volume that uses NFS
    volume = batch_v1.Volume()
    volume.nfs = batch_v1.NFS(server=nfs_ip_address, remote_path=nfs_path)
    volume.mount_path = mount_path

    # Create a task specification and assign the runnable and volume to it
    task = batch_v1.TaskSpec()
    task.runnables = [runnable]
    task.volumes = [volume]

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

    # Create a task group and assign the task specification to it
    group = batch_v1.TaskGroup()
    group.task_count = 1
    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]

    # Create the job and assign the task group and allocation policy to it
    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 the job request and set the job and job ID
    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)

O que se segue?