Crea ed esegui un job di base

Questo documento spiega le nozioni di base per la creazione di job batch: come creare ed eseguire un job basato su uno script o un'immagine container e utilizzare variabili predefinite e personalizzate. Per scoprire di più sulla creazione e l'esecuzione dei job, vedi Panoramica della creazione e dell'esecuzione dei job.

Prima di iniziare

  • Se non hai ancora utilizzato Batch, consulta la Guida introduttiva all'utilizzo di Batch e abilitalo compilando i prerequisiti per progetti e utenti.

  • Per ottenere le autorizzazioni necessarie per creare un job, chiedi all'amministratore di concederti i seguenti ruoli IAM:

    Per maggiori informazioni sulla concessione dei ruoli, vedi Gestire l'accesso.

    Potresti anche ottenere le autorizzazioni richieste tramite ruoli personalizzati o altri ruoli predefiniti.

  • Ogni volta che crei un job, assicurati che il job abbia una configurazione di rete valida.
    • Se non hai requisiti di networking specifici e non hai modificato la rete predefinita per il progetto, non devi fare nulla.
    • In caso contrario, se il tuo progetto o carico di lavoro richiede l'uso di una rete personalizzata, devi configurare il networking quando crei un job. Scopri come configurare il networking per un job prima di creare un job di base, quindi puoi modificare gli esempi di seguito per soddisfare i tuoi requisiti di networking.
    Per saperne di più sulla configurazione di rete predefinita per un job e su quando e come configurare il networking per un job, consulta la panoramica del networking batch.

Crea un job di base

Per informazioni su tutti i campi che puoi specificare per un job, consulta la documentazione di riferimento per la projects.locations.jobsrisorsa. Riassumendo, un job è costituito da un array di una o più attività che eseguono tutte una o più eseguibili, ossia gli script eseguibili e/o i container per il job. Questa sezione spiega come creare un job di esempio con una sola eseguibile, ovvero uno script o un'immagine container:

  • Se vuoi utilizzare Batch per scrivere job che eseguono un'immagine container, consulta la pagina Creare un job container.
  • In caso contrario, se non hai la certezza di voler utilizzare le immagini container o se non hai dimestichezza con i container, ti consigliamo di creare un job di script.

Il job di esempio per entrambi i tipi di job contiene un gruppo di attività con una matrice di 4 attività. Ogni attività stampa un messaggio e il suo indice nell'output standard e in Cloud Logging. La definizione di questo job specifica un parallelismo pari a 2, che indica che il job deve essere eseguito su due VM per consentire l'esecuzione di due attività alla volta.

Crea un job container di base

Puoi selezionare o creare un'immagine container per fornire il codice e le dipendenze per l'esecuzione del tuo job da qualsiasi ambiente di computing. Per ulteriori informazioni, consulta Utilizzo delle immagini container e Eseguire i container sulle istanze VM.

Puoi creare un job di container di base utilizzando la console Google Cloud, l'interfaccia a riga di comando gcloud, l'API Batch, Go, Java, Node.js o Python.

Console

Per creare un job container di base utilizzando la console Google Cloud, procedi nel seguente modo:

  1. Nella console Google Cloud, vai alla pagina Elenco job

    Vai all'elenco Job

  2. Fai clic su Crea. Si apre la pagina Crea job batch.

  3. Nel campo Nome job, inserisci un nome per il job.

    Ad esempio, inserisci example-basic-job.

  4. Nel campo Regione, seleziona la località per questo job.

    Ad esempio, seleziona us-central1 (Iowa) (valore predefinito).

  5. Nel campo Zona, esegui una delle seguenti operazioni:

    • Se vuoi limitare l'esecuzione del job solo in una zona specifica, seleziona una zona.

    • Altrimenti, seleziona any.

    Ad esempio, seleziona any (valore predefinito).

  6. Nella sezione Modello di provisioning delle VM, seleziona una delle seguenti opzioni per il modello di provisioning per le VM di questo job:

    • Se il tuo job può resistere alla prerilascio e vuoi VM scontate, seleziona Spot.

    • Altrimenti, seleziona Standard.

    Ad esempio, seleziona Standard (valore predefinito).

  7. Seleziona una delle seguenti famiglie di macchine:

    • Per i carichi di lavoro comuni, fai clic su Per uso generico.

    • Per carichi di lavoro che richiedono prestazioni elevate, fai clic su Ottimizzato per calcolo.

    • Per carichi di lavoro che richiedono molta memoria, fai clic su Ottimizzato per la memoria.

    Ad esempio, fai clic su Uso generico (impostazione predefinita).

  8. Nel campo Serie, seleziona una serie di macchine per le VM di questo job.

    Ad esempio, se hai selezionato Per uso generico per la famiglia di macchine, seleziona E2 (valore predefinito).

  9. Nel campo Tipo di macchina, seleziona un tipo di macchina per le VM di questo job.

    Ad esempio, se hai selezionato E2 per la serie della macchina, seleziona e2-medium (2 vCPU, 4 GB di memoria) (valore predefinito).

  10. Nel riquadro Nuovo eseguibile, procedi nel seguente modo:

    1. Seleziona URL immagine container (impostazione predefinita).

    2. Nel campo URL immagine container, inserisci l'URL di un'immagine container che vuoi eseguire per ogni attività in questo job.

      Ad esempio, per utilizzare l'immagine container di Docker di busybox, inserisci il seguente URL:

      gcr.io/google-containers/busybox

    3. (Facoltativo) Per eseguire l'override del comando ENTRYPOINT dell'immagine container, inserisci un comando nel campo Punto di ingresso.

      Ad esempio, inserisci quanto segue:

      /bin/sh

    4. (Facoltativo) Per eseguire l'override del comando CMD dell'immagine container, segui questi passaggi:

      1. Seleziona la casella di controllo Esegui l'override del comando CMD dell'immagine container. Viene visualizzata una casella di testo.

      2. Nella casella di testo, inserisci uno o più comandi, separando ogni comando con una nuova riga.

        Ad esempio, inserisci i seguenti comandi:

        -c
echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.

    5. Fai clic su Fine.

  11. Nel campo Conteggio attività, inserisci il numero di attività per questo job. Il valore deve essere un numero intero compreso tra 1 e 10000.

    Ad esempio, inserisci 4.

  12. Nel campo Parallelismo, inserisci il numero di attività da eseguire contemporaneamente. Il numero non può essere maggiore del numero totale di attività e deve essere un numero intero compreso tra 1 e 1000.

    Ad esempio, inserisci 2.

  13. Nella sezione Risorse per le attività, specifica la quantità di risorse VM necessarie per ogni attività, seguendo questi passaggi:

    1. Nel campo Core, inserisci la quantità di vCPU.

      Ad esempio, inserisci 1 (valore predefinito).

    2. Nel campo Memoria, inserisci la quantità di RAM (GB).

      Ad esempio, inserisci 0.5 (valore predefinito).

  14. Fai clic su Crea.

La pagina Elenco job mostra il job che hai creato.

gcloud

Per creare un job di container di base utilizzando gcloud CLI, procedi nel seguente modo:

  1. Crea un file JSON che specifichi i dettagli di configurazione del job. Ad esempio, per creare un job container di base, crea un file JSON con i seguenti contenuti. Per ulteriori informazioni su tutti i campi che puoi specificare per un job, consulta la documentazione di riferimento per la risorsa projects.locations.jobs.

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

    Sostituisci quanto segue:

    • CONTAINER: il contenitore eseguito da ogni attività.
    • CORES: facoltativo. La quantità di core, in particolare le vCPU, che di solito rappresentano la metà di un core fisico, da allocare per ogni attività in unità milliCPU. Se il campo cpuMilli non è specificato, il valore è impostato su 2000 (2 vCPU).
    • MEMORY: facoltativo. La quantità di memoria da allocare per ogni attività in MB. Se il campo memoryMib non è specificato, il valore è impostato su 2000 (2 GB).
    • MAX_RETRY_COUNT: facoltativo. Il numero massimo di nuovi tentativi per un'attività. Il valore deve essere un numero intero compreso tra 0 e 10. Se il campo maxRetryCount non è specificato, il valore viene impostato su 0, quindi non riprovare a eseguire l'attività.
    • MAX_RUN_DURATION: facoltativo. Il tempo massimo consentito per l'esecuzione di un'attività prima che venga eseguito un nuovo tentativo o un errore, formattato come valore in secondi seguito da s. Se il campo maxRunDuration non è specificato, il valore è impostato su 604800s (7 giorni), che è il valore massimo.
    • TASK_COUNT: facoltativo. Il numero di attività per il job. Il valore deve essere un numero intero compreso tra 1 e 10000. Se il campo taskCount non è specificato, il valore viene impostato su 1.
    • PARALLELISM: facoltativo. Il numero di attività eseguite simultaneamente dal job. Il numero non può essere maggiore del numero di attività e deve essere un numero intero compreso tra 1 e 1000. Se il campo parallelism non è specificato, il valore viene impostato su 1.

  2. Crea un job utilizzando il comando gcloud batch jobs submit.

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

    Sostituisci quanto segue:

    • JOB_NAME: il nome del job.
    • LOCATION: la località del job.
    • JSON_CONFIGURATION_FILE: il percorso di un file JSON con i dettagli di configurazione del job.

Ad esempio, per creare un job che esegua attività utilizzando l'immagine container Docker di busybox:

  1. Crea un file JSON nella directory corrente denominata hello-world-container.json con il seguente contenuto:

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

  2. Esegui questo comando:

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

API

Per creare un job container di base utilizzando l'API Batch, utilizza il metodo jobs.create. Per ulteriori informazioni su tutti i campi che puoi specificare per un job, consulta la documentazione di riferimento per la risorsa projects.locations.jobs.

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

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

