创建和运行作业

使用集合让一切井井有条 根据您的偏好保存内容并对其进行分类。

本页面介绍如何通过创建批处理作业,在 Google Cloud 上运行批处理工作负载。

创建作业以指定工作负载及其要求。当您完成作业创建后,Google Cloud 会自动排队、安排和执行该作业。根据资源可用性相关因素,作业完成运行所需的时间会因作业而异,并且时间也有所不同。通常,如果作业较小且只需要少量通用资源,则作业更有可能运行并更快地完成。对于本页面上所述的使用极少资源作业的示例作业,您可能会看到它们在几分钟内完成运行。

您可以通过以下选项创建作业:

  • 创建基本作业介绍了基本操作,包括如何使用脚本或容器映像定义作业的任务。
  • 创建使用环境变量的作业介绍了如何访问和使用 Batch 预定义环境变量或在作业资源中定义的环境变量。
  • 可选:基于 Compute Engine 实例模板创建作业,介绍如何指定实例模板来定义作业的资源。如果您的作业需要使用特定虚拟机映像或自定义机器类型,则必须提供实例模板。
  • 可选:使用自定义服务帐号创建作业介绍如何指定作业的服务帐号,这会影响作业的虚拟机可以访问的资源和应用。
  • 可选:创建一个使用 MPI 执行紧密耦合任务的作业介绍了如何使用消息传递接口 (MPI) 库跨不同虚拟机相互通信的相互独立配置作业。MPI 的一个常见使用场景是紧密耦合高性能计算 (HPC) 工作负载。
  • 可选:创建使用 GPU 的作业介绍了如何定义使用图形处理单元 (GPU) 的作业。使用 GPU 的作业的常见使用场景包括密集型数据处理或机器学习 (ML) 工作负载。
  • 可选:创建使用存储卷的作业介绍了如何定义可以访问一个或多个外部存储卷的作业。存储选项包括新的或现有的永久性磁盘、新的本地 SSD、现有的 Cloud Storage 存储分区和现有的网络文件系统 (NFS),例如 Filestore 文件共享。

准备工作

  • 如果您之前未使用过 Batch,请查看开始使用 Batch,然后完成项目和用户需满足的前提条件以启用 Batch。
  • 如需获取创建作业所需的权限,请让管理员授予您以下 IAM 角色:

    • 项目的批量作业编辑器 (roles/batch.jobsEditor)
    • 作业的服务帐号上的服务帐号用户 (roles/iam.serviceAccountUser),默认情况下为默认 Compute Engine 服务帐号
    • 基于 Compute Engine 实例模板创建作业:对实例模板使用 Compute Viewer (roles/compute.viewer)
    • 创建一个使用 Cloud Storage 存储桶的作业:Cloud Storage 存储桶的 Storage Object Viewer (roles/storage.objectViewer)

    如需详细了解如何授予角色,请参阅管理访问权限

创建基本作业

本部分介绍如何创建运行脚本或容器映像的示例作业:

  • 如果要使用 Batch 编写使用容器映像的作业,请参阅创建容器作业
  • 或者,如果您不确定是否要使用容器映像,或者不熟悉容器,建议您创建脚本作业

这两种类型的作业的示例作业都有一个包含 4 个任务的数组的任务组。每个任务都会将一条消息及其索引输出到标准输出和 Cloud Logging。此作业的定义将并行性指定为 2,这表示该作业应在 2 个虚拟机上运行,以允许同时运行 2 个任务。

创建基本容器作业

您可以选择或创建容器映像,以提供作业的代码和依赖项,以便作业可以从任何计算环境运行。 如需了解详情,请参阅使用容器映像在虚拟机实例上运行容器

您可以使用 Google Cloud 控制台、gcloud CLI、Batch API、Go、Java、Node.js 或 Python 创建基本容器作业。

控制台

如需使用 Google Cloud 控制台创建基本容器作业,请执行以下操作:

  1. 在 Google Cloud 控制台中,转到作业列表页面。

    转到作业列表

  2. 点击 创建。此时会打开创建批量作业页面。

  3. 作业名称字段中,输入作业名称。

    例如,输入 example-basic-job

  4. 区域字段中,为此作业选择位置

    例如,选择 us-central1(默认值)。

  5. 对于虚拟机预配模型,为此作业的虚拟机选择一个预配模型选项:

    • 如果您的作业可以承受抢占,并且您需要折扣虚拟机,请选择 Spot
    • 否则,请选择标准

    例如,选择标准(默认值)。

  6. 任务数字段中,输入此作业的任务数。该值必须是介于 110000 之间的整数。

    例如,输入 4

  7. 并行处理字段中,输入要同时运行的任务数量。该数字不能大于任务总数,并且必须是 11000 之间的整数。

    例如,输入 2

  8. 对于任务详情,选择容器映像网址(默认)。

  9. 容器映像网址字段中,输入容器映像。

    例如,输入以下内容以使用 busybox Docker 容器映像

    gcr.io/google-containers/busybox
    
  10. 可选:要替换容器映像的 ENTRYPOINT 命令,请在入口点字段中输入一个新命令。

    例如,输入以下内容:

    /bin/sh
    
  11. 可选:如需替换容器映像的 CMD 命令,请选中替换容器映像的 CMD 命令复选框,然后在显示的字段中输入一个或多个命令,每个命令各占一行。

    例如,选中替换容器映像的 CMD 命令复选框并输入以下命令:

    -c
    echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.
    
  12. 对于任务资源,请指定每个任务所需的虚拟机资源数量:在核心字段中,输入 vCPU 的数量,然后在内存字段中,输入 RAM 量(以 GB 为单位)。

    例如,输入 1 个 vCPU(默认)和 0.5 GB(默认)。

  13. 点击创建

作业列表页面会显示您创建的作业。

gcloud

如需使用 gcloud CLI 创建基本容器作业,请执行以下操作:

  1. 创建一个用于指定作业的配置详情的 JSON 文件。例如,如需创建基本容器作业,请创建包含以下内容的 JSON 文件。如需详细了解您可以为作业指定的所有字段,请参阅 projects.locations.jobs REST 资源的参考文档。

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

    请替换以下内容:

    • CONTAINER:每个任务运行的容器
    • CORES:可选。要为每个任务分配的核心(具体来说,就是 vCPU)的数量,通常代表半个物理核心,单位为毫单位。如果未指定 cpuMilli 字段,则将该值设置为 2000(2 个 vCPU)。
    • MEMORY:可选。要为每个任务分配的内存量(以 MB 为单位)。如果未指定 memoryMib 字段,则将该值设置为 2000 (2 GB)。
    • MAX_RETRY_COUNT:可选。任务的重试次数上限。该值必须是介于 010 之间的整数。如果未指定 maxRetryCount 字段,则将该值设置为 0,这意味着不重试任务。
    • MAX_RUN_DURATION:可选。允许任务在重试或失败之前运行的最长时间,格式为以秒为单位,后跟一个 s。如果未指定 maxRunDuration 字段,则将该值设置为 604800s(7 天),这是最大值。
    • TASK_COUNT:可选。作业的任务数。该值必须是介于 110000 之间的整数。如果未指定 taskCount 字段,则将其设置为 1
    • PARALLELISM:可选。作业并发运行的任务数。该数字不能大于任务数,并且必须是 11000 之间的整数。如果未指定 parallelism 字段,则将该值设置为 1
  2. 使用 gcloud batch jobs submit 命令创建作业。

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

    请替换以下内容:

    • JOB_NAME:作业的名称。
    • LOCATION:作业的位置
    • JSON_CONFIGURATION_FILE:包含作业配置详细信息的 JSON 文件的路径。

