Crea y ejecuta un trabajo

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

En esta página, se describe cómo ejecutar una carga de trabajo de procesamiento por lotes en Google Cloud mediante la creación de un trabajo por lotes.

Crea un trabajo para especificar la carga de trabajo y sus requisitos. Cuando terminas de crear el trabajo, Google Cloud pone en cola, programa y ejecuta el trabajo de forma automática. El tiempo que tarda un trabajo en terminar de ejecutarse varía según los diferentes trabajos y los momentos según los factores relacionados con la disponibilidad de recursos. Por lo general, es más probable que los trabajos se ejecuten y finalicen antes si son más pequeños y requieren solo unos pocos recursos comunes. Para los trabajos de ejemplo documentados en esta página, que usan una cantidad mínima de recursos, es posible que se terminen de ejecutar en apenas unos minutos.

Puedes crear un trabajo mediante las siguientes opciones:

  • En Crea un trabajo básico, se describen los aspectos básicos, incluido cómo definir las tareas de un trabajo con una secuencia de comandos o una imagen de contenedor.
  • En Crea un trabajo que use variables de entorno, se describe cómo acceder a las variables de entorno predefinidas por lotes o las variables de entorno que defines en los recursos del trabajo.
  • En Crea un trabajo a partir de una plantilla de instancias de Compute Engine, se describe cómo especificar una plantilla de instancias para definir los recursos de un trabajo (opcional). Si tu trabajo necesita usar una imagen de VM específica o un tipo personalizado de máquina, se requiere una plantilla de instancias.
  • En Crea un trabajo que use una cuenta de servicio personalizada, se describe cómo especificar la cuenta de servicio de un trabajo, lo que influye en los recursos y las aplicaciones a los que pueden acceder las VM de un trabajo.
  • En Crea un trabajo que use MPI para las tareas estrechamente vinculadas, se describe cómo configurar un trabajo con tareas interdependientes que se comunican entre sí en diferentes VM mediante una biblioteca de interfaz de envío de mensajes (MPI). Un caso práctico común para la MPI son las cargas de trabajo de procesamiento de alto rendimiento (HPC) estrechamente acopladas.
  • En Crea un trabajo que use una GPU, se describe cómo definir un trabajo que usa una unidad de procesamiento de gráficos (GPU). Los casos prácticos comunes para trabajos que usan GPU incluyen cargas de trabajo de procesamiento de datos o aprendizaje automático (AA) intensivo.
  • En Crea un trabajo que use volúmenes de almacenamiento, se describe cómo definir un trabajo que puede acceder a uno o más volúmenes de almacenamiento externo (opcional). Las opciones de almacenamiento incluyen discos persistentes nuevos o existentes, SSD locales nuevos, depósitos de Cloud Storage existentes y un sistema de archivos de red (NFS) existente, como un archivo compartido de Filestore.

Antes de comenzar

  • Si nunca usaste Batch, revisa Comienza a usar Batch y habilita los requisitos previos para proyectos y usuarios.
  • A fin de obtener los permisos que necesitas para crear un trabajo, pídele a tu administrador que te otorgue las siguientes funciones de IAM:

    • Editor de trabajos por lotes (roles/batch.jobsEditor) en el proyecto
    • Usuario de cuenta de servicio (roles/iam.serviceAccountUser) en la cuenta de servicio del trabajo, que es la cuenta de servicio predeterminada de Compute Engine de forma predeterminada
    • Crea un trabajo a partir de una plantilla de instancias de Compute Engine: visualizador de Compute (roles/compute.viewer) en la plantilla de instancias
    • Crea un trabajo que use un bucket de Cloud Storage: visualizador de objetos de almacenamiento (roles/storage.objectViewer) en el bucket

    Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso.

Crea un trabajo básico

En esta sección, se describe cómo crear un trabajo de ejemplo que ejecuta una secuencia de comandos o una imagen de contenedor:

El trabajo de ejemplo para ambos tipos de trabajos contiene un grupo de tareas con un arreglo de 4 tareas. Cada tarea imprime un mensaje y su índice en la salida estándar y Cloud Logging. La definición de este trabajo especifica un paralelismo de 2, lo que indica que el trabajo debe ejecutarse en 2 VM para permitir que se ejecuten 2 tareas a la vez.

Crea un trabajo de contenedor básico

Puedes seleccionar o crear una imagen de contenedor a fin de proporcionar el código y las dependencias para que tu trabajo se ejecute desde cualquier entorno de procesamiento. Para obtener más información, consulta Trabaja con imágenes de contenedor y Ejecuta contenedores en instancias de VM.

Puedes crear un trabajo de contenedor básico con Google Cloud Console, gcloud CLI, la API de Batch, Go, Java, Node.js o Python.

Consola

Para crear un trabajo de contenedor básico con Google Cloud Console, haz lo siguiente:

  1. En Google Cloud Console, ve a la página Lista de trabajos.

    Ir a la lista de trabajos

  2. Haz clic en Crear. Se abrirá la página Crear trabajo por lotes.

  3. En el campo Nombre del trabajo, ingresa un nombre de trabajo.

    Por ejemplo, ingresa example-basic-job.

  4. En el campo Región, selecciona la ubicación para este trabajo.

    Por ejemplo, selecciona us-central1 (predeterminado).

  5. En Modelo de aprovisionamiento de VM, selecciona una opción para el modelo de aprovisionamiento de las VM de este trabajo:

    • Si tu trabajo puede resistir la interrupción y deseas VM con descuento, selecciona Spot.
    • De lo contrario, selecciona Estándar.

    Por ejemplo, seleccione Estándar (opción predeterminada).

  6. En el campo Task count, ingresa la cantidad de tareas de este trabajo. El valor debe ser un número entero entre 1 y 10000.

    Por ejemplo, ingresa 4.

  7. En el campo Paralelismo, ingresa la cantidad de tareas que se ejecutarán al mismo tiempo. La cantidad no puede ser mayor que la cantidad total de tareas y debe ser un número entero entre 1 y 1000.

    Por ejemplo, ingresa 2.

  8. En Task details, seleccione Container image URL (predeterminado).

  9. En el campo URL de la imagen de contenedor, ingresa una imagen de contenedor.

    Por ejemplo, ingresa lo siguiente para usar la imagen de contenedor busybox de Docker.

    gcr.io/google-containers/busybox
    
  10. Para anular el comando ENTRYPOINT de la imagen del contenedor, ingresa un comando nuevo en el campo Punto de entrada (opcional).

    Por ejemplo, ingresa lo siguiente:

    /bin/sh
    
  11. Opcional: Para anular también el comando CMD de la imagen del contenedor, selecciona la casilla de verificación Anular el comando CMD de la imagen del contenedor y, luego, ingresa uno o más comandos en el campo que aparece y separa cada comando con una línea nueva.

    Por ejemplo, selecciona la casilla de verificación Anular el comando CMD de la imagen de contenedor y, luego, ingresa los siguientes comandos:

    -c
    echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.
    
  12. En Recursos de tareas, especifica la cantidad de recursos de VM necesarios para cada tarea: en el campo Núcleos, ingresa la cantidad de CPU virtuales y, en el campo Memoria, ingresa la cantidad de RAM en GB.

    Por ejemplo, ingresa 1 CPU virtual (predeterminado) y 0.5 GB (predeterminado).

  13. Haz clic en Crear.

En la página Lista de trabajos, se muestra el trabajo que creaste.

gcloud

Para crear un trabajo de contenedor básico con la CLI de gcloud, haz lo siguiente:

  1. Crea un archivo JSON que especifique los detalles de configuración del trabajo. Por ejemplo, para crear un trabajo de contenedor básico, crea un archivo JSON con el siguiente contenido. A fin de obtener más información sobre todos los campos que puedes especificar para un trabajo, consulta la documentación de referencia del recurso de REST projects.locations.jobs.

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

    Reemplaza lo siguiente:

    • CONTAINER: Es el contenedor que ejecuta cada tarea.
    • CORES: Opcional La cantidad de núcleos, específicamente CPU virtuales, que suelen representar la mitad del núcleo físico, para asignar a cada tarea en unidades de milCPU virtuales. Si no se especifica el campo cpuMilli, el valor se establece en 2000 (2 CPU virtuales).
    • MEMORY: Opcional La cantidad de memoria que se asignará para cada tarea en MB. Si no se especifica el campo memoryMib, el valor se establece en 2000 (2 GB).
    • MAX_RETRY_COUNT: Opcional La cantidad máxima de reintentos para una tarea. El valor debe ser un número entero entre 0 y 10. Si no se especifica el campo maxRetryCount, el valor se establece en 0, lo que significa que no se volverá a intentar la tarea.
    • MAX_RUN_DURATION: Opcional El tiempo máximo que una tarea se puede ejecutar antes de que se vuelva a intentar o que falle, con el formato de un valor en segundos seguido de s. Si no se especifica el campo maxRunDuration, el valor se establece en 604800s (7 días), que es el valor máximo.
    • TASK_COUNT: Opcional La cantidad de tareas para el trabajo. El valor debe ser un número entero entre 1 y 10000. Si no se especifica el campo taskCount, el valor se establece en 1.
    • PARALLELISM: Opcional La cantidad de tareas que el trabajo ejecuta en simultáneo. El número no puede ser mayor que el número de tareas y debe ser un número entero entre 1 y 1000. Si no se especifica el campo parallelism, el valor se establece en 1.
  2. Crea un trabajo con el comando gcloud batch jobs submit.

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

    Reemplaza lo siguiente:

    • JOB_NAME: Es el nombre del trabajo.
    • LOCATION: Es la ubicación del trabajo.
    • JSON_CONFIGURATION_FILE: Es la ruta de acceso de un archivo JSON con los detalles de configuración del trabajo.