Sostituisci quanto segue:

  • PROJECT_ID: l'ID progetto del progetto.
  • LOCATION: la località del job.
  • JOB_NAME: il nome del job.
  • CONTAINER: il contenitore eseguito da ogni attività.
  • CORES: facoltativo. La quantità di core, in particolare le vCPU, che di solito rappresentano la metà di un core fisico, da allocare per ogni attività in milliCPU. Se il campo cpuMilli non è specificato, il valore viene impostato su 2000 (2 vCPU).
  • MEMORY: facoltativo. La quantità di memoria da allocare per ogni attività in MB. Se il campo memoryMib non è specificato, il valore è impostato su 2000 (2 GB).
  • MAX_RETRY_COUNT: facoltativo. Il numero massimo di nuovi tentativi per un'attività. Il valore deve essere un numero intero compreso tra 0 e 10. Se il campo maxRetryCount non è specificato, il valore viene impostato su 0, il che significa che non riprova a eseguire l'attività.
  • MAX_RUN_DURATION: facoltativo. Il tempo massimo consentito per l'esecuzione di un'attività prima che venga eseguito un nuovo tentativo o un errore, formattato come valore in secondi seguito da s. Se il campo maxRunDuration non è specificato, il valore è impostato su 604800s (7 giorni), che è il valore massimo.
  • TASK_COUNT: facoltativo. Il numero di attività per il job, che deve essere un numero intero compreso tra 1 e 10000. Se il campo taskCount non è specificato, il valore viene impostato su 1.
  • PARALLELISM: facoltativo. Il numero di attività eseguite contemporaneamente dal job. Il numero non può essere maggiore del numero di attività e deve essere un numero intero compreso tra 1 e 1000. Se il campo parallelism non è specificato, il valore viene impostato su 1.

Ad esempio, per creare un job che esegua attività utilizzando l'immagine container Docker busybox, utilizza la seguente richiesta:

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

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

dove PROJECT_ID è l'ID progetto del tuo progetto.

Go

Go

Per scoprire di più, consulta la documentazione di riferimento per le API Go in batch.

Per eseguire l'autenticazione in batch, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

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

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

	// Policies are used to define on what kind of virtual machines the tasks will run on.
	// In this case, we tell the system to use "e2-standard-4" machine type.
	// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
	allocationPolicy := &batchpb.AllocationPolicy{
		Instances: []*batchpb.AllocationPolicy_InstancePolicyOrTemplate{{
			PolicyTemplate: &batchpb.AllocationPolicy_InstancePolicyOrTemplate_Policy{
				Policy: &batchpb.AllocationPolicy_InstancePolicy{
					MachineType: "e2-standard-4",
				},
			},
		}},
	}

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

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

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

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

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

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

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

	return nil
}

Java

Java

Per scoprire di più, consulta la documentazione di riferimento per le API Java in batch.