例如,如需创建使用 busybox Docker 容器映像运行任务的作业,请执行以下操作:

  1. 在当前目录中创建一个名为 hello-world-container.json 且包含以下内容的 JSON 文件:

    {
        "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. 运行以下命令:

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

API

如需使用 Batch API 创建基本容器作业,请使用 jobs.create 方法。如需详细了解可为作业指定的所有字段,请参阅 projects.locations.jobs REST 资源的参考文档。

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

请替换以下内容:

  • PROJECT_ID:项目的项目 ID
  • LOCATION:作业的位置
  • JOB_NAME:作业的名称。
  • CONTAINER:每个任务运行的容器
  • CORES:可选。要为每个任务分配的核心(具体来说,就是 vCPU)的数量,该数量通常表示物理核心的一半。如果未指定 cpuMilli 字段,则将该值设置为 2000(2 个 vCPU)。
  • MEMORY:可选。要为每个任务分配的内存量(以 MB 为单位)。如果未指定 memoryMib 字段,则将该值设置为 2000 (2 GB)。
  • MAX_RETRY_COUNT:可选。任务的重试次数上限。该值必须是介于 010 之间的整数。如果未指定 maxRetryCount 字段,则值设置为 0,这意味着不重试任务。
  • MAX_RUN_DURATION:可选。允许任务在重试或失败之前运行的最长时间,格式为以秒为单位,后跟一个 s。如果未指定 maxRunDuration 字段,则将该值设置为 604800s(7 天),这是最大值。
  • TASK_COUNT:可选。作业的任务数,必须是 110000 之间的整数。如果未指定 taskCount 字段,则将该值设置为 1
  • PARALLELISM:可选。此作业并发运行的任务数。该数字不能大于任务数,并且必须是 11000 之间的整数。如果未指定 parallelism 字段,则将该值设置为 1

例如,如需创建一个使用 busybox Docker 容器映像运行任务的作业,请使用以下请求:

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

其中 PROJECT_ID 是项目的项目 ID

Go

Go

如需了解详情,请参阅 Batch Go API 参考文档

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

如需了解详情,请参阅 Batch Java API 参考文档


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

如需了解详情,请参阅 Batch Node.js API 参考文档

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

如需了解详情,请参阅 Batch Python API 参考文档

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)

创建基本脚本作业

您可以使用 Google Cloud 控制台、gcloud CLI、Batch API、Go、Java、Node.js 或 Python 创建基本脚本作业。

控制台

如需使用 Google Cloud 控制台创建基本脚本作业,请执行以下操作:

  1. 在 Google Cloud 控制台中,转到作业列表页面。

    转到作业列表

  2. 点击 创建。此时会打开创建批量作业页面。

  3. 作业名称字段中,输入作业名称。

    例如,输入 example-basic-job

  4. 区域字段中,为此作业选择位置

    例如,选择 us-central1(默认值)。

  5. 对于虚拟机预配模型,为此作业的虚拟机选择一个预配模型选项:

    • 如果您的作业可以承受抢占,并且您需要折扣虚拟机,请选择 Spot
    • 否则,请选择标准

    例如,选择标准(默认值)。

  6. 任务数字段中,输入此作业的任务数。该值必须是介于 110000 之间的整数。

    例如,输入 4

  7. 并行处理字段中,输入要同时运行的任务数量。该数字不能大于任务总数,并且必须是 11000 之间的整数。

    例如,输入 2

  8. 对于任务详细信息,选择脚本

    然后,在显示的字段中输入要为每个任务运行的脚本。

    例如,使用以下脚本:

    echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.
    
  9. 对于任务资源,请指定每个任务所需的虚拟机资源数量:在核心字段中,输入 vCPU 的数量,然后在内存字段中,输入 RAM 量(以 GB 为单位)。

    例如,输入 1 个 vCPU(默认)和 0.5 GB(默认)。

  10. 点击创建

作业列表页面会显示您创建的作业。

gcloud

如需使用 gcloud CLI 创建基本脚本作业,请执行以下操作:

  1. 创建一个用于指定作业的配置详情的 JSON 文件。例如,如需创建基本脚本作业,请创建包含以下内容的 JSON 文件。如需详细了解您可以为作业指定的所有字段,请参阅 projects.locations.jobs REST 资源的参考文档。

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

    请替换以下内容:

    • SCRIPT:每个任务运行的脚本
    • CORES:可选。要为每个任务分配的核心(具体来说,就是 vCPU)的数量,通常代表半个物理核心,单位为毫单位。如果未指定 cpuMilli 字段,则将该值设置为 2000(2 个 vCPU)。
    • MEMORY:可选。要为每个任务分配的内存量(以 MB 为单位)。如果未指定 memoryMib 字段,则将该值设置为 2000 (2 GB)。
    • MAX_RETRY_COUNT:可选。任务的重试次数上限。该值必须是介于 010 之间的整数。如果未指定 maxRetryCount 字段,则将该值设置为 0,这意味着不重试任务。
    • MAX_RUN_DURATION:可选。允许任务在重试或失败之前运行的最长时间,格式为以秒为单位,后跟一个 s。如果未指定 maxRunDuration 字段,则将该值设置为 604800s(7 天),这是最大值。
    • TASK_COUNT:可选。作业的任务数。该值必须是介于 110000 之间的整数。如果未指定 taskCount 字段,则将其设置为 1
    • PARALLELISM:可选。作业并发运行的任务数。该数字不能大于任务数,并且必须是 11000 之间的整数。如果未指定 parallelism 字段,则将该值设置为 1
  2. 使用 gcloud batch jobs submit 命令创建作业。

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

    请替换以下内容:

    • JOB_NAME:作业的名称。
    • LOCATION:作业的位置
    • JSON_CONFIGURATION_FILE:包含作业配置详细信息的 JSON 文件的路径。