Por ejemplo, para crear un trabajo que ejecute tareas con la imagen de contenedor busybox de Docker, haz lo siguiente:

  1. Crea un archivo JSON en el directorio actual llamado hello-world-container.json con el siguiente contenido:

    {
        "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. Ejecute el siguiente comando:

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

API

Para crear un trabajo de contenedor básico con la API de Batch, usa el método jobs.create. A fin de obtener más información sobre todos los campos que puedes especificar para un trabajo, consulta la documentación de referencia del recurso de REST projects.locations.jobs.

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

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

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto.
  • LOCATION: Es la ubicación del trabajo.
  • JOB_NAME: Es el nombre del trabajo.
  • CONTAINER: Es el contenedor que ejecuta cada tarea.
  • CORES: Opcional La cantidad de núcleos, específicamente CPU virtuales, que suelen representar la mitad de un núcleo físico, para asignar a cada tarea en unidades de CPU virtuales. Si no se especifica el campo cpuMilli, el valor se establece en 2000 (2 CPU virtuales).
  • MEMORY: Opcional La cantidad de memoria que se asignará para cada tarea en MB. Si no se especifica el campo memoryMib, el valor se establece en 2000 (2 GB).
  • MAX_RETRY_COUNT: Opcional La cantidad máxima de reintentos para una tarea. El valor debe ser un número entero entre 0 y 10. Si no se especifica el campo maxRetryCount, el valor se establece en 0, lo que significa que no se volverá a intentar la tarea.
  • MAX_RUN_DURATION: Opcional El tiempo máximo que una tarea se puede ejecutar antes de que se vuelva a intentar o que falle, con el formato de un valor en segundos seguido de s. Si no se especifica el campo maxRunDuration, el valor se establece en 604800s (7 días), que es el valor máximo.
  • TASK_COUNT: Opcional La cantidad de tareas para el trabajo, que debe ser un número entero entre 1 y 10000 Si no se especifica el campo taskCount, el valor se establece en 1.
  • PARALLELISM: Opcional La cantidad de tareas que el trabajo ejecuta en simultáneo. El número no puede ser mayor que el número de tareas y debe ser un número entero entre 1 y 1000. Si no se especifica el campo parallelism, el valor se establece en 1.

Por ejemplo, para crear un trabajo que ejecute tareas con la imagen de contenedor busybox de Docker, usa la siguiente solicitud:

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

En el ejemplo anterior, PROJECT_ID es el ID del proyecto.

Go

Go

Si deseas obtener más información, consulta la documentación de referencia de la API de Batch Go.

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: %v", 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: %v", err)
	}

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

	return nil
}

Java

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Batch Java.


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

Si deseas obtener más información, consulta la documentación de referencia de la API de Batch Node.js.