Per eseguire l'autenticazione in batch, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicyOrTemplate;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.ComputeResource;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.LogsPolicy.Destination;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.Runnable.Container;
import com.google.cloud.batch.v1.TaskGroup;
import com.google.cloud.batch.v1.TaskSpec;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateWithContainerNoMounting {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";

    // Name of the region you want to use to run the job. Regions that are
    // available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
    String region = "europe-central2";

    // The name of the job that will be created.
    // It needs to be unique for each project and region pair.
    String jobName = "JOB_NAME";

    createContainerJob(projectId, region, jobName);
  }

  // This method shows how to create a sample Batch Job that will run a simple command inside a
  // container on Cloud Compute instances.
  public static void createContainerJob(String projectId, String region, String jobName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `batchServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {

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

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

      TaskSpec task =
          TaskSpec.newBuilder()
              // Jobs can be divided into tasks. In this case, we have only one task.
              .addRunnables(runnable)
              .setComputeResource(computeResource)
              .setMaxRetryCount(2)
              .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
              .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder().setTaskCount(4).setTaskSpec(task).build();

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      // In this case, we tell the system to use "e2-standard-4" machine type.
      // Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
      InstancePolicy instancePolicy =
          InstancePolicy.newBuilder().setMachineType("e2-standard-4").build();

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

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

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run.
              .setParent(String.format("projects/%s/locations/%s", projectId, region))
              .setJob(job)
              .setJobId(jobName)
              .build();

      Job result =
          batchServiceClient
              .createJobCallable()
              .futureCall(createJobRequest)
              .get(5, TimeUnit.MINUTES);

      System.out.printf("Successfully created the job: %s", result.getName());
    }
  }
}

Node.js

Node.js

Per scoprire di più, consulta la documentazione di riferimento per le API Node.js in batch.

Per eseguire l'autenticazione in batch, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

// Imports the Batch library
const batchLib = require('@google-cloud/batch');
const batch = batchLib.protos.google.cloud.batch.v1;

// Instantiates a client
const batchClient = new batchLib.v1.BatchServiceClient();

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

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

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

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup();
group.taskCount = 4;
group.taskSpec = task;

// Policies are used to define on what kind of virtual machines the tasks will run on.
// In this case, we tell the system to use "e2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const allocationPolicy = new batch.AllocationPolicy();
const policy = new batch.AllocationPolicy.InstancePolicy();
policy.machineType = 'e2-standard-4';
const instances = new batch.AllocationPolicy.InstancePolicyOrTemplate();
instances.policy = policy;
allocationPolicy.instances = [instances];

const job = new batch.Job();
job.name = jobName;
job.taskGroups = [group];
job.allocationPolicy = allocationPolicy;
job.labels = {env: 'testing', type: 'container'};
// We use Cloud Logging as it's an option available out of the box
job.logsPolicy = new batch.LogsPolicy();
job.logsPolicy.destination = batch.LogsPolicy.Destination.CLOUD_LOGGING;

// The job's parent is the project and region in which the job will run
const parent = `projects/${projectId}/locations/${region}`;

async function callCreateJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

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

callCreateJob();

Python

Python

Per scoprire di più, consulta la documentazione di riferimento per le API Python in batch.

Per eseguire l'autenticazione in batch, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

from google.cloud import batch_v1

def create_container_job(project_id: str, region: str, job_name: str) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command inside a container on Cloud Compute instances.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use to run the job. Regions that are
            available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.

    Returns:
        A job object representing the job created.
    """
    client = batch_v1.BatchServiceClient()

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

    # Jobs can be divided into tasks. In this case, we have only one task.
    task = batch_v1.TaskSpec()
    task.runnables = [runnable]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 2000  # in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
    resources.memory_mib = 16  # in MiB
    task.compute_resource = resources

    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    # Tasks are grouped inside a job using TaskGroups.
    # Currently, it's possible to have only one task group.
    group = batch_v1.TaskGroup()
    group.task_count = 4
    group.task_spec = task

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # In this case, we tell the system to use "e2-standard-4" machine type.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "e2-standard-4"
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "container"}
    # We use Cloud Logging as it's an out of the box available option
    job.logs_policy = batch_v1.LogsPolicy()
    job.logs_policy.destination = batch_v1.LogsPolicy.Destination.CLOUD_LOGGING

    create_request = batch_v1.CreateJobRequest()
    create_request.job = job
    create_request.job_id = job_name
    # The job's parent is the region in which the job will run
    create_request.parent = f"projects/{project_id}/locations/{region}"

    return client.create_job(create_request)

Crea un job di script di base

Puoi creare un job di script di base utilizzando la console Google Cloud, l'interfaccia a riga di comando gcloud, l'API Batch, Go, Java, Node.js o Python.

Console

Per creare un job di script di base utilizzando la console Google Cloud, procedi nel seguente modo:

  1. Nella console Google Cloud, vai alla pagina Elenco job

    Vai all'elenco Job

  2. Fai clic su Crea. Si apre la pagina Crea job batch.

  3. Nel campo Nome job, inserisci un nome per il job.

    Ad esempio, inserisci example-basic-job.

  4. Nel campo Regione, seleziona la località per questo job.

    Ad esempio, seleziona us-central1 (Iowa) (valore predefinito).

  5. Nel campo Zona, esegui una delle seguenti operazioni:

    • Se vuoi limitare l'esecuzione del job solo in una zona specifica, seleziona una zona.

    • Altrimenti, seleziona any.

    Ad esempio, seleziona any (valore predefinito).

  6. Nella sezione Modello di provisioning delle VM, seleziona una delle seguenti opzioni per il modello di provisioning per le VM di questo job:

    • Se il tuo job può resistere alla prerilascio e vuoi VM scontate, seleziona Spot.

    • Altrimenti, seleziona Standard.

    Ad esempio, seleziona Standard (valore predefinito).

  7. Seleziona una delle seguenti famiglie di macchine:

    • Per i carichi di lavoro comuni, fai clic su Per uso generico.

    • Per carichi di lavoro che richiedono prestazioni elevate, fai clic su Ottimizzato per calcolo.

    • Per carichi di lavoro che richiedono molta memoria, fai clic su Ottimizzato per la memoria.

    Ad esempio, fai clic su Uso generico (impostazione predefinita).

  8. Nel campo Serie, seleziona una serie di macchine per le VM di questo job.

    Ad esempio, se hai selezionato Per uso generico per la famiglia di macchine, seleziona E2 (valore predefinito).

  9. Nel campo Tipo di macchina, seleziona un tipo di macchina per le VM di questo job.

    Ad esempio, se hai selezionato E2 per la serie della macchina, seleziona e2-medium (2 vCPU, 4 GB di memoria) (valore predefinito).

  10. Nel riquadro Nuovo eseguibile, procedi nel seguente modo:

    1. Seleziona Script. Viene visualizzata una casella di testo.

    2. Nella casella di testo, inserisci uno script da eseguire per ogni attività in questo job.

      Ad esempio, inserisci il seguente script:

      echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.

    3. Fai clic su Fine.

  11. Nel campo Conteggio attività, inserisci il numero di attività per questo job. Il valore deve essere un numero intero compreso tra 1 e 10000.

    Ad esempio, inserisci 4.

  12. Nel campo Parallelismo, inserisci il numero di attività da eseguire contemporaneamente. Il numero non può essere maggiore del numero totale di attività e deve essere un numero intero compreso tra 1 e 1000.

    Ad esempio, inserisci 2.

  13. Nella sezione Risorse per le attività, specifica la quantità di risorse VM necessarie per ogni attività, seguendo questi passaggi:

    1. Nel campo Core, inserisci la quantità di vCPU.

      Ad esempio, inserisci 1 (valore predefinito).

    2. Nel campo Memoria, inserisci la quantità di RAM (GB).

      Ad esempio, inserisci 0.5 (valore predefinito).

  14. Fai clic su Crea.

La pagina Elenco job mostra il job che hai creato.

gcloud

Per creare un job di script di base utilizzando gcloud CLI, procedi nel seguente modo:

  1. Crea un file JSON che specifichi i dettagli di configurazione del job. Ad esempio, per creare un job di script di base, crea un file JSON con i seguenti contenuti. Per ulteriori informazioni su tutti i campi che puoi specificare per un job, consulta la documentazione di riferimento per la risorsa projects.locations.jobs.

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

    Sostituisci quanto segue:

    • SCRIPT: lo script eseguito da ogni attività.
    • CORES: facoltativo. La quantità di core, in particolare le vCPU, che di solito rappresentano la metà di un core fisico, da allocare per ogni attività in unità milliCPU. Se il campo cpuMilli non è specificato, il valore è impostato su 2000 (2 vCPU).
    • MEMORY: facoltativo. La quantità di memoria da allocare per ogni attività in MB. Se il campo memoryMib non è specificato, il valore è impostato su 2000 (2 GB).
    • MAX_RETRY_COUNT: facoltativo. Il numero massimo di nuovi tentativi per un'attività. Il valore deve essere un numero intero compreso tra 0 e 10. Se il campo maxRetryCount non è specificato, il valore viene impostato su 0, quindi non riprovare a eseguire l'attività.
    • MAX_RUN_DURATION: facoltativo. Il tempo massimo consentito per l'esecuzione di un'attività prima che venga eseguito un nuovo tentativo o un errore, formattato come valore in secondi seguito da s. Se il campo maxRunDuration non è specificato, il valore è impostato su 604800s (7 giorni), che è il valore massimo.
    • TASK_COUNT: facoltativo. Il numero di attività per il job. Il valore deve essere un numero intero compreso tra 1 e 10000. Se il campo taskCount non è specificato, il valore viene impostato su 1.
    • PARALLELISM: facoltativo. Il numero di attività eseguite simultaneamente dal job. Il numero non può essere maggiore del numero di attività e deve essere un numero intero compreso tra 1 e 1000. Se il campo parallelism non è specificato, il valore viene impostato su 1.

  2. Crea un job utilizzando il comando gcloud batch jobs submit.

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

    Sostituisci quanto segue:

    • JOB_NAME: il nome del job.
    • LOCATION: la località del job.
    • JSON_CONFIGURATION_FILE: il percorso di un file JSON con i dettagli di configurazione del job.

Ad esempio, per creare un job che esegue attività utilizzando uno script:

  1. Crea un file JSON nella directory corrente denominata hello-world-script.json con il seguente contenuto:

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

  2. Esegui questo comando:

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

API

Per creare un job di script di base utilizzando l'API Batch, utilizza il metodo jobs.create. Per ulteriori informazioni su tutti i campi che puoi specificare per un job, consulta la documentazione di riferimento per la risorsa projects.locations.jobs.

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

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

Sostituisci quanto segue:

  • PROJECT_ID: l'ID progetto del progetto.
  • LOCATION: la località del job.
  • JOB_NAME: il nome del job.
  • SCRIPT: lo script eseguito da ogni attività.
  • CORES: facoltativo. La quantità di core, in particolare le vCPU, che di solito rappresentano la metà di un core fisico, da allocare per ogni attività in milliCPU. Se il campo cpuMilli non è specificato, il valore viene impostato su 2000 (2 vCPU).
  • MEMORY: facoltativo. La quantità di memoria da allocare per ogni attività in MB. Se il campo memoryMib non è specificato, il valore è impostato su 2000 (2 GB).
  • MAX_RETRY_COUNT: facoltativo. Il numero massimo di nuovi tentativi per un'attività. Il valore deve essere un numero intero compreso tra 0 e 10. Se il campo maxRetryCount non è specificato, il valore viene impostato su 0, il che significa che non riprova a eseguire l'attività.
  • MAX_RUN_DURATION: facoltativo. Il tempo massimo consentito per l'esecuzione di un'attività prima che venga eseguito un nuovo tentativo o un errore, formattato come valore in secondi seguito da s. Se il campo maxRunDuration non è specificato, il valore è impostato su 604800s (7 giorni), che è il valore massimo.
  • TASK_COUNT: facoltativo. Il numero di attività per il job. Il valore deve essere un numero intero compreso tra 1 e 10000. Se il campo taskCount non è specificato, il valore viene impostato su 1.
  • PARALLELISM: facoltativo. Il numero di attività eseguite contemporaneamente dal job. Il numero non può essere maggiore del numero di attività e deve essere un numero intero compreso tra 1 e 1000. Se il campo parallelism non è specificato, il valore viene impostato su 1.

Ad esempio, per creare un job che esegue attività utilizzando uno script, utilizza la seguente richiesta:

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

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

dove PROJECT_ID è l'ID progetto del tuo progetto.

Go

Go

Per scoprire di più, consulta la documentazione di riferimento per le API Go in batch.

Per eseguire l'autenticazione in batch, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

import (
	"context"
	"fmt"
	"io"

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

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

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

	// Define what will be done as part of the job.
	command := &batchpb.Runnable_Script_Text{
		Text: "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.",
	}
	// You can also run a script from a file. Just remember, that needs to be a script that's
	// already on the VM that will be running the job.
	// Using runnable.script.text and runnable.script.path is mutually exclusive.
	// command := &batchpb.Runnable_Script_Path{
	// 	Path: "/tmp/test.sh",
	// }

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

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

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

	// Policies are used to define on what kind of virtual machines the tasks will run on.
	// In this case, we tell the system to use "e2-standard-4" machine type.
	// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
	allocationPolicy := &batchpb.AllocationPolicy{
		Instances: []*batchpb.AllocationPolicy_InstancePolicyOrTemplate{{
			PolicyTemplate: &batchpb.AllocationPolicy_InstancePolicyOrTemplate_Policy{
				Policy: &batchpb.AllocationPolicy_InstancePolicy{
					MachineType: "e2-standard-4",
				},
			},
		}},
	}

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

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

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

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

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

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

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

	return nil
}

Java

Java

Per scoprire di più, consulta la documentazione di riferimento per le API Java in batch.

Per eseguire l'autenticazione in batch, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicyOrTemplate;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.ComputeResource;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.LogsPolicy.Destination;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.Runnable.Script;
import com.google.cloud.batch.v1.TaskGroup;
import com.google.cloud.batch.v1.TaskSpec;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateWithScriptNoMounting {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";

    // Name of the region you want to use to run the job. Regions that are
    // available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
    String region = "europe-central2";

    // The name of the job that will be created.
    // It needs to be unique for each project and region pair.
    String jobName = "JOB_NAME";

    createScriptJob(projectId, region, jobName);
  }

  // This method shows how to create a sample Batch Job that will run
  // a simple command on Cloud Compute instances.
  public static void createScriptJob(String projectId, String region, String jobName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `batchServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {

      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(
                          "echo Hello world! This is task ${BATCH_TASK_INDEX}. "
                              + "This job has a total of ${BATCH_TASK_COUNT} tasks.")
                      // You can also run a script from a file. Just remember, that needs to be a
                      // script that's already on the VM that will be running the job.
                      // Using setText() and setPath() is mutually exclusive.
                      // .setPath("/tmp/test.sh")
                      .build())
              .build();

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

      TaskSpec task =
          TaskSpec.newBuilder()
              // Jobs can be divided into tasks. In this case, we have only one task.
              .addRunnables(runnable)
              .setComputeResource(computeResource)
              .setMaxRetryCount(2)
              .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
              .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder().setTaskCount(4).setTaskSpec(task).build();

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      // In this case, we tell the system to use "e2-standard-4" machine type.
      // Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
      InstancePolicy instancePolicy =
          InstancePolicy.newBuilder().setMachineType("e2-standard-4").build();

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

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(Destination.CLOUD_LOGGING).build())
              .build();

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run.
              .setParent(String.format("projects/%s/locations/%s", projectId, region))
              .setJob(job)
              .setJobId(jobName)
              .build();

      Job result =
          batchServiceClient
              .createJobCallable()
              .futureCall(createJobRequest)
              .get(5, TimeUnit.MINUTES);

      System.out.printf("Successfully created the job: %s", result.getName());
    }
  }
}