例如,如需创建使用脚本运行任务的作业,请运行以下命令:

  1. 在当前目录中创建一个名为 hello-world-script.json 且包含以下内容的 JSON 文件:

    {
        "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. 运行以下命令:

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

API

如需使用 Batch API 创建基本脚本作业,请使用 jobs.create 方法。如需详细了解可为作业指定的所有字段,请参阅 projects.locations.jobs REST 资源的参考文档。

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

请替换以下内容:

  • PROJECT_ID:项目的项目 ID
  • LOCATION:作业的位置
  • JOB_NAME:作业的名称。
  • SCRIPT:每个任务运行的脚本
  • CORES:可选。要为每个任务分配的核心(具体来说,就是 vCPU)的数量,该数量通常表示物理核心的一半。如果未指定 cpuMilli 字段,则将该值设置为 2000(2 个 vCPU)。
  • MEMORY:可选。要为每个任务分配的内存量(以 MB 为单位)。如果未指定 memoryMib 字段,则将该值设置为 2000 (2 GB)。
  • MAX_RETRY_COUNT:可选。任务的重试次数上限。该值必须是介于 010 之间的整数。如果未指定 maxRetryCount 字段,则值设置为 0,这意味着不重试任务。
  • MAX_RUN_DURATION:可选。允许任务在重试或失败之前运行的最长时间,格式为以秒为单位,后跟一个 s。如果未指定 maxRunDuration 字段,则将该值设置为 604800s(7 天),这是最大值。
  • TASK_COUNT:可选。作业的任务数。该值必须是介于 110000 之间的整数。如果未指定 taskCount 字段,则将该值设置为 1
  • PARALLELISM:可选。此作业并发运行的任务数。该数字不能大于任务数,并且必须是 11000 之间的整数。如果未指定 parallelism 字段,则将该值设置为 1

例如,如需创建使用脚本运行任务的作业,请使用以下请求:

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

其中 PROJECT_ID 是项目的项目 ID

Go

Go

如需了解详情,请参阅 Batch Go API 参考文档

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

如需了解详情,请参阅 Batch Java API 参考文档


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

如需了解详情,请参阅 Batch Node.js API 参考文档

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

如需了解详情,请参阅 Batch Python API 参考文档

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)

创建使用环境变量的作业

您可以在作业的资源中定义环境变量,并在作业的可运行对象中使用它们。

默认情况下,作业中的可运行对象可以使用以下环境变量:

  • BATCH_TASK_COUNT:一个任务组中的任务数。
  • BATCH_TASK_INDEX:任务组中任务的索引编号。索引编号从 0 开始。
  • BATCH_HOSTS_FILE:可选。列出任务组中所有正在运行的虚拟机实例的文件路径。如需使用此环境变量,requireHostsFile 字段为必填字段,并且必须设置为 true。

(可选)您可以在作业的资源中定义自定义环境变量,并按以下方式使用:

  • 每个任务在一个可运行的环境中运行。
  • 在一个任务运行的所有可运行对象中。

本部分提供了有关如何创建两个作业在其资源中定义自定义环境变量的示例。第一个示例作业将环境变量传递给每个任务运行的可运行对象。第二个示例作业将一个环境变量数组(具有匹配名称但值不同)传递给任务,这些环境变量的索引与环境变量在数组中的索引匹配。

您可以使用 gcloud CLI 或 Batch API 为您的作业定义环境变量。

Glocud

如果您要定义将环境变量传递给每个任务运行的可运行作业的作业,请参阅有关如何为可运行对象定义和使用环境变量的示例。否则,如果您要定义根据任务索引将环境变量列表传递给不同任务的作业,请参阅有关如何为每个任务定义和使用环境变量的示例。

为可运行程序定义和使用环境变量

如需创建使用 gcloud CLI 将环境变量传递给可运行作业的作业,请使用 gcloud batch jobs submit 命令并在作业的配置文件中指定环境变量。

例如,如需创建一个脚本作业来定义环境变量,并将其传递给 3 项任务的脚本,请发出以下请求:

  1. 在当前目录中创建一个名为 hello-word-environment-variables.json 且包含以下内容的 JSON 文件:

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

    请替换以下内容:

    • VARIABLE_NAME:传递给每个任务的环境变量的名称。按照惯例,环境变量名称的首字母大写
    • VARIABLE_VALUE:可选。传递给每个任务的环境变量的值。
  2. 运行以下命令:

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

为每个任务定义和使用环境变量

如需使用 gcloud CLI 根据任务索引将环境变量传递给任务的作业,请使用 gcloud batch jobs submit 命令并在作业的配置文件中指定 taskEnvironments 数组字段。

例如,如需创建一个包含 3 个环境变量的数组(这些变量具有匹配名称和不同的值),并将这些环境变量传递给任务的脚本(这些脚本的索引与环境变量中的索引匹配),请执行以下操作:

  1. 在当前目录中创建一个名为 hello-word-task-environment-variables.json 且包含以下内容的 JSON 文件:

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

    请替换以下内容:

    • TASK_VARIABLE_NAME:传递给具有匹配索引的任务的环境变量的名称。按照惯例,环境变量名称的首字母大写
    • TASK_VARIABLE_VALUE_0:传递给任务的环境变量的值,其中 BATCH_TASK_INDEX 等于 0
    • TASK_VARIABLE_VALUE_1:传递给任务的环境变量的值,其中 BATCH_TASK_INDEX 等于 1
    • TASK_VARIABLE_VALUE_2:传递给任务的环境变量的值,其中 BATCH_TASK_INDEX 等于 2
  2. 运行以下命令:

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

API

如果您要定义将环境变量传递给每个任务运行的可运行作业的作业,请参阅有关如何为可运行对象定义和使用环境变量的示例。否则,如果您要定义根据任务索引将环境变量列表传递给不同任务的作业,请参阅有关如何为每个任务定义和使用环境变量的示例。

为可运行程序定义和使用环境变量

如需使用 Batch API 创建将环境变量传递给可运行作业的作业,请使用 gcloud batch jobs submit 命令并在 environment 字段中指定环境变量。

例如,如需创建包含环境变量的作业并将其传递给 3 项任务的脚本,请发出以下请求:

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

请替换以下内容:

  • PROJECT_ID:项目的项目 ID
  • VARIABLE_NAME:传递给每个任务的环境变量的名称。按照惯例,环境变量名称的首字母大写
  • VARIABLE_VALUE:传递给每个任务的环境变量的值。

为每个任务定义和使用环境变量

如需使用 Batch API 根据任务索引将环境变量传递给任务的作业,请使用 jobs.create 方法并在 taskEnvironments 数组字段中指定环境变量。

例如,如需创建一个包含 3 个环境变量的数组(这些变量具有匹配名称和不同的值),并根据这些变量的索引将任务传递给 3 个任务的脚本,请发出以下请求:

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

请替换以下内容:

  • PROJECT_ID:项目的项目 ID
  • TASK_VARIABLE_NAME:传递给具有匹配索引的任务的环境变量的名称。按照惯例,环境变量名称的首字母大写
  • TASK_VARIABLE_VALUE_0:传递给任务的环境变量的值,其中 BATCH_TASK_INDEX 等于 0
  • TASK_VARIABLE_VALUE_1:传递给任务的环境变量的值,其中 BATCH_TASK_INDEX 等于 1
  • TASK_VARIABLE_VALUE_2:传递给任务的环境变量的值,其中 BATCH_TASK_INDEX 等于 2

基于 Compute Engine 实例模板创建作业

(可选)您可以使用 Compute Engine 实例模板定义作业的资源。如需创建非默认虚拟机映像的作业或创建自定义机器类型的作业,必须执行此操作。

本部分介绍如何通过现有实例模板创建基本脚本作业。您可以使用 gcloud CLI 或 Batch API 基于实例模板创建作业。

gcloud

如需使用 gcloud CLI 根据实例模板创建作业,请使用 gcloud batch jobs submit 命令,并在作业的 JSON 配置文件中指定实例模板。