/**
 * 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 = [
  '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 out 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

Si deseas obtener más información, consulta la documentación de referencia de la API de Batch Python.

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)

Crear un trabajo de secuencia de comandos básico

Puedes crear un trabajo de secuencia de comandos básico con Google Cloud Console, gcloud CLI, la API de Batch, Go, Java, Node.js o Python.

Consola

Para crear un trabajo de secuencia de comandos básico con Google Cloud Console, haz lo siguiente:

  1. En Google Cloud Console, ve a la página Lista de trabajos.

    Ir a la lista de trabajos

  2. Haz clic en Crear. Se abrirá la página Crear trabajo por lotes.

  3. En el campo Nombre del trabajo, ingresa un nombre de trabajo.

    Por ejemplo, ingresa example-basic-job.

  4. En el campo Región, selecciona la ubicación para este trabajo.

    Por ejemplo, selecciona us-central1 (predeterminado).

  5. En Modelo de aprovisionamiento de VM, selecciona una opción para el modelo de aprovisionamiento de las VM de este trabajo:

    • Si tu trabajo puede resistir la interrupción y deseas VM con descuento, selecciona Spot.
    • De lo contrario, selecciona Estándar.

    Por ejemplo, seleccione Estándar (opción predeterminada).

  6. En el campo Task count, ingresa la cantidad de tareas de este trabajo. El valor debe ser un número entero entre 1 y 10000.

    Por ejemplo, ingresa 4.

  7. En el campo Paralelismo, ingresa la cantidad de tareas que se ejecutarán al mismo tiempo. La cantidad no puede ser mayor que la cantidad total de tareas y debe ser un número entero entre 1 y 1000.

    Por ejemplo, ingresa 2.

  8. En Detalles de la tarea, selecciona Secuencia de comandos.

    Luego, en el campo que aparece, ingrese una secuencia de comandos que se ejecutará en cada tarea.

    Por ejemplo, usa la siguiente secuencia de comandos:

    echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.
    
  9. En Recursos de tareas, especifica la cantidad de recursos de VM necesarios para cada tarea: en el campo Núcleos, ingresa la cantidad de CPU virtuales y, en el campo Memoria, ingresa la cantidad de RAM en GB.

    Por ejemplo, ingresa 1 CPU virtual (predeterminado) y 0.5 GB (predeterminado).

  10. Haz clic en Crear.

En la página Lista de trabajos, se muestra el trabajo que creaste.

gcloud

Para crear un trabajo de secuencia de comandos básico con la CLI de gcloud, haz lo siguiente:

  1. Crea un archivo JSON que especifique los detalles de configuración del trabajo. Por ejemplo, para crear un trabajo de secuencia de comandos básico, crea un archivo JSON con el siguiente contenido. A fin de obtener más información sobre todos los campos que puedes especificar para un trabajo, consulta la documentación de referencia del recurso de REST projects.locations.jobs.

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

    Reemplaza lo siguiente:

    • SCRIPT: Es la secuencia de comandos que ejecuta cada tarea.
    • CORES: Opcional La cantidad de núcleos, específicamente CPU virtuales, que suelen representar la mitad del núcleo físico, para asignar a cada tarea en unidades de milCPU virtuales. Si no se especifica el campo cpuMilli, el valor se establece en 2000 (2 CPU virtuales).
    • MEMORY: Opcional La cantidad de memoria que se asignará para cada tarea en MB. Si no se especifica el campo memoryMib, el valor se establece en 2000 (2 GB).
    • MAX_RETRY_COUNT: Opcional La cantidad máxima de reintentos para una tarea. El valor debe ser un número entero entre 0 y 10. Si no se especifica el campo maxRetryCount, el valor se establece en 0, lo que significa que no se volverá a intentar la tarea.
    • MAX_RUN_DURATION: Opcional El tiempo máximo que una tarea se puede ejecutar antes de que se vuelva a intentar o que falle, con el formato de un valor en segundos seguido de s. Si no se especifica el campo maxRunDuration, el valor se establece en 604800s (7 días), que es el valor máximo.
    • TASK_COUNT: Opcional La cantidad de tareas para el trabajo. El valor debe ser un número entero entre 1 y 10000. Si no se especifica el campo taskCount, el valor se establece en 1.
    • PARALLELISM: Opcional La cantidad de tareas que el trabajo ejecuta en simultáneo. El número no puede ser mayor que el número de tareas y debe ser un número entero entre 1 y 1000. Si no se especifica el campo parallelism, el valor se establece en 1.
  2. Crea un trabajo con el comando gcloud batch jobs submit.

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

    Reemplaza lo siguiente:

    • JOB_NAME: Es el nombre del trabajo.
    • LOCATION: Es la ubicación del trabajo.
    • JSON_CONFIGURATION_FILE: Es la ruta de acceso de un archivo JSON con los detalles de configuración del trabajo.

Por ejemplo, para crear un trabajo que ejecute tareas con una secuencia de comandos, sigue estos pasos:

  1. Crea un archivo JSON en el directorio actual llamado hello-world-script.json con el siguiente contenido:

    {
        "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. Ejecute el siguiente comando:

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

API

Para crear un trabajo de secuencia de comandos básico con la API de Batch, usa el método jobs.create. A fin de obtener más información sobre todos los campos que puedes especificar para un trabajo, consulta la documentación de referencia del recurso de REST projects.locations.jobs.

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

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

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto.
  • LOCATION: Es la ubicación del trabajo.
  • JOB_NAME: Es el nombre del trabajo.
  • SCRIPT: Es la secuencia de comandos que ejecuta cada tarea.
  • CORES: Opcional La cantidad de núcleos, específicamente CPU virtuales, que suelen representar la mitad de un núcleo físico, para asignar a cada tarea en unidades de CPU virtuales. Si no se especifica el campo cpuMilli, el valor se establece en 2000 (2 CPU virtuales).
  • MEMORY: Opcional La cantidad de memoria que se asignará para cada tarea en MB. Si no se especifica el campo memoryMib, el valor se establece en 2000 (2 GB).
  • MAX_RETRY_COUNT: Opcional La cantidad máxima de reintentos para una tarea. El valor debe ser un número entero entre 0 y 10. Si no se especifica el campo maxRetryCount, el valor se establece en 0, lo que significa que no se volverá a intentar la tarea.
  • MAX_RUN_DURATION: Opcional El tiempo máximo que una tarea se puede ejecutar antes de que se vuelva a intentar o que falle, con el formato de un valor en segundos seguido de s. Si no se especifica el campo maxRunDuration, el valor se establece en 604800s (7 días), que es el valor máximo.
  • TASK_COUNT: Opcional La cantidad de tareas para el trabajo. El valor debe ser un número entero entre 1 y 10000. Si no se especifica el campo taskCount, el valor se establece en 1.
  • PARALLELISM: Opcional La cantidad de tareas que el trabajo ejecuta en simultáneo. El número no puede ser mayor que el número de tareas y debe ser un número entero entre 1 y 1000. Si no se especifica el campo parallelism, el valor se establece en 1.

Por ejemplo, para crear un trabajo que ejecute tareas con una secuencia de comandos, usa la siguiente solicitud:

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

En el ejemplo anterior, PROJECT_ID es el ID del proyecto.

Go

Go

Si deseas obtener más información, consulta la documentación de referencia de la API de Batch Go.

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: %v", 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: %v", err)
	}

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

	return nil
}

Java

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Batch Java.


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

Si deseas obtener más información, consulta la documentación de referencia de la API de Batch Node.js.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Batch Python.

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)

Crea un trabajo que use variables de entorno

Puedes definir variables de entorno en los recursos de tu trabajo y usarlas en los objetos ejecutables de tu trabajo.

De forma predeterminada, los objetos ejecutables en tu trabajo pueden usar las siguientes variables de entorno:

  • BATCH_TASK_COUNT: Es la cantidad de tareas en un grupo de tareas.
  • BATCH_TASK_INDEX: Es el número de índice de una tarea en un grupo de tareas. La numeración del índice comienza en 0.
  • BATCH_HOSTS_FILE: Opcional La ruta al archivo que enumera todas las instancias de VM en ejecución en un grupo de tareas. Para usar esta variable de entorno, el campo requireHostsFile es obligatorio y debe establecerse en verdadero.

De manera opcional, puedes definir variables de entorno personalizadas en los recursos de tu trabajo y usarlas de la siguiente manera:

  • En una ejecución que ejecute cada tarea.
  • En todos los elementos ejecutables que ejecuta una tarea

En esta sección, se proporcionan ejemplos sobre cómo crear dos trabajos que definen variables de entorno personalizadas en sus recursos. En el primer trabajo de ejemplo, se pasa una variable de entorno a un ejecutable que ejecuta cada tarea. El segundo trabajo de ejemplo pasa un arreglo de variables de entorno, con nombres coincidentes, pero con valores diferentes, a las tareas que indexan los índices de las variables del entorno en el arreglo.

Puedes definir variables de entorno para tu trabajo con la CLI de gcloud o la API de Batch.

glocud

Si deseas definir un trabajo que pasa una variable de entorno a un elemento ejecutable que ejecute cada tarea, consulta el ejemplo para obtener información sobre cómo definir y usar una variable de entorno para un objeto ejecutable. De lo contrario, si deseas definir un trabajo que pasa una lista de variables de entorno a diferentes tareas según el índice de tareas, consulta el ejemplo sobre cómo definir y usar una variable de entorno para cada tarea.

Define y usa una variable de entorno para un objeto ejecutable

Para crear un trabajo que pase variables de entorno a un entorno ejecutable con la CLI de gcloud, usa el comando gcloud batch jobs submit y especifica las variables de entorno en el archivo de configuración del trabajo.

Por ejemplo, para crear un trabajo de secuencia de comandos que defina una variable de entorno y la pase a las secuencias de comandos de 3 tareas, realiza la siguiente solicitud:

  1. Crea un archivo JSON en el directorio actual llamado hello-word-environment-variables.json con el siguiente contenido:

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

    Reemplaza lo siguiente:

    • VARIABLE_NAME: Es el nombre de la variable de entorno que se pasa a cada tarea. Por convención, los nombres de las variables de entorno tienen mayúsculas.
    • VARIABLE_VALUE: Opcional El valor de la variable de entorno que se pasa a cada tarea.
  2. Ejecute el siguiente comando:

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

Define y usa una variable de entorno para cada tarea

Para crear un trabajo que pase variables de entorno a una tarea según el índice de la tarea mediante gcloud CLI, usa el comando gcloud batch jobs submit y especifica el campo de arreglo taskEnvironments en el archivo de configuración del trabajo.

Por ejemplo, para crear un trabajo que incluya un arreglo de 3 variables de entorno con nombres coincidentes y valores diferentes, y pasa las variables del entorno a las secuencias de comandos de las tareas que coinciden con los índices de las variables de entorno en el arreglo:

  1. Crea un archivo JSON en el directorio actual llamado hello-word-task-environment-variables.json con el siguiente contenido:

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

    Reemplaza lo siguiente:

    • TASK_VARIABLE_NAME: Es el nombre de las variables de entorno que se pasan a las tareas con índices coincidentes. Por convención, los nombres de las variables de entorno tienen mayúsculas.
    • TASK_VARIABLE_VALUE_0: Es el valor de la variable de entorno que se pasa a la tarea, que BATCH_TASK_INDEX es igual a 0.
    • TASK_VARIABLE_VALUE_1: Es el valor de la variable de entorno que se pasa a la tarea, que BATCH_TASK_INDEX es igual a 1.
    • TASK_VARIABLE_VALUE_2: Es el valor de la variable de entorno que se pasa a la tarea, que BATCH_TASK_INDEX es igual a 2.
  2. Ejecute el siguiente comando:

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

API

Si deseas definir un trabajo que pasa una variable de entorno a un elemento ejecutable que ejecute cada tarea, consulta el ejemplo para obtener información sobre cómo definir y usar una variable de entorno para un objeto ejecutable. De lo contrario, si deseas definir un trabajo que pasa una lista de variables de entorno a diferentes tareas según el índice de tareas, consulta el ejemplo sobre cómo definir y usar una variable de entorno para cada tarea.

Define y usa una variable de entorno para un objeto ejecutable

Para crear un trabajo que pase variables de entorno a una que se pueda ejecutar mediante la API de Batch, usa el comando gcloud batch jobs submit y especifica las variables de entorno en el campo environment.

Por ejemplo, para crear un trabajo que incluya una variable de entorno y la pase a las secuencias de comandos de 3 tareas, realiza la siguiente solicitud:

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

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto.
  • VARIABLE_NAME: Es el nombre de la variable de entorno que se pasa a cada tarea. Por convención, los nombres de las variables de entorno tienen mayúsculas.
  • VARIABLE_VALUE: Es el valor de la variable de entorno que se pasa a cada tarea.

Define y usa una variable de entorno para cada tarea

Para crear un trabajo que pase variables de entorno a una tarea según el índice de tareas con la API de Batch, usa el método jobs.create y especifica las variables de entorno en el campo del arreglo taskEnvironments.

Por ejemplo, para crear un trabajo que incluya un arreglo de 3 variables de entorno con nombres coincidentes y valores diferentes, y pasa las variables de entorno a las secuencias de comandos de 3 tareas según sus índices, realiza la siguiente solicitud:

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

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto.
  • TASK_VARIABLE_NAME: Es el nombre de las variables de entorno que se pasaron a las tareas con índices coincidentes. Por convención, los nombres de las variables de entorno tienen mayúsculas.
  • TASK_VARIABLE_VALUE_0: Es el valor de la variable de entorno que se pasa a la tarea, en la que BATCH_TASK_INDEX es igual a 0.
  • TASK_VARIABLE_VALUE_1: Es el valor de la variable de entorno que se pasa a la tarea, en la que BATCH_TASK_INDEX es igual a 1.
  • TASK_VARIABLE_VALUE_2: Es el valor de la variable de entorno que se pasa a la tarea, en la que BATCH_TASK_INDEX es igual a 2.

Crea un trabajo a partir de una plantilla de instancias de Compute Engine

De manera opcional, puedes usar una plantilla de instancias de Compute Engine para definir los recursos de tu trabajo. Esto es necesario para crear un trabajo que use imágenes de VM no predeterminadas o un trabajo con un tipo personalizado de máquina.

En esta sección, se proporcionan ejemplos sobre cómo crear un trabajo de secuencia de comandos básico a partir de una plantilla de instancias existente. Puedes crear un trabajo a partir de una plantilla de instancias con gcloud CLI o la API de Batch.

gcloud

Para crear un trabajo a partir de una plantilla de instancias con gcloud CLI, usa el comando gcloud batch jobs submit y especifica la plantilla de instancias en el archivo de configuración JSON del trabajo.

Por ejemplo, para crear un trabajo de secuencia de comandos básico a partir de una plantilla de instancias:

  1. Crea un archivo JSON en el directorio actual llamado hello-world-instance-template.json con el siguiente contenido:

    {
        "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": [
                {
                    "installGpuDrivers" INSTALL_GPU_DRIVERS,
                    "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
                }
            ]
        },
        "labels": {
            "department": "finance",
            "env": "testing"
        },
        "logsPolicy": {
            "destination": "CLOUD_LOGGING"
        }
    }
    

    Reemplaza lo siguiente:

    • INSTALL_GPU_DRIVERS: Opcional Cuando se configura en true, Batch recupera e instala los controladores de GPU necesarios para este trabajo.
    • INSTALL_GPU_DRIVERS: Opcional Cuando se configura en true, Batch recupera los controladores necesarios para el tipo de GPU que especificas en tu plantilla de instancias de Compute Engine y Batch los instala en tu nombre. Para obtener más información, consulta cómo crear un trabajo que use una GPU.
    • INSTANCE_TEMPLATE_NAME: Es el nombre de una plantilla de instancias de Compute Engine existente. Obtén información sobre cómo crear y enumerar plantillas de instancias.
  2. Ejecute el siguiente comando:

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

API

Para crear un trabajo básico con la API de Batch, usa el método jobs.create y especifica una plantilla de instancias en el campo allocationPolicy.

Por ejemplo, para crear trabajos de secuencia de comandos básicos a partir de una plantilla de instancias, usa la siguiente solicitud:

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": [
            {
                "installGpuDrivers" INSTALL_GPU_DRIVERS,
                "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
            }
        ]
    },
    "labels": {
        "department": "finance",
        "env": "testing"
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto.
  • INSTALL_GPU_DRIVERS: Opcional Cuando se configura en true, Batch recupera los controladores necesarios para el tipo de GPU que especificas en tu plantilla de instancias de Compute Engine y Batch los instala en tu nombre. Para obtener más información, consulta Crea un trabajo que use una GPU.
  • INSTANCE_TEMPLATE_NAME: Es el nombre de una plantilla de instancias de Compute Engine existente. Obtén información sobre cómo crear y enumerar plantillas de instancias.

Crea un trabajo que use una cuenta de servicio personalizada

De manera opcional, puedes crear un trabajo que use una cuenta de servicio personalizada en lugar de la cuenta de servicio predeterminada de Compute Engine. La cuenta de servicio de un trabajo influye en los recursos y las aplicaciones a los que pueden acceder las VM del trabajo. La cuenta de servicio predeterminada de Compute Engine se conecta automáticamente a todas las VM de forma predeterminada, por lo que usar una cuenta de servicio personalizada proporciona un mayor control para administrar los permisos de un trabajo y es una práctica recomendada para limitar los privilegios.

Antes de crear un trabajo que use una cuenta de servicio personalizada, asegúrate de que la cuenta de servicio que planeas usar tenga los permisos necesarios para crear trabajos por lotes para tu proyecto. A fin de obtener más información, consulta Habilita Batch para un proyecto.

Para crear un trabajo que use una cuenta de servicio personalizada, selecciona uno de los siguientes métodos:

  • Especifica la cuenta de servicio personalizada en la definición de tu trabajo, como se muestra en esta sección.
  • Usa una plantilla de instancias de Compute Engine y especifica la cuenta de servicio personalizada en la plantilla de instancias y en la definición de tu trabajo.

En esta sección, se proporciona un ejemplo de cómo crear un trabajo que usa una cuenta de servicio personalizada. Puedes crear un trabajo que use una cuenta de servicio personalizada con la CLI de gcloud o la API de Batch.

gcloud

Para crear un trabajo que use una cuenta de servicio personalizada con la CLI de gcloud, usa el comando gcloud batch jobs submit y especifica la cuenta de servicio personalizada en el archivo de configuración del trabajo.

Por ejemplo, para crear un trabajo de secuencia de comandos que use una cuenta de servicio personalizada, haz lo siguiente:

  1. Crea un archivo JSON en el directorio actual llamado hello-world-service-account.json con el siguiente contenido:

    {
        "taskGroups": [
            {
                "taskSpec": {
                    "runnables": [
                        {
                            "script": {
                                "text": "echo Hello World! This is task $BATCH_TASK_INDEX."
                            }
                        }
                    ]
                }
            }
        ],
        "allocationPolicy": {
            "serviceAccount": {
                "email": "SERVICE_ACCOUNT_EMAIL"
            }
        }
    }
    

    En el ejemplo anterior, SERVICE_ACCOUNT_EMAIL es la dirección de correo electrónico de la cuenta de servicio. Si no se especifica el campo serviceAccount, el valor se establece en la cuenta de servicio predeterminada de Compute Engine.

  2. Ejecute el siguiente comando:

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

API

Para crear un trabajo que use una cuenta de servicio personalizada con la API de Batch, usa el método jobs.create y especifica tu cuenta de servicio personalizada en el campo allocationPolicy.

Por ejemplo, para crear un trabajo de secuencia de comandos que use una cuenta de servicio personalizada, realiza la siguiente solicitud:

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

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello World! This is task $BATCH_TASK_INDEX."
                        }
                    }
                ]
            }
        }
    ],
    "allocationPolicy": {
        "serviceAccount": {
            "email": "SERVICE_ACCOUNT_EMAIL"
        }
    }
}

Reemplaza lo siguiente:

Crea un trabajo que use la MPI para las tareas estrechamente vinculadas

De manera opcional, puedes crear un trabajo que use una biblioteca de Interfaz de envío de mensajes (MPI) para permitir que las tareas interdependientes se comuniquen entre sí en diferentes instancias de VM.

En esta sección, se proporcionan ejemplos sobre cómo crear un trabajo que pueda usar la MPI. En particular, los trabajos de ejemplo tienen 3 ejecutables:

  • La primera ejecutable es una secuencia de comandos que prepara el trabajo para la MPI mediante la inhabilitación de varios subprocesos simultáneos y la instalación de Intel MPI.
  • El segundo objeto ejecutable es una ejecución de barrera vacía (con formato { "barrier": {} }), que garantiza que todas las tareas terminen de configurar la MPI antes de continuar con los elementos ejecutables futuros.
  • El tercer ejecutable (y cualquier otro posterior) está disponible para la carga de trabajo del trabajo.

Puedes crear un trabajo que use la MPI para las tareas estrechamente vinculadas mediante la CLI de gcloud o la API de Batch.

gcloud

Si deseas crear un trabajo de secuencia de comandos que use la MPI para tareas estrechamente vinculadas mediante la CLI de gcloud, haz lo siguiente:

  1. Crea un archivo de configuración JSON con el siguiente contenido:

    {
        "taskGroups": [
            {
                "taskSpec": {
                    "runnables": [
                        {
                            "script": {
                                "text": "google_mpi_tuning --nosmt; google_install_mpi --intel_mpi;"
                            }
                        },
                        { "barrier": {} },
                        {
                            "script": {
                                SCRIPT
                            }
                        }
                    ]
                },
                "taskCount": TASK_COUNT,
                "taskCountPerNode": TASK_COUNT_PER_NODE,
                "requireHostsFile": REQUIRE_HOSTS_FILE,
                "permissiveSsh": PERMISSIVE_SSH
            }
        ]
    }
    

    Reemplaza lo siguiente:

    • SCRIPT: Una secuencia de comandos que se puede ejecutar para una carga de trabajo que usa MPI.
    • TASK_COUNT: Es la cantidad de tareas para el trabajo. El valor debe ser un número entero entre 1 y 10000. Para usar las bibliotecas de la MPI que proporciona Batch, este campo es obligatorio y se debe configurar como 2 o superior.
    • TASK_COUNT_PER_NODE: Es la cantidad de tareas que un trabajo puede ejecutar en simultáneo en una instancia de VM. Para usar las bibliotecas de MPI que proporciona Batch, este campo es obligatorio y debe establecerse en 1, que equivale a ejecutar una instancia de VM por tarea.
    • REQUIRE_HOSTS_FILE: Cuando se establece en true, el trabajo crea un archivo que enumera las instancias de VM que se ejecutan en un grupo de tareas. La ruta del archivo se almacena en la variable de entorno BATCH_HOSTS_FILE. Para usar las bibliotecas de MPI que proporciona Batch, este campo se debe configurar como verdadero.
    • PERMISSIVE_SSH: Cuando se configura en true, Batch configura SSH para permitir la comunicación sin contraseña entre las instancias de VM que se ejecutan en un grupo de tareas. Para usar las bibliotecas de MPI que proporciona Batch, este campo se debe configurar como verdadero.
  2. Para crear el trabajo, usa el comando gcloud batch jobs submit.

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

    Reemplaza lo siguiente:

    • JOB_NAME: Es el nombre del trabajo.
    • LOCATION: Es la ubicación del trabajo.
    • JSON_CONFIGURATION_FILE: Es la ruta de acceso de un archivo JSON con los detalles de configuración del trabajo.

De manera opcional, puedes aumentar el rendimiento de las bibliotecas de la MPI que proporciona Batch si realizas lo siguiente:

Por ejemplo, para crear un trabajo de secuencia de comandos a partir de una plantilla de instancias que usa MPI y hace que 1 tarea genere el nombre de host de las 3 tareas en el grupo de tareas, haz lo siguiente:

  1. Crea un archivo JSON en el directorio actual llamado example-job-uses-mpi.json con el siguiente contenido:

    {
        "taskGroups": [
            {
                "taskSpec": {
                    "runnables": [
                        {
                            "script": {
                                "text": "google_mpi_tuning --nosmt; google_install_mpi --intel_mpi;"
                            }
                        },
                        { "barrier": {} },
                        {
                            "script": {
                                "text":
                                    "if [ $BATCH_TASK_INDEX = 0 ]; then
                                    mpirun -hostfile $BATCH_HOSTS_FILE -np 3 hostname;
                                    fi"
                            }
                        },
                        { "barrier": {} }
                    ]
                },
                "taskCount": 3,
                "taskCountPerNode": 1,
                "requireHostsFile": true,
                "permissiveSsh": true
            }
        ],
        "allocationPolicy": {
            "instances": [
                {
                    "instanceTemplate": "example-template-job-uses-mpi"
                }
            ]
        },
        "logsPolicy": {
            "destination": "CLOUD_LOGGING"
        }
    }
    
  2. Ejecute el siguiente comando:

    gcloud batch jobs submit example-template-job-uses-mpi \
      --location us-central1 \
      --config example-job-uses-mpi.json
    

API

Si deseas crear un trabajo de secuencia de comandos que use una MPI para tareas estrechamente vinculadas mediante la API de Batch, usa el comando gcloud batch jobs submit y especifica los campos permissiveSsh, requireHostsFile, taskCount y taskCountPerNode.

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

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "google_mpi_tuning --nosmt; google_install_mpi --intel_mpi;"
                        }
                    },
                    { "barrier": {} },
                    {
                        "script": {
                            SCRIPT
                        }
                    }
                ]
            },
            "taskCount": TASK_COUNT,
            "taskCountPerNode": TASK_COUNT_PER_NODE,
            "requireHostsFile": REQUIRE_HOSTS_FILE,
            "permissiveSsh": PERMISSIVE_SSH
        }
    ]
}

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto.
  • LOCATION: Es la ubicación del trabajo.
  • JOB_NAME: Es el nombre del trabajo.
  • SCRIPT: La secuencia de comandos que se puede ejecutar para una carga de trabajo que usa MPI.
  • TASK_COUNT: Es la cantidad de tareas para el trabajo. El valor debe ser un número entero entre 1 y 10000. Para usar las bibliotecas de la MPI que proporciona Batch, este campo es obligatorio y se debe configurar como 2 o superior.
  • TASK_COUNT_PER_NODE: Es la cantidad de tareas que un trabajo puede ejecutar en simultáneo en una instancia de VM. Para usar las bibliotecas de MPI que proporciona Batch, este campo es obligatorio y debe establecerse en 1, que equivale a ejecutar una instancia de VM por tarea.
  • REQUIRE_HOSTS_FILE: Cuando se establece en true, el trabajo crea un archivo que enumera las instancias de VM que se ejecutan en un grupo de tareas. La ruta del archivo se almacena en la variable de entorno BATCH_HOSTS_FILE. Para usar las bibliotecas de MPI que proporciona Batch, este campo se debe configurar como verdadero.
  • PERMISSIVE_SSH: Cuando se configura en true, Batch configura SSH para permitir la comunicación sin contraseña entre las instancias de VM que se ejecutan en un grupo de tareas. Para usar las bibliotecas de MPI que proporciona Batch, este campo se debe configurar como verdadero.

De manera opcional, puedes aumentar el rendimiento de las bibliotecas de la MPI que proporciona Batch si realizas lo siguiente:

Por ejemplo, para crear un trabajo de secuencia de comandos a partir de una plantilla de instancias que usa MPI y hace que 1 tarea genere el nombre de host de las 3 tareas en el grupo de tareas, usa la siguiente solicitud:

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

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "google_mpi_tuning --nosmt; google_install_mpi --intel_mpi;"
                        }
                    },
                    { "barrier": {} },
                    {
                        "script": {
                            "text":
                                "if [ $BATCH_TASK_INDEX = 0 ]; then
                                mpirun -hostfile $BATCH_HOSTS_FILE -np 3 hostname;
                                fi"
                        }
                    },
                    { "barrier": {} }
                ]
            },
            "taskCount": 3,
            "taskCountPerNode": 1,
            "requireHostsFile": true,
            "permissiveSsh": true
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "instanceTemplate": "example-template-job-uses-mpi"
            }
        ]
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

En el ejemplo anterior, PROJECT_ID es el ID del proyecto.

Si deseas obtener un ejemplo más detallado de un trabajo que usa la MPI para tareas estrechamente vinculadas, consulta Ejecuta el modelo de investigación y previsión meteorológica con Batch.

Crea un trabajo que use una GPU

De manera opcional, puedes crear un trabajo que agregue una unidad de procesamiento de gráficos (GPU) a las instancias de VM que se ejecutan en el grupo de tareas de tu trabajo.

A fin de instalar los controladores de GPU necesarios para tu trabajo, selecciona uno de los siguientes métodos:

Para agregar una GPU a los recursos de tu trabajo, selecciona uno de los siguientes métodos:

  • Define el tipo de máquina y la plataforma de GPU en la definición de tu trabajo, como se muestra en esta sección.
  • Define la GPU en tu plantilla de instancias de Compute Engine. Si incluyes una plantilla de instancias en la definición de tu trabajo, debes usar este método.

En esta sección, se proporcionan ejemplos sobre cómo crear un trabajo que define una GPU en los recursos del trabajo y se instalan los controladores necesarios para la GPU. En el primer ejemplo, se muestra cómo agregar una GPU a un trabajo de contenedor que usa la imagen predeterminada. En el segundo ejemplo, se muestra cómo agregar una GPU a un trabajo de secuencia de comandos que usa la imagen predeterminada. En el tercer ejemplo, se muestra cómo agregar una GPU a un contenedor y un trabajo de secuencia de comandos que usa la imagen predeterminada.

Puedes crear un trabajo que use una GPU mediante la CLI de gcloud o la API de Batch.

gcloud

Si deseas agregar una GPU a un trabajo, consulta los siguientes ejemplos:

Agrega una GPU a un trabajo de contenedor

Para crear un trabajo de contenedor con una GPU que use la imagen predeterminada mediante la CLI de gcloud, usa el comando gcloud batch jobs submit y especifica lo siguiente en el archivo de configuración del trabajo:

  • El tipo de máquina y la plataforma de GPU
  • Los campos volumes y options para activar la GPU en un trabajo de contenedor con la imagen predeterminada, como se muestra en este ejemplo.

Por ejemplo, para crear un trabajo de contenedor con una GPU, sigue estos pasos:

  1. Crea un archivo JSON en el directorio actual llamado hello-world-container-job-gpu.json con el siguiente contenido:

    {
        "taskGroups": [
            {
                "taskSpec": {
                    "runnables": [
                        {
                            "container": {
                                "volumes": [
                                    "/var/lib/nvidia/lib64:/usr/local/nvidia/lib64",
                                    "/var/lib/nvidia/bin:/usr/local/nvidia/bin"
                                ],
                                "options": "--privileged",
                                "commands": [
                                    "-c",
                                    "echo Hello world from task ${BATCH_TASK_INDEX}."
                                ]
                            }
                        }
                    ],
                },
                "taskCount": 3,
                "parallelism": 1
            }
        ],
        "allocationPolicy": {
            "instances": [
                {
                    "installGpuDrivers": INSTALL_GPU_DRIVERS,
                    "policy": {
                        "machineType": "MACHINE_TYPE",
                        "accelerators": [
                            {
                                "type": "GPU_TYPE",
                                "count": GPU_COUNT
                            }
                        ]
                    }
                }
            ],
            "location": {
                "allowedLocations": [
                    "ALLOWED_LOCATIONS"
                ]
            }
        }
    }
    

    Reemplaza lo siguiente:

    • INSTALL_GPU_DRIVERS: Opcional Cuando se establece en true, Batch recupera los controladores necesarios para el tipo de GPU que especificas en el campo policy de una ubicación de terceros y los instala en tu nombre.
    • MACHINE_TYPE: Es el tipo de máquina para las VM de tu trabajo, que restringe el tipo de GPU que puedes usar. Para crear un trabajo con una GPU, este campo es obligatorio.
    • GPU_TYPE: Es el tipo de GPU. Puedes ver una lista de los tipos de GPU disponibles con el comando gcloud compute accelerator-types list. Para crear un trabajo con una GPU, este campo es obligatorio.
    • GPU_COUNT: Es la cantidad de GPU del tipo que especificaste en el campo type. Para crear un trabajo con una GPU, este campo es obligatorio.
    • ALLOWED_LOCATIONS: Opcional Las ubicaciones en las que se pueden ejecutar las instancias de VM para tu trabajo (por ejemplo, regions/us-central1, zones/us-central1-a permite la zona us-central1-a). Si especificas una ubicación permitida, debes seleccionar la región y, de forma opcional, una o más zonas. Las ubicaciones que elijas deben tener el tipo de GPU que deseas para este trabajo. Para obtener más información, consulta el campo de arreglo allowedLocations.
  2. Ejecute el siguiente comando:

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

Agrega una GPU a un trabajo de secuencia de comandos

Para crear un trabajo de secuencia de comandos con una GPU que use la imagen predeterminada mediante la CLI de gcloud, usa el comando gcloud batch jobs submit y especifica la plataforma de tipo de máquina y GPU en el archivo de configuración del trabajo.

Por ejemplo, para crear un trabajo de secuencia de comandos con una GPU, sigue estos pasos:

  1. Crea un archivo JSON en el directorio actual llamado hello-world-script-job-gpu.json con el siguiente contenido:

    {
        "taskGroups": [
            {
                "taskSpec": {
                    "runnables": [
                        {
                            "script": {
                                "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                            }
                        }
                    ]
                },
                "taskCount": 3,
                "parallelism": 1
            }
        ],
        "allocationPolicy": {
            "instances": [
                {
                    "installGpuDrivers": INSTALL_GPU_DRIVERS,
                    "policy": {
                        "machineType": "MACHINE_TYPE",
                        "accelerator":
                            {
                                "type": "GPU_TYPE",
                                "count": GPU_COUNT
                            }
                        ]
                    }
                }
            ],
            "location": {
                "allowedLocations": [
                    "ALLOWED_LOCATIONS"
                ]
            }
        }
    }
    

    Reemplaza lo siguiente:

    • INSTALL_GPU_DRIVERS: Opcional Cuando se establece en true, Batch recupera los controladores necesarios para el tipo de GPU que especificas en el campo policy de una ubicación de terceros y los instala en tu nombre.
    • MACHINE_TYPE: Es el tipo de máquina para las VM de tu trabajo, que restringe el tipo de GPU que puedes usar. Para crear un trabajo con una GPU, este campo es obligatorio.
    • GPU_TYPE: Es el tipo de GPU. Puedes ver una lista de los tipos de GPU disponibles con el comando gcloud compute accelerator-types list. Para crear un trabajo con una GPU, este campo es obligatorio.
    • GPU_COUNT: Es la cantidad de GPU del tipo que especificaste en el campo type. Para crear un trabajo con una GPU, este campo es obligatorio.
    • ALLOWED_LOCATIONS: Opcional Las ubicaciones en las que se pueden ejecutar las instancias de VM para tu trabajo (por ejemplo, regions/us-central1, zones/us-central1-a permite la zona us-central1-a). Si especificas una ubicación permitida, debes seleccionar la región y, de forma opcional, una o más zonas. Las ubicaciones que elijas deben tener el tipo de GPU que deseas para este trabajo. Para obtener más información, consulta el campo de arreglo allowedLocations.
  2. Ejecute el siguiente comando:

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

Agrega una GPU a un trabajo de contenedor y secuencia de comandos

Para crear un trabajo de contenedor y secuencia de comandos con una GPU que use la imagen predeterminada mediante la CLI de gcloud, usa el comando gcloud batch jobs submit y especifica lo siguiente en el archivo de configuración del trabajo:

  • El tipo de máquina y la plataforma de GPU
  • El campo text para cada secuencia de comandos que se puede ejecutar y los campos imageUri y options para cada contenedor ejecutable, a fin de activar la GPU en un trabajo de contenedor y secuencia de comandos con la imagen predeterminada, como se muestra en este ejemplo

Por ejemplo, para crear un trabajo de contenedor y secuencia de comandos con una GPU, haz lo siguiente:

  1. Crea un archivo JSON en el directorio actual llamado hello-world-container-script-job-gpu.json con el siguiente contenido:

    {
        "taskGroups": [
            {
                "taskSpec": {
                    "runnables": [
                        {
                            "script": {
                                "text":
                                    "distribution=$(. /etc/os-release;echo $ID$VERSION_ID);
                                    curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -;
                                    curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list;
                                    sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit;
                                    sudo systemctl restart docker"
                            }
                        },
                        {
                            "container": {
                                "imageUri": "gcr.io/google_containers/cuda-vector-add:v0.1",
                                "options": "--gpus all"
                            }
                        },
                        {
                            "script": {
                                "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                            }
                        }
                    ]
                },
                "taskCount": 3,
                "parallelism": 1
            }
        ],
        "allocationPolicy": {
            "instances": [
                {
                    "installGpuDrivers": INSTALL_GPU_DRIVERS,
                    "policy": {
                        "machineType": "MACHINE_TYPE",
                        "accelerators": [
                            {
                                "type": "GPU_TYPE",
                                "count": GPU_COUNT
                            }
                        ]
                    }
                }
            ],
            "location": {
                "allowedLocations": [
                    "ALLOWED_LOCATIONS"
                ]
            }
        }
    }
    

    Reemplaza lo siguiente:

    • INSTALL_GPU_DRIVERS: Opcional Cuando se establece en true, Batch recupera los controladores necesarios para el tipo de GPU que especificas en el campo policy de una ubicación de terceros y los instala en tu nombre.
    • MACHINE_TYPE: Es el tipo de máquina para las VM de tu trabajo, que restringe el tipo de GPU que puedes usar. Para crear un trabajo con una GPU, este campo es obligatorio.
    • GPU_TYPE: Es el tipo de GPU. Puedes ver una lista de los tipos de GPU disponibles con el comando gcloud compute accelerator-types list. Para crear un trabajo con una GPU, este campo es obligatorio.
    • GPU_COUNT: Es la cantidad de GPU del tipo que especificaste en el campo type. Para crear un trabajo con una GPU, este campo es obligatorio.
    • ALLOWED_LOCATIONS: Opcional Las ubicaciones en las que se pueden ejecutar las instancias de VM para tu trabajo (por ejemplo, regions/us-central1, zones/us-central1-a permite la zona us-central1-a). Si especificas una ubicación permitida, debes seleccionar la región y, de forma opcional, una o más zonas. Las ubicaciones que elijas deben tener el tipo de GPU que deseas para este trabajo. Para obtener más información, consulta el campo de arreglo allowedLocations.
  2. Ejecute el siguiente comando:

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

API

Si deseas agregar una GPU a un trabajo, consulta los siguientes ejemplos:

Agrega una GPU a un trabajo de contenedor

Para crear un trabajo de contenedor con una GPU que use la imagen predeterminada mediante la API de Batch, usa el método jobs.create y especifica lo siguiente:

  • El tipo de máquina y la plataforma de GPU
  • Los campos volumes y options para activar la GPU en un trabajo de contenedor con la imagen predeterminada, como se muestra en este ejemplo.

Por ejemplo, para crear un trabajo de contenedor con una GPU, realiza la siguiente solicitud:

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

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "container": {
                            "volumes": [
                                "/var/lib/nvidia/lib64:/usr/local/nvidia/lib64",
                                "/var/lib/nvidia/bin:/usr/local/nvidia/bin"
                            ],
                            "options": "--privileged",
                            "commands": [
                                "-c",
                                "echo Hello world from task ${BATCH_TASK_INDEX}."
                            ]
                        }
                    }
                ],
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE",
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    }
}

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto.
  • INSTALL_GPU_DRIVERS: Opcional Cuando se establece en true, Batch recupera los controladores necesarios para el tipo de GPU que especificas en el campo policy de una ubicación de terceros y los instala en tu nombre.
  • MACHINE_TYPE: Es el tipo de máquina para las VM de tu trabajo, que restringe el tipo de GPU que puedes usar. Para crear un trabajo con una GPU, este campo es obligatorio.
  • GPU_TYPE: Es el tipo de GPU. Puedes ver una lista de los tipos de GPU disponibles con el comando gcloud compute accelerator-types list. Para crear un trabajo con una GPU, este campo es obligatorio.
  • GPU_COUNT: Es la cantidad de GPU del tipo que especificaste en el campo type. Para crear un trabajo con una GPU, este campo es obligatorio.
  • ALLOWED_LOCATIONS: Opcional Las ubicaciones en las que se pueden ejecutar las instancias de VM para tu trabajo (por ejemplo, regions/us-central1, zones/us-central1-a permite la zona us-central1-a). Si especificas una ubicación permitida, debes seleccionar la región y, de forma opcional, una o más zonas. Las ubicaciones que elijas deben tener el tipo de GPU que deseas para este trabajo. Para obtener más información, consulta el campo de arreglo allowedLocations.

Agrega una GPU a un trabajo de secuencia de comandos

Para crear un trabajo de secuencia de comandos con una GPU que use la imagen predeterminada mediante la API de Batch, usa el método jobs.create y especifica los tipos de máquina y acelerador en el campo instances.

Por ejemplo, para crear un trabajo de secuencia de comandos con una GPU, realiza la siguiente solicitud:

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

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE",
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    }
}

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto.
  • INSTALL_GPU_DRIVERS: Opcional Cuando se establece en true, Batch recupera los controladores necesarios para el tipo de GPU que especificas en el campo policy de una ubicación de terceros y los instala en tu nombre.
  • MACHINE_TYPE: Es el tipo de máquina para las VM de tu trabajo, que restringe el tipo de GPU que puedes usar. Para crear un trabajo con una GPU, este campo es obligatorio.
  • GPU_TYPE: Es el tipo de GPU. Puedes ver una lista de los tipos de GPU disponibles con el comando gcloud compute accelerator-types list. Para crear un trabajo con una GPU, este campo es obligatorio.
  • GPU_COUNT: Es la cantidad de GPU del tipo que especificaste en el campo type. Para crear un trabajo con una GPU, este campo es obligatorio.
  • ALLOWED_LOCATIONS: Opcional Las ubicaciones en las que se pueden ejecutar las instancias de VM para tu trabajo (por ejemplo, regions/us-central1, zones/us-central1-a permite la zona us-central1-a). Si especificas una ubicación permitida, debes seleccionar la región y, de forma opcional, una o más zonas. Las ubicaciones que elijas deben tener el tipo de GPU que deseas para este trabajo. Para obtener más información, consulta el campo de arreglo allowedLocations.

Agrega una GPU a un trabajo de contenedor y secuencia de comandos

Para crear un trabajo de contenedor y secuencia de comandos con una GPU que use la imagen predeterminada mediante la API de Batch, usa el método jobs.create y especifica lo siguiente:

  • El tipo de máquina y la plataforma de GPU
  • El campo text para cada secuencia de comandos que se puede ejecutar y los campos imageUri y options para cada contenedor ejecutable, a fin de activar la GPU en un trabajo de contenedor y secuencia de comandos con la imagen predeterminada, como se muestra en este ejemplo

Por ejemplo, para crear un trabajo de contenedor y secuencia de comandos con una GPU, realiza la siguiente solicitud:

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

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text":
                                "distribution=$(. /etc/os-release;echo $ID$VERSION_ID);
                                curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -;
                                curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list;
                                sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit;
                                sudo systemctl restart docker"
                        }
                    },
                    {
                        "container": {
                            "imageUri": "gcr.io/google_containers/cuda-vector-add:v0.1",
                            "options": "--gpus all"
                        }
                    },
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE",
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    }
}

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto.
  • INSTALL_GPU_DRIVERS: Opcional Cuando se establece en true, Batch recupera los controladores necesarios para el tipo de GPU que especificas en el campo policy de una ubicación de terceros y los instala en tu nombre.
  • MACHINE_TYPE: Es el tipo de máquina para las VM de tu trabajo, que restringe el tipo de GPU que puedes usar. Para crear un trabajo con una GPU, este campo es obligatorio.
  • GPU_TYPE: Es el tipo de GPU. Puedes ver una lista de los tipos de GPU disponibles con el comando gcloud compute accelerator-types list. Para crear un trabajo con una GPU, este campo es obligatorio.
  • GPU_COUNT: Es la cantidad de GPU del tipo que especificaste en el campo type. Para crear un trabajo con una GPU, este campo es obligatorio.
  • ALLOWED_LOCATIONS: Opcional Las ubicaciones en las que se pueden ejecutar las instancias de VM para tu trabajo (por ejemplo, regions/us-central1, zones/us-central1-a permite la zona us-central1-a). Si especificas una ubicación permitida, debes seleccionar la región y, de forma opcional, una o más zonas. Las ubicaciones que elijas deben tener el tipo de GPU que deseas para este trabajo. Para obtener más información, consulta el campo de arreglo allowedLocations.

Crea un trabajo que use volúmenes de almacenamiento

De forma predeterminada, cada VM de Compute Engine para un trabajo tiene un solo disco persistente de arranque que contiene el sistema operativo. De manera opcional, puedes crear un trabajo que use volúmenes de almacenamiento adicionales. En particular, las VM de un trabajo pueden usar uno o más de los siguientes tipos de volúmenes de almacenamiento. Para obtener más información sobre todos los tipos de volúmenes de almacenamiento y las diferencias y restricciones de cada uno, consulta la documentación sobre las opciones de almacenamiento de VM de Compute Engine.

Puedes permitir que un trabajo use cada volumen de almacenamiento si lo incluyes en la definición de tu trabajo y especificas su ruta de activación (mountPath) en los ejecutables. Para obtener información sobre cómo crear un trabajo que use volúmenes de almacenamiento, consulta una o más de las siguientes secciones:

Usar un disco persistente

Un trabajo que usa discos persistentes tiene las siguientes restricciones:

  • Todos los discos persistentes: Revisa las restricciones para todos los discos persistentes.
  • Plantillas de instancias: si deseas especificar una plantilla de instancias mientras creas este trabajo, debes adjuntar cualquier disco persistente para este trabajo en la plantilla de instancias. De lo contrario, si no quieres usar una plantilla de instancias, debes conectar los discos persistentes directamente en la definición del trabajo.
  • Discos persistentes nuevos y existentes: Cada disco persistente en un trabajo puede ser nuevo (definido en el trabajo y creado con él) o existente (ya creado en tu proyecto y especificado en el trabajo). Las opciones de activación compatibles con las que Batch activa los discos persistentes en las VM del trabajo y las opciones de ubicación compatibles para tu trabajo y sus discos persistentes varían entre los discos persistentes nuevos y existentes, como se describe en la siguiente tabla:

    Nuevos discos persistentes Discos persistentes existentes
    Opciones de montaje Todas las opciones son compatibles. Se admiten todas las opciones excepto la escritura. Esto se debe a las restricciones del modo de escritura múltiple.
    Opciones de ubicación

    Solo puedes crear discos persistentes zonales.

    Puedes seleccionar cualquier ubicación para tu trabajo. Los discos persistentes se crean en la zona en la que se ejecuta tu proyecto.

    Puedes seleccionar discos persistentes zonales y regionales.

    Debes establecer la ubicación del trabajo (o, si se especifica, solo las ubicaciones permitidas del trabajo) en solo las ubicaciones que contienen todos los discos persistentes del trabajo. Por ejemplo, para un disco persistente zonal, la ubicación del trabajo debe ser la zona del disco; para un disco persistente regional, la ubicación del trabajo debe ser la región del disco o, si se especifican, una o ambas zonas específicas en las que se encuentra el disco persistente regional.

Puedes crear un trabajo que use un disco persistente mediante la CLI de gcloud o la API de Batch. En el siguiente ejemplo, se describe cómo crear un trabajo que conecta y activa un disco persistente existente y un disco persistente nuevo. El trabajo también tiene 3 tareas que ejecutan una secuencia de comandos para crear un archivo en el disco persistente nuevo llamado output_task_TASK_INDEX.txt, en el que TASK_INDEX es el índice de cada tarea: 0, 1 y 2.

gcloud

Para crear un trabajo que use discos persistentes mediante la CLI de gcloud, usa el comando gcloud batch jobs submit. En el archivo de configuración JSON del trabajo, especifica los discos persistentes en el campo instances y activa el disco persistente en el campo volumes.

  1. Crea un archivo JSON.

    • Si no usas una plantilla de instancias para este trabajo, crea un archivo JSON con el siguiente contenido:

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

      Reemplaza lo siguiente:

      • PROJECT_ID: Es el ID del proyecto.
      • EXISTING_PERSISTENT_DISK_NAME: Es el nombre de un disco persistente existente.
      • EXISTING_PERSISTENT_DISK_LOCATION: Es la ubicación de un disco persistente existente. Para cada disco persistente zonal existente, la ubicación del trabajo debe ser la zona del disco; para cada disco persistente regional existente, la ubicación del trabajo debe ser la región del disco o, si se especifican las zonas, una o ambas zonas específicas en las que se encuentra el disco persistente regional. Si no especificas ningún disco persistente existente, puedes seleccionar cualquier ubicación. Obtén más información sobre el campo allowedLocations.
      • NEW_PERSISTENT_DISK_SIZE: Es el tamaño del disco persistente nuevo en GB. Los tamaños permitidos dependen del tipo de disco persistente, pero el mínimo suele ser de 10 GB (10) y el máximo, de 64 TB (64000).
      • NEW_PERSISTENT_DISK_TYPE: Es el tipo de disco del disco persistente nuevo, pd-standard, pd-balanced, pd-ssd o pd-extreme.
      • NEW_PERSISTENT_DISK_NAME: Es el nombre del disco persistente nuevo.
    • Si usas una plantilla de instancias para este trabajo, crea un archivo JSON como se mostró antes, excepto que reemplaces el campo instances con lo siguiente:

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

      en el que INSTANCE_TEMPLATE_NAME es el nombre de la plantilla de instancias para este trabajo. Para un trabajo que usa discos persistentes, esta plantilla de instancias debe definir y adjuntar los discos persistentes que deseas que use el trabajo. Para este ejemplo, la plantilla debe definir y adjuntar un disco persistente nuevo llamado NEW_PERSISTENT_DISK_NAME y, luego, adjuntar un disco persistente existente llamado EXISTING_PERSISTENT_DISK_NAME.

  2. Ejecute el siguiente comando:

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

    Reemplaza lo siguiente:

    • JOB_NAME: Es el nombre del trabajo.
    • LOCATION: Es la ubicación del trabajo.
    • JSON_CONFIGURATION_FILE: Es la ruta de acceso de un archivo JSON con los detalles de configuración del trabajo.

API

Para crear un trabajo que use discos persistentes mediante la API de Batch, usa el método jobs.create. En la solicitud, especifica los discos persistentes en el campo instances y activa el disco persistente en el campo volumes.

  • Si no usas una plantilla de instancias para este trabajo, realiza la siguiente solicitud:

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

    Reemplaza lo siguiente:

    • PROJECT_ID: Es el ID del proyecto.
    • LOCATION: Es la ubicación del trabajo.
    • JOB_NAME: Es el nombre del trabajo.
    • EXISTING_PERSISTENT_DISK_NAME: Es el nombre de un disco persistente existente.
    • EXISTING_PERSISTENT_DISK_LOCATION: Es la ubicación de un disco persistente existente. Para cada disco persistente zonal existente, la ubicación del trabajo debe ser la zona del disco; para cada disco persistente regional existente, la ubicación del trabajo debe ser la región del disco o, si se especifican las zonas, una o ambas zonas específicas en las que se encuentra el disco persistente regional. Si no especificas ningún disco persistente existente, puedes seleccionar cualquier ubicación. Obtén más información sobre el campo allowedLocations.
    • NEW_PERSISTENT_DISK_SIZE: Es el tamaño del disco persistente nuevo en GB. Los tamaños permitidos dependen del tipo de disco persistente, pero el mínimo suele ser de 10 GB (10) y el máximo, de 64 TB (64000).
    • NEW_PERSISTENT_DISK_TYPE: Es el tipo de disco del disco persistente nuevo, pd-standard, pd-balanced, pd-ssd o pd-extreme.
    • NEW_PERSISTENT_DISK_NAME: Es el nombre del disco persistente nuevo.
  • Si usas una plantilla de instancias para este trabajo, crea un archivo JSON como se mostró antes, excepto que reemplaces el campo instances con lo siguiente:

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

    en el que INSTANCE_TEMPLATE_NAME es el nombre de la plantilla de instancias para este trabajo. Para un trabajo que usa discos persistentes, esta plantilla de instancias debe definir y adjuntar los discos persistentes que deseas que use el trabajo. Para este ejemplo, la plantilla debe definir y adjuntar un disco persistente nuevo llamado NEW_PERSISTENT_DISK_NAME y, luego, adjuntar un disco persistente existente llamado EXISTING_PERSISTENT_DISK_NAME.

Usar un SSD local

Un trabajo que usa SSD locales tiene las siguientes restricciones:

Puedes crear un trabajo que use un SSD local con la CLI de gcloud o la API de Batch. En el siguiente ejemplo, se describe cómo crear un trabajo que crea, adjunta y activa un SSD local. El trabajo también tiene 3 tareas que ejecutan una secuencia de comandos para crear un archivo en el SSD local llamado output_task_TASK_INDEX.txt, en el que TASK_INDEX es el índice de cada tarea: 0, 1 y 2.

gcloud

Para crear un trabajo que use SSD locales con la CLI de gcloud, usa el comando gcloud batch jobs submit. En el archivo de configuración JSON del trabajo, crea y adjunta los SSD locales en el campo instances y activa los SSD locales en el campo volumes.

  1. Crea un archivo JSON.

    • Si no usas una plantilla de instancias para este trabajo, crea un archivo JSON con el siguiente contenido:

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

      Reemplaza lo siguiente:

      • MACHINE_TYPE: Es el tipo de máquina de las VM del trabajo. La cantidad permitida de SSD locales depende del tipo de máquina para las VM de tu trabajo.
      • LOCAL_SSD_NAME: Es el nombre de un SSD local creado para este trabajo.
      • LOCAL_SSD_SIZE: Es el tamaño de todos los SSD locales en GB. Cada SSD local es de 375 GB, por lo que este valor debe ser un múltiplo de 375 GB. Por ejemplo, para 2 SSD locales, establece este valor en 750 GB.
    • Si usas una plantilla de instancias para este trabajo, crea un archivo JSON como se mostró antes, excepto que reemplaces el campo instances con lo siguiente:

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

      en el que INSTANCE_TEMPLATE_NAME es el nombre de la plantilla de instancias para este trabajo. Para un trabajo que usa SSD locales, esta plantilla de instancias debe definir y adjuntar los SSD locales que deseas que use el trabajo. Para este ejemplo, la plantilla debe definir y adjuntar un SSD local llamado LOCAL_SSD_NAME.

  2. Ejecute el siguiente comando:

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

    Reemplaza lo siguiente:

    • JOB_NAME: Es el nombre del trabajo.
    • LOCATION: Es la ubicación del trabajo.
    • JSON_CONFIGURATION_FILE: Es la ruta de acceso de un archivo JSON con los detalles de configuración del trabajo.

API

Para crear un trabajo que use SSD locales con la API de Batch, usa el método jobs.create. En la solicitud, crea y adjunta los SSD locales en el campo instances y activa los SSD locales en el campo volumes.

  • Si no usas una plantilla de instancias para este trabajo, realiza la siguiente solicitud:

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

    Reemplaza lo siguiente:

    • PROJECT_ID: Es el ID del proyecto.
    • LOCATION: Es la ubicación del trabajo.
    • JOB_NAME: Es el nombre del trabajo.
    • MACHINE_TYPE: Es el tipo de máquina de las VM del trabajo. La cantidad permitida de SSD locales depende del tipo de máquina para las VM de tu trabajo.
    • LOCAL_SSD_NAME: Es el nombre de un SSD local creado para este trabajo.
    • LOCAL_SSD_SIZE: Es el tamaño de todos los SSD locales en GB. Cada SSD local es de 375 GB, por lo que este valor debe ser un múltiplo de 375 GB. Por ejemplo, para 2 SSD locales, establece este valor en 750 GB.
  • Si usas una plantilla de instancias para este trabajo, crea un archivo JSON como se mostró antes, excepto que reemplaces el campo instances con lo siguiente:

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

    en el que INSTANCE_TEMPLATE_NAME es el nombre de la plantilla de instancias para este trabajo. Para un trabajo que usa SSD locales, esta plantilla de instancias debe definir y adjuntar los SSD locales que deseas que use el trabajo. Para este ejemplo, la plantilla debe definir y adjuntar un SSD local llamado LOCAL_SSD_NAME.

Usa un bucket de Cloud Storage

Para crear un trabajo que use un bucket de Cloud Storage existente, selecciona uno de los siguientes métodos:

  • Activa un bucket directamente en el entorno de procesamiento de tu trabajo, como se muestra en esta sección.
  • Crea un trabajo básico con tareas que accedan directamente a Cloud Storage, como a través de bibliotecas cliente.

Antes de crear un trabajo que use un bucket, crea un bucket o identifica un bucket existente. Para obtener más información, consulta Crea depósitos de almacenamiento y Enumera depósitos.

Puedes crear un trabajo que use un bucket de Cloud Storage mediante la CLI de gcloud o la API de Batch.

En el siguiente ejemplo, se describe cómo crear un trabajo para activar un bucket de Cloud Storage. El trabajo también tiene 3 tareas que ejecutan una secuencia de comandos para crear un archivo en el bucket llamado output_task_TASK_INDEX.txt, en el que TASK_INDEX es el índice de cada tarea: 0, 1 y 2.

gcloud

Para crear un trabajo que use un depósito de Cloud Storage mediante gcloud CLI, usa el comando gcloud batch jobs submit. En el archivo de configuración JSON del trabajo, activa el bucket en el campo volumes.

Por ejemplo, para crear un trabajo que genere archivos en Cloud Storage, haz lo siguiente:

  1. Crea un archivo JSON en el directorio actual llamado hello-world-bucket.json con el siguiente contenido: json { "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" } } Reemplaza lo siguiente:
  • BUCKET_PATH: Es la ruta del directorio del bucket al que deseas que acceda este trabajo, que debe comenzar con el nombre del bucket. Por ejemplo, para un bucket llamado BUCKET_NAME, la ruta BUCKET_NAME representa el directorio raíz del bucket y la ruta BUCKET_NAME/subdirectory representa el subdirectorio subdirectory.
  • MOUNT_PATH: Es la ruta de acceso de activación que usan los objetos ejecutables del trabajo para acceder a este bucket. La ruta debe comenzar con /mnt/disks/ seguido de un directorio o una ruta de acceso que elijas. Por ejemplo, si deseas representar este bucket con un directorio llamado my-bucket, establece la ruta de acceso de activación en /mnt/disks/my-bucket.
  1. Ejecute el siguiente comando:

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

API

Para crear un trabajo que use un bucket de Cloud Storage mediante la API de Batch, usa el método jobs.create y activa el bucket en el campo volumes.

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

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

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto.
  • BUCKET_PATH: Es la ruta del directorio del bucket al que deseas que acceda este trabajo, que debe comenzar con el nombre del bucket. Por ejemplo, para un bucket llamado BUCKET_NAME, la ruta BUCKET_NAME representa el directorio raíz del bucket y la ruta BUCKET_NAME/subdirectory representa el subdirectorio subdirectory.
  • MOUNT_PATH: Es la ruta de acceso de activación que usan los objetos ejecutables del trabajo para acceder a este bucket. La ruta debe comenzar con /mnt/disks/ seguido de un directorio o una ruta de acceso que elijas. Por ejemplo, si deseas representar este bucket con un directorio llamado my-bucket, establece la ruta de acceso de activación en /mnt/disks/my-bucket.

Cómo usar un sistema de archivos de red

Puedes crear un trabajo que use un sistema de archivos de red (NFS) existente, como un archivo compartido de Filestore, con la CLI de gcloud o la API de Batch.

Antes de crear un trabajo que use un NFS, asegúrate de que el firewall de la red esté configurado de forma correcta para permitir el tráfico entre las VM de tu trabajo y el NFS. Si deseas obtener más información, consulta Configura reglas de firewall para Filestore.

En el siguiente ejemplo, se describe cómo crear un trabajo que especifica y activa un NFS. El trabajo también tiene 3 tareas que ejecutan una secuencia de comandos para crear un archivo en el NFS llamado output_task_TASK_INDEX.txt, en el que TASK_INDEX es el índice de cada tarea: 0, 1 y 2.

gcloud

Para crear un trabajo que use un NFS con la CLI de gcloud, usa el comando gcloud batch jobs submit. En el archivo de configuración JSON del trabajo, activa el NFS en el campo volumes.

  1. Crea un archivo JSON con el siguiente contenido:

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

    Reemplaza lo siguiente:

    • NFS_IP_ADDRESS: Es la dirección IP del NFS. Por ejemplo, si tu NFS es un archivo compartido de Filestore, especifica la dirección IP de la VM que aloja el archivo compartido de Filestore, que puedes obtener mediante la descripción de la VM de Filestore.
    • NFS_PATH: Es la ruta de acceso del directorio NFS al que deseas que acceda este trabajo, que debe comenzar con un / seguido del directorio raíz del NFS. Por ejemplo, para un archivo compartido de Filestore llamado FILE_SHARE_NAME, la ruta /FILE_SHARE_NAME representa el directorio raíz del archivo compartido, y la ruta /FILE_SHARE_NAME/subdirectory representa el subdirectorio subdirectory.
    • MOUNT_PATH: Es la ruta de acceso de activación que usan los objetos ejecutables del trabajo para acceder a este NFS. La ruta debe comenzar con /mnt/disks/ seguido de un directorio o una ruta de acceso que elijas. Por ejemplo, si deseas representar este NFS con un directorio llamado my-nfs, establece la ruta de activación en /mnt/disks/my-nfs.
  2. Ejecute el siguiente comando:

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

    Reemplaza lo siguiente:

    • JOB_NAME: Es el nombre del trabajo.
    • LOCATION: Es la ubicación del trabajo.
    • JSON_CONFIGURATION_FILE: Es la ruta de acceso de un archivo JSON con los detalles de configuración del trabajo.

API

Para crear un trabajo que use un NFS mediante la API de Batch, usa el método jobs.create y activa NFS en el 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"
    }
}

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto.
  • LOCATION: Es la ubicación del trabajo.
  • JOB_NAME: Es el nombre del trabajo.
  • NFS_IP_ADDRESS: Es la dirección IP del sistema de archivos de red. Por ejemplo, si tu NFS es un archivo compartido de Filestore, especifica la dirección IP de la VM que aloja el archivo compartido de Filestore, que puedes obtener mediante la descripción de la VM de Filestore.
  • NFS_PATH: Es la ruta de acceso del directorio NFS al que deseas que acceda este trabajo, que debe comenzar con un / seguido del directorio raíz del NFS. Por ejemplo, para un archivo compartido de Filestore llamado FILE_SHARE_NAME, la ruta /FILE_SHARE_NAME representa el directorio raíz del archivo compartido, y la ruta /FILE_SHARE_NAME/subdirectory representa un subdirectorio.
  • MOUNT_PATH: Es la ruta de acceso de activación que usan los objetos ejecutables del trabajo para acceder a este NFS. La ruta debe comenzar con /mnt/disks/ seguido de un directorio o una ruta de acceso que elijas. Por ejemplo, si deseas representar este NFS con un directorio llamado my-nfs, establece la ruta de activación en /mnt/disks/my-nfs.

¿Qué sigue?