Node.js

Node.js

Per scoprire di più, consulta la documentazione di riferimento per le API Node.js in batch.

Per eseguire l'autenticazione in batch, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

// Imports the Batch library
const batchLib = require('@google-cloud/batch');
const batch = batchLib.protos.google.cloud.batch.v1;

// Instantiates a client
const batchClient = new batchLib.v1.BatchServiceClient();

// Define what will be done as part of the job.
const task = new batch.TaskSpec();
const runnable = new batch.Runnable();
runnable.script = new batch.Runnable.Script();
runnable.script.text =
  'echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.';
// You can also run a script from a file. Just remember, that needs to be a script that's
// already on the VM that will be running the job. Using runnable.script.text and runnable.script.path is mutually
// exclusive.
// runnable.script.path = '/tmp/test.sh'
task.runnables = [runnable];

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

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

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup();
group.taskCount = 4;
group.taskSpec = task;

// Policies are used to define on what kind of virtual machines the tasks will run on.
// In this case, we tell the system to use "e2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const allocationPolicy = new batch.AllocationPolicy();
const policy = new batch.AllocationPolicy.InstancePolicy();
policy.machineType = 'e2-standard-4';
const instances = new batch.AllocationPolicy.InstancePolicyOrTemplate();
instances.policy = policy;
allocationPolicy.instances = [instances];