例如,如需通过实例模板创建基本脚本作业,请执行以下操作:

  1. 在当前目录中创建一个名为 hello-world-instance-template.json 且包含以下内容的 JSON 文件:

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

    请替换以下内容:

    • INSTALL_GPU_DRIVERS:可选。设置为 true 时,Batch 会获取并安装此作业所需的 GPU 驱动程序。
    • INSTALL_GPU_DRIVERS:可选。设置为 true 时,Batch 会提取您在 Compute Engine 实例模板中指定的 GPU 类型所需的驱动程序,然后 Batch 代表您安装这些驱动程序。如需了解详情,请参阅如何创建使用 GPU 的作业
    • INSTANCE_TEMPLATE_NAME:现有 Compute Engine 实例模板的名称。了解如何创建列出实例模板
  2. 运行以下命令:

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

API

如需使用 Batch API 创建基本作业,请使用 jobs.create 方法并在 allocationPolicy 字段中指定实例模板。

例如,如需通过实例模板创建基本脚本作业,请使用以下请求:

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

请替换以下内容:

  • PROJECT_ID:项目的项目 ID
  • INSTALL_GPU_DRIVERS:可选。设置为 true 时,Batch 会提取您在 Compute Engine 实例模板中指定的 GPU 类型所需的驱动程序,然后 Batch 代表您安装这些驱动程序。如需了解详情,请参阅如何创建使用 GPU 的作业
  • INSTANCE_TEMPLATE_NAME:现有 Compute Engine 实例模板的名称。了解如何创建列出实例模板

创建使用自定义服务帐号的作业

或者,您也可以创建使用自定义服务帐号(而不是默认的 Compute Engine 服务帐号)的作业。作业的服务帐号会影响作业的虚拟机可以访问哪些资源和应用。默认情况下,默认 Compute Engine 服务帐号会自动附加到所有虚拟机,因此使用自定义服务帐号可以更好地管理作业的权限,因此我们建议您采用最佳实践来限制权限。

在创建使用自定义服务帐号的作业之前,请确保计划使用的服务帐号具有为项目创建批量作业所需的权限。如需了解详情,请参阅为项目启用 Batch

如需创建使用自定义服务帐号的作业,请选择以下方法之一:

  • 在作业定义中指定自定义服务帐号,如本部分所示。
  • 使用 Compute Engine 实例模板,并在实例模板和作业定义中指定自定义服务帐号。

本部分举例说明了如何创建使用自定义服务帐号的作业。您可以使用 gcloud CLI 或 Batch API 创建使用自定义服务帐号的作业。

gcloud

如需使用 gcloud CLI 创建使用自定义服务帐号的作业,请使用 gcloud batch jobs submit 命令并在作业的配置文件中指定自定义服务帐号。

例如,如需创建使用自定义服务帐号的脚本作业,请运行以下命令:

  1. 在当前目录中创建一个名为 hello-world-service-account.json 且包含以下内容的 JSON 文件:

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

    其中,SERVICE_ACCOUNT_EMAIL 是您的服务帐号的电子邮件地址。如果未指定 serviceAccount 字段,则该值将设置为默认 Compute Engine 服务帐号

  2. 运行以下命令:

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

API

如需创建使用 Batch API 使用自定义服务帐号的作业,请使用 jobs.create 方法并在 allocationPolicy 字段中指定自定义服务帐号。

例如,如需创建使用自定义服务帐号的脚本作业,请发出以下请求:

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

请替换以下内容:

创建一个使用 MPI 执行紧密耦合任务的作业

(可选)您可以创建一个使用消息传递接口 (MPI) 库的作业,以便相互依赖的任务能够在不同虚拟机实例之间相互通信。

本部分提供了有关如何创建可以使用 MPI 的作业的示例。值得注意的是,示例作业有 3 个可运行的对象:

  • 第一个可运行程序是一个脚本,它通过停用并发多线程安装 Intel MPI 来为 MPI 准备作业。
  • 第二个可运行项是一个空的屏障可运行(格式为 { "barrier": {} }),它可确保所有任务都先完成 MPI 设置,然后再继续运行可运行项。
  • 第 3 个可运行(和任何后续可运行)可用于该工作负载。

您可以使用 gcloud CLI 或 Batch API 创建使用 MPI 执行紧密耦合任务的作业。

gcloud

如需使用 gcloud CLI 创建使用 MPI 执行紧密耦合任务的脚本作业,请执行以下操作:

  1. 创建一个包含以下内容的 JSON 配置文件:

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

    请替换以下内容:

    • SCRIPT:适用于使用 MPI 的工作负载的脚本
    • TASK_COUNT:作业的任务数。 该值必须是介于 110000 之间的整数。如需使用 Batch 提供的 MPI 库,此字段是必填字段,并且必须设置为 2 或更高版本。
    • TASK_COUNT_PER_NODE:作业可以在虚拟机实例上并发运行的任务数量。如需使用 Batch 提供的 MPI 库,此字段是必填字段,且必须设置为 1,这相当于每个任务运行一个虚拟机实例。
    • REQUIRE_HOSTS_FILE:设置为 true 时,作业会创建一个文件,列出任务组中运行的虚拟机实例。文件路径存储在 BATCH_HOSTS_FILE 环境变量中。如需使用 Batch 提供的 MPI 库,此字段必须设置为 true。
    • PERMISSIVE_SSH:设置为 true 时,Batch 会配置 SSH,以允许在任务组中运行的虚拟机实例之间进行无密码通信。如需使用 Batch 提供的 MPI 库,此字段必须设置为 true。
  2. 如需创建作业,请使用 gcloud batch jobs submit 命令

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

    请替换以下内容:

    • JOB_NAME:作业的名称。
    • LOCATION:作业的位置
    • JSON_CONFIGURATION_FILE:包含作业配置详细信息的 JSON 文件的路径。

(可选)您可以通过执行以下操作来提高 Batch 提供的 MPI 库的性能:

例如,如需从使用 MPI 并使 1 个任务输出任务组中 3 个任务的主机名的实例模板创建脚本作业,请执行以下操作:

  1. 在当前目录中创建一个名为 example-job-uses-mpi.json 且包含以下内容的 JSON 文件:

    {
        "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. 运行以下命令:

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

API

如需创建使用 MPI 通过 Batch API 执行紧密耦合的任务的脚本作业,请使用 gcloud batch jobs submit 命令并指定 permissiveSshrequireHostsFiletaskCounttaskCountPerNode 字段。

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

请替换以下内容:

  • PROJECT_ID:项目的项目 ID
  • LOCATION:作业的位置
  • JOB_NAME:作业的名称。
  • SCRIPT:适用于使用 MPI 的工作负载的脚本
  • TASK_COUNT:作业的任务数。该值必须是介于 110000 之间的整数。如需使用 Batch 提供的 MPI 库,此字段是必填字段,并且必须设置为 2 或更高版本。
  • TASK_COUNT_PER_NODE:作业可在虚拟机实例上并发运行的任务数量。如需使用 Batch 提供的 MPI 库,此字段是必填字段,且必须设置为 1,这相当于每个任务运行一个虚拟机实例。
  • REQUIRE_HOSTS_FILE:设置为 true 时,作业会创建一个文件,列出任务组中运行的虚拟机实例。文件路径存储在 BATCH_HOSTS_FILE 环境变量中。如需使用 Batch 提供的 MPI 库,此字段必须设置为 true。
  • PERMISSIVE_SSH:设置为 true 时,Batch 会配置 SSH,以允许在任务组中运行的虚拟机实例之间进行无密码通信。如需使用 Batch 提供的 MPI 库,此字段必须设置为 true。

(可选)您可以通过执行以下操作来提高 Batch 提供的 MPI 库的性能:

例如,如需从使用 MPI 的实例模板创建脚本作业,并使 1 个任务输出任务组中 3 个任务的主机名,请使用以下请求:

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

其中 PROJECT_ID 是项目的项目 ID

如需查看使用 MPI 执行紧密耦合任务的作业的更详细示例,请参阅使用 Batch 运行天气研究和预测模型

创建使用 GPU 的作业

或者,您可以创建一个作业,将图形处理单元 (GPU) 添加到作业的任务组中运行的虚拟机实例。

如需为您的作业安装所需的 GPU 驱动程序,请选择以下方法之一:

如需将 GPU 添加到作业资源,请选择以下方法之一:

  • 在作业的定义中定义机器类型和 GPU 平台,如本部分所示。
  • Compute Engine 实例模板中定义 GPU。如果您在作业的定义中包含实例模板,则必须使用此方法。

本部分举例说明了如何创建在作业资源中定义 GPU 的作业,并为 GPU 安装所需的驱动程序。具体而言,第一个示例展示了如何将 GPU 添加到使用默认映像的容器作业。第二个示例展示了如何将 GPU 添加到使用默认映像的脚本作业。第三个示例展示了如何将 GPU 添加到使用默认映像的容器和脚本作业。

您可以使用 gcloud CLI 或 Batch API 创建使用 GPU 的作业。

gcloud

如果要为作业添加 GPU,请参阅以下示例:

为容器作业添加 GPU

如需创建使用 gcloud CLI 使用默认映像的 GPU 的容器作业,请使用 gcloud batch jobs submit 命令并在作业的配置文件中指定以下内容:

  • 机器类型GPU 平台。
  • volumesoptions 字段,用于将 GPU 装载到使用默认映像的容器作业,如此示例所示。

例如,如需创建配有 GPU 的容器作业,请运行以下命令:

  1. 在当前目录中创建一个名为 hello-world-container-job-gpu.json 且包含以下内容的 JSON 文件:

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

    请替换以下内容:

    • INSTALL_GPU_DRIVERS:可选。设置为 true 时,Batch 会从第三方位置提取您在 policy 字段中指定的 GPU 类型所需的驱动程序,然后 Batch 代表您安装这些驱动程序。
    • MACHINE_TYPE:作业虚拟机的机器类型,用于限制您可以使用的 GPU 类型。如需创建具有 GPU 的作业,必须填写此字段。
    • GPU_TYPEGPU 类型。您可以使用 gcloud compute accelerator-types list 命令查看可用 GPU 类型的列表。如需创建具有 GPU 的作业,必须填写此字段。
    • GPU_COUNT:您在 type 字段中指定的类型的 GPU 数量。如需创建具有 GPU 的作业,必须填写此字段。
    • ALLOWED_LOCATIONS:可选。允许运行作业虚拟机实例的位置(例如,regions/us-central1, zones/us-central1-a 允许可用区 us-central1-a)。如果您指定允许的位置,则必须选择区域以及(可选)一个或多个可用区。您选择的位置必须具有此作业所需的 GPU 类型。如需了解详情,请参阅 allowedLocations 数组字段
  2. 运行以下命令:

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

将 GPU 添加到脚本作业

如需创建使用 gcloud CLI 使用默认映像的 GPU 的脚本作业,请使用 gcloud batch jobs submit 命令并在作业的配置文件中指定机器类型GPU 平台。

例如,如需创建配有 GPU 的脚本作业,请运行以下命令:

  1. 在当前目录中创建一个名为 hello-world-script-job-gpu.json 且包含以下内容的 JSON 文件:

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

    请替换以下内容:

    • INSTALL_GPU_DRIVERS:可选。设置为 true 时,Batch 会从第三方位置提取您在 policy 字段中指定的 GPU 类型所需的驱动程序,然后 Batch 代表您安装这些驱动程序。
    • MACHINE_TYPE:作业虚拟机的机器类型,用于限制您可以使用的 GPU 类型。如需创建具有 GPU 的作业,必须填写此字段。
    • GPU_TYPEGPU 类型。您可以使用 gcloud compute accelerator-types list 命令查看可用 GPU 类型的列表。如需创建具有 GPU 的作业,必须填写此字段。
    • GPU_COUNT:您在 type 字段中指定的类型的 GPU 数量。如需创建具有 GPU 的作业,必须填写此字段。
    • ALLOWED_LOCATIONS:可选。允许运行作业虚拟机实例的位置(例如,regions/us-central1, zones/us-central1-a 允许可用区 us-central1-a)。如果您指定允许的位置,则必须选择区域以及(可选)一个或多个可用区。您选择的位置必须具有此作业所需的 GPU 类型。如需了解详情,请参阅 allowedLocations 数组字段
  2. 运行以下命令:

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

将 GPU 添加到容器和脚本作业

如需创建使用 gcloud CLI 使用默认映像的 GPU 的容器和脚本作业,请使用 gcloud batch jobs submit 命令并在作业的配置文件中指定以下内容:

  • 机器类型GPU 平台。
  • 每个脚本可运行的 text 字段以及每个可运行的容器的 imageUrioptions 字段,用于使用默认映像将 GPU 装载到容器和脚本作业,如此示例所示。

例如,如需创建配有 GPU 的容器和脚本作业,请使用以下代码:

  1. 在当前目录中创建一个名为 hello-world-container-script-job-gpu.json 且包含以下内容的 JSON 文件:

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

    请替换以下内容:

    • INSTALL_GPU_DRIVERS:可选。设置为 true 时,Batch 会从第三方位置提取您在 policy 字段中指定的 GPU 类型所需的驱动程序,然后 Batch 代表您安装这些驱动程序。
    • MACHINE_TYPE:作业虚拟机的机器类型,用于限制您可以使用的 GPU 类型。如需创建具有 GPU 的作业,必须填写此字段。
    • GPU_TYPEGPU 类型。您可以使用 gcloud compute accelerator-types list 命令查看可用 GPU 类型的列表。如需创建具有 GPU 的作业,必须填写此字段。
    • GPU_COUNT:您在 type 字段中指定的类型的 GPU 数量。如需创建具有 GPU 的作业,必须填写此字段。
    • ALLOWED_LOCATIONS:可选。允许运行作业虚拟机实例的位置(例如,regions/us-central1, zones/us-central1-a 允许可用区 us-central1-a)。如果您指定允许的位置,则必须选择区域以及(可选)一个或多个可用区。您选择的位置必须具有此作业所需的 GPU 类型。如需了解详情,请参阅 allowedLocations 数组字段
  2. 运行以下命令:

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

API

如果要为作业添加 GPU,请参阅以下示例:

为容器作业添加 GPU

如需使用 Batch API 创建 GPU 并使用默认映像的容器作业,请使用 jobs.create 方法并指定以下内容:

  • 机器类型GPU 平台。
  • volumesoptions 字段,用于将 GPU 装载到使用默认映像的容器作业,如此示例所示。

例如,如需创建带有 GPU 的容器作业,请发出以下请求:

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

请替换以下内容:

  • PROJECT_ID:项目的项目 ID
  • INSTALL_GPU_DRIVERS:可选。设置为 true 时,Batch 会从第三方位置提取您在 policy 字段中指定的 GPU 类型所需的驱动程序,然后 Batch 代表您安装这些驱动程序。
  • MACHINE_TYPE:作业虚拟机的机器类型,用于限制您可以使用的 GPU 类型。如需创建具有 GPU 的作业,必须填写此字段。
  • GPU_TYPEGPU 类型。您可以使用 gcloud compute accelerator-types list 命令查看可用 GPU 类型的列表。如需创建具有 GPU 的作业,必须填写此字段。
  • GPU_COUNT:您在 type 字段中指定的类型的 GPU 数量。如需创建具有 GPU 的作业,必须填写此字段。
  • ALLOWED_LOCATIONS:可选。允许运行作业的虚拟机实例的位置(例如,regions/us-central1, zones/us-central1-a 允许可用区 us-central1-a)。如果您指定允许的位置,则必须选择区域以及(可选)一个或多个可用区。您选择的位置必须具有此作业所需的 GPU 类型。如需了解详情,请参阅 allowedLocations 数组字段

将 GPU 添加到脚本作业

如需创建使用 Batch API 使用默认映像的 GPU 的脚本作业,请使用 jobs.create 方法,并在 instances 字段中指定机器类型和加速器类型。

例如,如需创建配有 GPU 的脚本作业,请发出以下请求:

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

请替换以下内容:

  • PROJECT_ID:项目的项目 ID
  • INSTALL_GPU_DRIVERS:可选。设置为 true 时,Batch 会从第三方位置提取您在 policy 字段中指定的 GPU 类型所需的驱动程序,然后 Batch 代表您安装这些驱动程序。
  • MACHINE_TYPE:作业虚拟机的机器类型,用于限制您可以使用的 GPU 类型。如需创建具有 GPU 的作业,必须填写此字段。
  • GPU_TYPEGPU 类型。您可以使用 gcloud compute accelerator-types list 命令查看可用 GPU 类型的列表。如需创建具有 GPU 的作业,必须填写此字段。
  • GPU_COUNT:您在 type 字段中指定的类型的 GPU 数量。如需创建具有 GPU 的作业,必须填写此字段。
  • ALLOWED_LOCATIONS:可选。允许运行作业的虚拟机实例的位置(例如,regions/us-central1, zones/us-central1-a 允许可用区 us-central1-a)。如果您指定允许的位置,则必须选择区域以及(可选)一个或多个可用区。您选择的位置必须具有此作业所需的 GPU 类型。如需了解详情,请参阅 allowedLocations 数组字段

将 GPU 添加到容器和脚本作业

如需使用 Batch API 创建具有默认映像的 GPU 的容器和脚本作业,请使用 jobs.create 方法并指定以下内容:

  • 机器类型GPU 平台。
  • 每个脚本可运行的 text 字段以及每个可运行的容器的 imageUrioptions 字段,用于使用默认映像将 GPU 装载到容器和脚本作业,如此示例所示。

例如,如需创建带有 GPU 的容器和脚本作业,请发出以下请求:

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

请替换以下内容:

  • PROJECT_ID:项目的项目 ID
  • INSTALL_GPU_DRIVERS:可选。设置为 true 时,Batch 会从第三方位置提取您在 policy 字段中指定的 GPU 类型所需的驱动程序,然后 Batch 代表您安装这些驱动程序。
  • MACHINE_TYPE:作业虚拟机的机器类型,用于限制您可以使用的 GPU 类型。如需创建具有 GPU 的作业,必须填写此字段。
  • GPU_TYPEGPU 类型。您可以使用 gcloud compute accelerator-types list 命令查看可用 GPU 类型的列表。如需创建具有 GPU 的作业,必须填写此字段。
  • GPU_COUNT:您在 type 字段中指定的类型的 GPU 数量。如需创建具有 GPU 的作业,必须填写此字段。
  • ALLOWED_LOCATIONS:可选。允许运行作业的虚拟机实例的位置(例如,regions/us-central1, zones/us-central1-a 允许可用区 us-central1-a)。如果您指定允许的位置,则必须选择区域以及(可选)一个或多个可用区。您选择的位置必须具有此作业所需的 GPU 类型。如需了解详情,请参阅 allowedLocations 数组字段

创建使用存储卷的作业

默认情况下,作业的每个 Compute Engine 虚拟机都有一个包含操作系统的永久性启动磁盘。您也可以选择创建使用额外存储卷的作业。 具体而言,作业的虚拟机可以使用以下各种类型的存储卷。如需详细了解所有类型的存储卷及其差异和限制,请参阅 Compute Engine 虚拟机存储选项文档。

您可以让作业使用每个存储卷,方法是将其添加到作业定义中并在可运行对象中指定其装载路径 (mountPath)。如需了解如何创建使用存储卷的作业,请参阅以下一个或多个部分:

使用永久性磁盘

使用永久性磁盘的作业具有以下限制:

  • 所有永久性磁盘:查看所有永久性磁盘的限制
  • 实例模板:如果要在创建此作业时指定实例模板,则必须在实例模板中为此作业挂接任何永久性磁盘。否则,如果您不想使用实例模板,则必须直接在作业定义中附加任何永久性磁盘。
  • 新的永久性磁盘与现有的永久性磁盘:作业中的每个永久性磁盘可以是新的(在作业中定义并通过作业创建),也可以是现有的(已在项目中创建并在作业中指定)。下表介绍了 Batch 如何支持将 Batch 装载永久性磁盘到作业虚拟机,以及作业及其永久性磁盘在新的和现有的永久性磁盘上支持的位置选项不同:

    新的永久性磁盘 现有永久性磁盘
    装载选项 支持所有选项 系统支持除写入之外的所有选项。这是由于多写入器模式的限制。
    位置选项

    您只能创建可用区永久性磁盘

    您可以为作业选择任何位置。永久性磁盘是在项目运行的可用区内创建的。

    您可以选择可用区级和区域级永久性磁盘

    您必须将作业的位置(如果指定,则仅设置作业允许的位置)设置为仅包含作业的所有永久性磁盘的位置。例如,对于地区永久性磁盘,作业的位置必须是磁盘所在的区域;对于区域永久性磁盘,作业的位置必须是磁盘所在的区域;如果指定了区域,则作业的位置必须是区域永久性磁盘所在的一个或两个特定区域。

您可以使用 gcloud CLI 或 Batch API 创建使用永久性磁盘的作业。以下示例介绍如何创建挂接并装载现有永久性磁盘和新永久性磁盘的作业。该作业还有 3 项任务,每项任务都运行脚本以在名为 output_task_TASK_INDEX.txt 的新永久性磁盘中创建一个文件,其中 TASK_INDEX 是每个任务的索引:012

gcloud

如需使用 gcloud CLI 创建使用永久性磁盘的作业,请使用 gcloud batch jobs submit 命令。在作业的 JSON 配置文件中,在 instances 字段中指定永久性磁盘,并在 volumes 字段中装载永久性磁盘。

  1. 创建一个 JSON 文件。

    • 如果您没有为此作业使用实例模板,请创建一个包含以下内容的 JSON 文件:

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

      请替换以下内容:

      • PROJECT_ID:项目的项目 ID
      • EXISTING_PERSISTENT_DISK_NAME:现有永久性磁盘的名称。
      • EXISTING_PERSISTENT_DISK_LOCATION:现有永久性磁盘的位置。对于每个现有的区域永久性磁盘,作业的位置必须是磁盘所在的区域;对于每个现有的区域永久性磁盘,作业的位置必须是磁盘所在的区域;如果指定了区域,则作业的位置必须是区域永久性磁盘所在的一个或两个特定区域。如果您没有指定任何现有的永久性磁盘,则可以选择任意位置。详细了解 allowedLocations 字段
      • NEW_PERSISTENT_DISK_SIZE:新永久性磁盘的大小(以 GB 为单位)。允许的大小取决于永久性磁盘的类型,但最小容量通常为 10 GB (10),而最大容量通常为 64 TB (64000)。
      • NEW_PERSISTENT_DISK_TYPE:新永久性磁盘的磁盘类型,即 pd-standardpd-balancedpd-ssdpd-extreme
      • NEW_PERSISTENT_DISK_NAME:新永久性磁盘的名称。
    • 如果您要为此作业使用实例模板,请创建一个如前所示的 JSON 文件,但需要将 instances 字段替换为以下内容:

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

      其中,INSTANCE_TEMPLATE_NAME 是此作业的实例模板的名称。对于使用永久性磁盘的作业,此实例模板必须定义并挂接您希望该作业使用的永久性磁盘。在此示例中,模板必须定义并挂接名为 NEW_PERSISTENT_DISK_NAME 的新永久性磁盘,并挂接名为 EXISTING_PERSISTENT_DISK_NAME 的现有永久性磁盘。

  2. 运行以下命令:

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

    请替换以下内容:

    • JOB_NAME:作业的名称。
    • LOCATION:作业的位置
    • JSON_CONFIGURATION_FILE:包含作业配置详细信息的 JSON 文件的路径。

API

如需使用 Batch API 创建使用永久性磁盘的作业,请使用 jobs.create 方法。在请求中,在 instances 字段中指定永久性磁盘,并在 volumes 字段中装载永久性磁盘。

  • 如果您没有为此作业使用实例模板,请发出以下请求:

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

    请替换以下内容:

    • PROJECT_ID:项目的项目 ID
    • LOCATION:作业的位置
    • JOB_NAME:作业的名称。
    • EXISTING_PERSISTENT_DISK_NAME:现有永久性磁盘的名称。
    • EXISTING_PERSISTENT_DISK_LOCATION:现有永久性磁盘的位置。对于每个现有的可用区级永久性磁盘,作业的位置必须是磁盘的可用区;对于每个现有的区域永久性磁盘,作业的位置必须是磁盘所在的区域;如果指定了可用区,则作业的位置必须是区域永久性磁盘所在的一个或两个特定可用区。如果您未指定任何现有的永久性磁盘,则可以选择任何位置。详细了解 allowedLocations 字段
    • NEW_PERSISTENT_DISK_SIZE:新永久性磁盘的大小(以 GB 为单位)。允许的大小取决于永久性磁盘的类型,但最小容量通常为 10 GB (10),而最大容量通常为 64 TB (64000)。
    • NEW_PERSISTENT_DISK_TYPE:新永久性磁盘的磁盘类型,即 pd-standardpd-balancedpd-ssdpd-extreme
    • NEW_PERSISTENT_DISK_NAME:新永久性磁盘的名称。
  • 如果您要为此作业使用实例模板,请创建一个如前所示的 JSON 文件,但需要将 instances 字段替换为以下内容:

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

    其中,INSTANCE_TEMPLATE_NAME 是此作业的实例模板的名称。对于使用永久性磁盘的作业,此实例模板必须定义并挂接您希望该作业使用的永久性磁盘。在此示例中,模板必须定义并挂接名为 NEW_PERSISTENT_DISK_NAME 的新永久性磁盘,并挂接名为 EXISTING_PERSISTENT_DISK_NAME 的现有永久性磁盘。

使用本地 SSD

使用本地 SSD 的作业存在以下限制:

您可以使用 gcloud CLI 或 Batch API 创建使用本地 SSD 的作业。以下示例介绍如何创建创建、挂接和装载本地 SSD 的作业。该作业还有 3 项任务,每项任务都运行脚本以在本地 SSD 中创建一个名为 output_task_TASK_INDEX.txt 的文件,其中 TASK_INDEX 是每个任务的索引:012

gcloud

如需使用 gcloud CLI 创建使用本地 SSD 的作业,请使用 gcloud batch jobs submit 命令。在作业的 JSON 配置文件中,在 instances 字段中创建并挂接本地 SSD,并在 volumes 字段中装载本地 SSD。

  1. 创建一个 JSON 文件。

    • 如果您没有为此作业使用实例模板,请创建一个包含以下内容的 JSON 文件:

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

      请替换以下内容:

      • MACHINE_TYPE:作业虚拟机的机器类型允许的本地 SSD 数量取决于作业虚拟机的机器类型。
      • LOCAL_SSD_NAME:为此作业创建的本地 SSD 的名称。
      • LOCAL_SSD_SIZE:所有本地 SSD 的大小(以 GB 为单位)。每个本地 SSD 的大小为 375 GB,因此该值必须是 375 GB 的倍数。例如,对于 2 个本地 SSD,请将此值设置为 750 GB。
    • 如果您要为此作业使用实例模板,请创建一个如前所示的 JSON 文件,但需要将 instances 字段替换为以下内容:

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

      其中,INSTANCE_TEMPLATE_NAME 是此作业的实例模板的名称。对于使用本地 SSD 的作业,此实例模板必须定义并附加您希望该作业使用的本地 SSD。在此示例中,模板必须定义并附加一个名为 LOCAL_SSD_NAME 的本地 SSD。

  2. 运行以下命令:

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

    请替换以下内容:

    • JOB_NAME:作业的名称。
    • LOCATION:作业的位置
    • JSON_CONFIGURATION_FILE:包含作业配置详细信息的 JSON 文件的路径。

API

如需使用 Batch API 创建使用本地 SSD 的作业,请使用 jobs.create 方法。在该请求中,创建本地 SSD 并将其挂接到 instances 字段中,然后将本地 SSD 装载到 volumes 字段中。

  • 如果您没有为此作业使用实例模板,请发出以下请求:

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

    请替换以下内容:

    • PROJECT_ID:项目的项目 ID
    • LOCATION:作业的位置
    • JOB_NAME:作业的名称。
    • MACHINE_TYPE:作业虚拟机的机器类型允许的本地 SSD 数量取决于作业虚拟机的机器类型。
    • LOCAL_SSD_NAME:为此作业创建的本地 SSD 的名称。
    • LOCAL_SSD_SIZE:所有本地 SSD 的大小(以 GB 为单位)。每个本地 SSD 的大小为 375 GB,因此该值必须是 375 GB 的倍数。例如,对于 2 个本地 SSD,请将此值设置为 750 GB。
  • 如果您要为此作业使用实例模板,请创建一个如前所示的 JSON 文件,但需要将 instances 字段替换为以下内容:

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

    其中,INSTANCE_TEMPLATE_NAME 是此作业的实例模板的名称。对于使用本地 SSD 的作业,此实例模板必须定义并附加您希望该作业使用的本地 SSD。在此示例中,模板必须定义并附加一个名为 LOCAL_SSD_NAME 的本地 SSD。

使用 Cloud Storage 存储桶

如需创建使用现有 Cloud Storage 存储桶的作业,请选择以下方法之一:

  • 将存储桶直接装载到作业的计算环境,如本部分所示。
  • 创建基本作业,其中包含直接访问 Cloud Storage 的任务(例如通过客户端库)。

在创建使用存储桶的作业之前,请先创建存储桶或标识现有存储桶。如需了解详情,请参阅创建存储分区列出存储分区

您可以使用 gcloud CLI 或 Batch API 创建使用 Cloud Storage 存储桶的作业。

以下示例展示了如何创建作业装载 Cloud Storage 存储桶。该作业还有 3 项任务,每项任务都运行脚本以在名为 output_task_TASK_INDEX.txt 的存储桶中创建一个文件,其中 TASK_INDEX 是每个任务的索引:012

gcloud

如需使用 gcloud CLI 创建使用 Cloud Storage 存储桶的作业,请使用 gcloud batch jobs submit 命令。在作业的 JSON 配置文件中,将存储桶装载在 volumes 字段中。

例如,如需创建一个将文件输出到 Cloud Storage 的作业,请运行以下命令:

  1. 在当前目录中创建一个名为 hello-world-bucket.json 且包含以下内容的 JSON 文件: 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" } } 替换以下内容:
  • BUCKET_PATH:您希望此作业访问的存储桶目录的路径,该路径必须以存储桶的名称开头。例如,对于名为 BUCKET_NAME 的存储桶,路径 BUCKET_NAME 表示存储桶的根目录,路径 BUCKET_NAME/subdirectory 表示 subdirectory 子目录。
  • MOUNT_PATH:作业的运行程序用于访问此存储桶的装载路径。路径必须以 /mnt/disks/ 开头,后跟您选择的目录或路径。例如,如果要使用名为 my-bucket 的目录表示此存储桶,请将装载路径设置为 /mnt/disks/my-bucket
  1. 运行以下命令:

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

API

如需创建使用 Batch API 使用 Cloud Storage 存储桶的作业,请使用 jobs.create 方法并将存储桶装载到 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"
    }
}