const job = new batch.Job();
job.name = jobName;
job.taskGroups = [group];
job.allocationPolicy = allocationPolicy;
job.labels = {env: 'testing', type: 'script'};
// We use Cloud Logging as it's an option available out of the box
job.logsPolicy = new batch.LogsPolicy();
job.logsPolicy.destination = batch.LogsPolicy.Destination.CLOUD_LOGGING;

// The job's parent is the project and region in which the job will run
const parent = `projects/${projectId}/locations/${region}`;

async function callCreateJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

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

callCreateJob();

Python

Python

Per scoprire di più, consulta la documentazione di riferimento per le API Python in batch.

Per eseguire l'autenticazione in batch, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

from google.cloud import batch_v1

def create_script_job(project_id: str, region: str, job_name: str) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command on Cloud Compute instances.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use to run the job. Regions that are
            available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.

    Returns:
        A job object representing the job created.
    """
    client = batch_v1.BatchServiceClient()

    # Define what will be done as part of the job.
    task = batch_v1.TaskSpec()
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
    # You can also run a script from a file. Just remember, that needs to be a script that's
    # already on the VM that will be running the job. Using runnable.script.text and runnable.script.path is mutually
    # exclusive.
    # runnable.script.path = '/tmp/test.sh'
    task.runnables = [runnable]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 2000  # in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
    resources.memory_mib = 16
    task.compute_resource = resources

    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    # Tasks are grouped inside a job using TaskGroups.
    # Currently, it's possible to have only one task group.
    group = batch_v1.TaskGroup()
    group.task_count = 4
    group.task_spec = task

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # In this case, we tell the system to use "e2-standard-4" machine type.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    allocation_policy = batch_v1.AllocationPolicy()
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "e2-standard-4"
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    allocation_policy.instances = [instances]

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "script"}
    # We use Cloud Logging as it's an out of the box available option
    job.logs_policy = batch_v1.LogsPolicy()
    job.logs_policy.destination = batch_v1.LogsPolicy.Destination.CLOUD_LOGGING

    create_request = batch_v1.CreateJobRequest()
    create_request.job = job
    create_request.job_id = job_name
    # The job's parent is the region in which the job will run
    create_request.parent = f"projects/{project_id}/locations/{region}"

    return client.create_job(create_request)

Utilizza le variabili di ambiente

Utilizza le variabili di ambiente quando scrivi un'immagine container o uno script che vuoi eseguire in un job. Puoi utilizzare una qualsiasi delle variabili di ambiente predefinite per tutti i job batch e qualsiasi variabile di ambiente personalizzata che definisci durante la creazione del job.

Utilizza variabili di ambiente predefinite

Per impostazione predefinita, i runnable nel tuo job possono utilizzare le seguenti variabili di ambiente predefinite:

  • BATCH_TASK_COUNT: numero di attività di un gruppo.
  • BATCH_TASK_INDEX: il numero di indice di un'attività in un gruppo di attività. La numerazione dell'indice inizia da 0.
  • BATCH_HOSTS_FILE: facoltativo. Il percorso del file che elenca tutte le istanze VM in esecuzione in un gruppo di attività. Per utilizzare questa variabile di ambiente, il campo requireHostsFile è obbligatorio e deve essere impostato su vero.

Per un esempio di come utilizzare le variabili di ambiente predefinite, vedi l'esempio eseguibile precedente in Creare un job di base in questo documento.

Definisci e utilizza le variabili di ambiente personalizzate

Facoltativamente, puoi definire i seguenti tipi di variabili di ambiente personalizzate per uno o più eseguibili in un job:

  • Una variabile per un eseguibile, che ha lo stesso valore per tutte le attività che possono essere eseguite.
  • Un array per un eseguibile, che ha un valore separato per ogni attività che viene eseguito.

Questa sezione fornisce esempi su come creare due job che definiscono e utilizzano variabili di ambiente personalizzate. Il primo job di esempio trasmette una variabile di ambiente a un eseguibile eseguito da ogni attività. Il secondo job di esempio trasmette un array di variabili di ambiente, con nomi corrispondenti ma valori diversi, alle attività in cui gli indici corrispondono agli indici della variabile di ambiente nell'array.

Questa sezione descrive come definire e utilizzare le variabili di ambiente personalizzate per il job utilizzando l'interfaccia a riga di comando gcloud o l'API batch.

gcloud

Se vuoi definire un job che trasmette una variabile di ambiente a un eseguibile che funzioni ogni attività, vedi l'esempio su come definire e utilizzare una variabile di ambiente per una eseguibile. In caso contrario, se vuoi definire un job che passi un elenco di variabili di ambiente a diverse attività in base all'indice delle attività, vedi l'esempio su come definire e utilizzare una variabile di ambiente per ogni attività.

Definisci e utilizza una variabile di ambiente per un eseguibile

Per creare un job che passi le variabili di ambiente a un eseguibile utilizzando l'interfaccia a riga di comando gcloud, utilizza il comando gcloud batch jobs submit e specifica le variabili di ambiente nel file di configurazione del job.

Ad esempio, per creare un job di script che definisca una variabile di ambiente e la invii agli script di tre attività, effettua la seguente richiesta:

  1. Crea un file JSON nella directory corrente denominata hello-world-environment-variables.json con il seguente contenuto:

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

    Sostituisci quanto segue:

    • VARIABLE_NAME: il nome della variabile di ambiente passato a ogni attività. Per convenzione, i nomi variabile di ambiente sono in maiuscolo.
    • VARIABLE_VALUE: facoltativo. Il valore della variabile di ambiente passato a ogni attività.

  2. Esegui questo comando:

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

Definisci e utilizza una variabile di ambiente per ogni attività

Per creare un job che passi le variabili di ambiente a un'attività in base all'indice delle attività utilizzando l'interfaccia alla gcloud CLI, utilizza il comando gcloud batch jobs submit e specifica il campo dell'array taskEnvironments nel file di configurazione del job.

Ad esempio, per creare un job che includa un array di 3 variabili di ambiente con nomi corrispondenti e valori diversi, e passi le variabili di ambiente agli script delle attività che gli indici corrispondono agli indici delle variabili di ambiente nell'array:

  1. Crea un file JSON nella directory corrente denominata hello-world-task-environment-variables.json con il seguente contenuto:

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

    Sostituisci quanto segue:

    • TASK_VARIABLE_NAME: il nome delle variabili di ambiente di attività passate alle attività con indici corrispondenti. Per convenzione, i nomi variabile di ambiente sono in maiuscolo.
    • TASK_VARIABLE_VALUE_0: il valore della variabile di ambiente passato all'attività che BATCH_TASK_INDEX è uguale a 0.
    • TASK_VARIABLE_VALUE_1: il valore della variabile di ambiente passato all'attività che BATCH_TASK_INDEX è uguale a 1.
    • TASK_VARIABLE_VALUE_2: il valore della variabile di ambiente passato all'attività che BATCH_TASK_INDEX è uguale a 2.

  2. Esegui questo comando:

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

API

Se vuoi definire un job che trasmette una variabile di ambiente a un eseguibile che funzioni ogni attività, vedi l'esempio su come definire e utilizzare una variabile di ambiente per una eseguibile. In caso contrario, se vuoi definire un job che passi un elenco di variabili di ambiente a diverse attività in base all'indice delle attività, vedi l'esempio su come definire e utilizzare una variabile di ambiente per ogni attività.

Definisci e utilizza una variabile di ambiente per un eseguibile

Per creare un job che passi le variabili di ambiente a un eseguibile utilizzando l'API Batch, utilizza il comando gcloud batch jobs submit e specifica le variabili di ambiente nel campo environment.

Ad esempio, per creare un job che includa una variabile di ambiente e la trasferisca agli script di tre attività, effettua la seguente richiesta:

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

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

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

Sostituisci quanto segue:

  • PROJECT_ID: l'ID progetto del progetto.
  • VARIABLE_NAME: il nome della variabile environment trasmesso a ogni attività. Per convenzione, i nomi variabile di ambiente sono in maiuscolo.
  • VARIABLE_VALUE: il valore della variabile di ambiente passato a ogni attività.

Definisci e utilizza una variabile di ambiente per ogni attività

Per creare un job che passi le variabili di ambiente a un'attività in base all'indice delle attività utilizzando l'API Batch, utilizza il metodo jobs.create e specifica le variabili di ambiente nel campo dell'array taskEnvironments.

Ad esempio, per creare un job che includa un array di 3 variabili di ambiente con nomi corrispondenti e valori diversi e che passi le variabili di ambiente agli script di 3 attività in base ai relativi indici, effettua la seguente richiesta:

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

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

Sostituisci quanto segue:

  • PROJECT_ID: l'ID progetto del progetto.
  • TASK_VARIABLE_NAME: il nome delle variabili di ambiente passate alle attività con indici corrispondenti. Per convenzione, i nomi variabile di ambiente sono in maiuscolo.
  • TASK_VARIABLE_VALUE_0: il valore della variabile di ambiente passato all'attività che BATCH_TASK_INDEX è uguale a 0.
  • TASK_VARIABLE_VALUE_1: il valore della variabile di ambiente passato all'attività che BATCH_TASK_INDEX è uguale a 1.
  • TASK_VARIABLE_VALUE_2: il valore della variabile di ambiente passato all'attività che BATCH_TASK_INDEX è uguale a 2.

Passaggi successivi