请替换以下内容:

  • PROJECT_ID:项目的项目 ID
  • BUCKET_PATH:您希望此作业访问的存储桶目录的路径,该路径必须以存储桶的名称开头。例如,对于名为 BUCKET_NAME 的存储桶,路径 BUCKET_NAME 表示存储桶的根目录,路径 BUCKET_NAME/subdirectory 表示 subdirectory 子目录。
  • MOUNT_PATH:作业的运行程序用于访问此存储桶的装载路径。路径必须以 /mnt/disks/ 开头,后跟您选择的目录或路径。例如,如果要使用名为 my-bucket 的目录表示此存储桶,请将装载路径设置为 /mnt/disks/my-bucket

使用网络文件系统

您可以使用 gcloud CLI 或 Batch API 创建使用现有网络文件系统 (NFS) 的作业,例如 Filestore 文件共享

在创建使用 NFS 的作业之前,请确保网络的防火墙已正确配置为允许在作业的虚拟机和 NFS 之间传输流量。如需了解详情,请参阅为 Filestore 配置防火墙规则

以下示例介绍如何创建指定和装载 NFS 的作业。该作业还有 3 项任务,每项任务都运行脚本以在 NFS 中创建一个名为 output_task_TASK_INDEX.txt 的文件,其中 TASK_INDEX 是每个任务的索引:012

gcloud

如需使用 gcloud CLI 创建使用 NFS 的作业,请使用 gcloud batch jobs submit 命令。在作业的 JSON 配置文件中,将 NFS 装载到 volumes 字段中。

  1. 使用以下内容创建 JSON 文件:

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

    请替换以下内容:

    • NFS_IP_ADDRESS:NFS 的 IP 地址。例如,如果您的 NFS 是 Filestore 文件共享,则指定托管 Filestore 文件共享的虚拟机的 IP 地址,您可以通过描述 Filestore 虚拟机来获取该 IP 地址。
    • NFS_PATH:您希望此作业访问的 NFS 目录的路径,该路径必须以 / 开头,后跟 NFS 的根目录。例如,对于名为 FILE_SHARE_NAME 的 Filestore 文件共享,路径 /FILE_SHARE_NAME 表示文件共享的根目录,路径 /FILE_SHARE_NAME/subdirectory 表示 subdirectory 子目录。
    • MOUNT_PATH:作业的运行程序用于访问此 NFS 的装载路径。路径必须以 /mnt/disks/ 开头,后跟您选择的目录或路径。例如,如果要使用名为 my-nfs 的目录表示此 NFS,请将装载路径设置为 /mnt/disks/my-nfs
  2. 运行以下命令:

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

    请替换以下内容:

    • JOB_NAME:作业的名称。
    • LOCATION:作业的位置
    • JSON_CONFIGURATION_FILE:包含作业配置详细信息的 JSON 文件的路径。

API

如需使用 Batch API 创建使用 NFS 的作业,请使用 jobs.create 方法并将 NFS 装载到 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"
    }
}

请替换以下内容:

  • PROJECT_ID:项目的项目 ID
  • LOCATION:作业的位置
  • JOB_NAME:作业的名称。
  • NFS_IP_ADDRESS:网络文件系统的 IP 地址。例如,如果您的 NFS 是 Filestore 文件共享,则指定托管 Filestore 文件共享的虚拟机的 IP 地址,您可以通过描述 Filestore 虚拟机来获取该 IP 地址。
  • NFS_PATH:您希望此作业访问的 NFS 目录的路径,该路径必须以 / 开头,后跟 NFS 的根目录。例如,对于名为 FILE_SHARE_NAME 的 Filestore 文件共享,路径 /FILE_SHARE_NAME 表示文件共享的根目录,路径 /FILE_SHARE_NAME/subdirectory 表示子目录。
  • MOUNT_PATH:作业的运行程序用于访问此 NFS 的装载路径。路径必须以 /mnt/disks/ 开头,后跟您选择的目录或路径。例如,如果要使用名为 my-nfs 的目录表示此 NFS,请将装载路径设置为 /mnt/disks/my-nfs

后续步骤