创建并运行使用存储卷的作业

本文档介绍如何创建和运行使用一个或多个外部存储卷的批处理作业。 外部存储选项包括新的或现有的永久性磁盘、新的本地 SSD、现有的 Cloud Storage 存储分区和现有的网络文件系统 (NFS)（如 Filestore 文件共享）。

无论您是否添加外部存储卷，作业的每个 Compute Engine 虚拟机都有一个启动磁盘，该磁盘为作业的操作系统 (OS) 映像和说明提供存储空间。如需了解如何为作业配置启动磁盘，请改为参阅虚拟机操作系统环境概览。

准备工作

创建使用存储卷的作业

（可选）作业可以使用以下每种类型的外部存储卷中的一个或多个。如需详细了解所有类型的存储卷及其差异和限制，请参阅 Compute Engine 虚拟机存储方案的相关文档。

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

使用永久性磁盘

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

  • 所有永久性磁盘：查看针对所有永久性磁盘的限制。

  • 新的与现有的永久性磁盘：作业中的每个永久性磁盘都可以是新的（在作业中定义和创建）或现有的（已在项目中创建并在作业中指定）。如需使用永久性磁盘，需要将其格式化并装载到作业的虚拟机上，该虚拟机必须与永久性磁盘位于同一位置。批量装载包含在作业中的所有永久性磁盘并设置所有新的永久性磁盘的格式，但您必须格式化并卸载作业要使用的任何现有永久性磁盘。

    支持的位置选项、格式选项和装载选项因新的和现有的永久性磁盘而异，如下表所示：

    新的永久性磁盘 现有的永久性磁盘
    格式选项

    永久性磁盘会使用 ext4 文件系统自动格式化。

    您必须先将永久性磁盘的格式设置为以使用 ext4 文件系统，然后才能将其用于作业。

    安装方式

    支持所有选项。

    支持除书写以外的所有选项。这是因为多写入者模式存在限制。

    在将永久性磁盘用于作业之前，您必须先从其挂接的所有虚拟机中分离该永久性磁盘。
    位置选项

    您只能创建地区永久性磁盘。

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

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


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

  • 实例模板：如果要在创建此作业时使用虚拟机实例模板，则必须在实例模板中为此作业挂接任何永久性磁盘。如果您不想使用实例模板，则必须直接在作业定义中挂接任何永久性磁盘。

您可以使用 Google Cloud 控制台、gcloud CLI、Batch API、Go、Java、Node.js、Python 或 C++ 创建使用永久性磁盘的作业。

控制台

借助 Google Cloud 控制台，以下示例可创建一个作业，该作业运行脚本以从位于 us-central1-a 地区的现有地区永久性磁盘中读取文件。示例脚本假定作业已有地区永久性磁盘，该磁盘的根目录中包含名为 example.txt 的文本文件。

可选：创建示例地区永久性磁盘

如果您要创建一个可用于运行示例脚本的地区永久性磁盘，请在创建作业之前执行以下操作：

  1. 将名为 example-disk 的新空白永久性磁盘挂接到 us-central1-a 区域中的 Linux 虚拟机，然后在该虚拟机上运行命令以格式化并装载该磁盘。如需了解相关说明，请参阅向虚拟机添加永久性磁盘。

    请勿断开与虚拟机的连接。

  2. 如需在永久性磁盘上创建 example.txt，请在虚拟机上运行以下命令：

    1. 如需将当前工作目录更改为永久性磁盘的根目录，请输入以下命令：

      cd VM_MOUNT_PATH

      将 VM_MOUNT_PATH 替换为上一步中永久性磁盘装载到此虚拟机的目录的路径，例如 /mnt/disks/example-disk。

    2. 按 Enter 键。

    3. 如需创建和定义名为 example.txt 的文件，请输入以下命令：

      cat > example.txt

    4. 按 Enter 键。

    5. 输入文件的内容。例如，输入 Hello world!。

    6. 如需保存文件，请按 Ctrl+D（在 macOS 上，按 Command+D）。

    完成后，您可以断开与虚拟机的连接。

  3. 将永久性磁盘与虚拟机分离。

    • 如果您不再需要该虚拟机，可以删除虚拟机，以自动分离永久性磁盘。

    • 否则，请分离永久性磁盘。有关说明，请参阅分离和重新挂接启动磁盘，并分离 example-disk 永久性磁盘（而不是虚拟机的启动磁盘）。

创建使用现有地区永久性磁盘的作业

如需通过 Google Cloud 控制台创建使用现有地区永久性磁盘的作业，请执行以下操作：

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

    转到作业列表

  2. 点击 创建。此时系统会打开创建批量作业页面。在左侧窗格中，选择作业详情页面。

  3. 配置作业详情页面：

    1. 可选：在作业名称字段中，自定义作业名称。

      例如，输入 example-disk-job。

    2. 配置任务详情部分：

      1. 在新建可运行对象窗口中，添加至少一个脚本或容器来运行此作业。

        例如，如需运行一个脚本来输出名为 example.txt 且位于此作业使用的永久性磁盘根目录中的文件的内容，请执行以下操作：

        1. 选中 Script 复选框。随即会出现一个文本框。

        2. 在文本框中输入以下脚本：

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

          将 MOUNT_PATH 替换为您打算将永久性磁盘装载到此作业的虚拟机的路径，例如 /mnt/disks/example-disk。

        3. 点击完成。

      2. 在任务计数字段中，输入此作业的任务数量。

        例如，输入 1（默认）。

      3. 在并行数量字段中，输入要并发运行的任务数量。

        例如，输入 1（默认）。

  4. 配置资源规范页面：

    1. 在左侧窗格中，点击资源规范。 系统随即会打开资源规范页面。

    2. 选择此作业的位置。 如需使用现有地区永久性磁盘，作业的虚拟机必须位于同一地区中。

      1. 在区域字段中，选择一个区域。

        例如，如需使用示例地区永久性磁盘，请选择 us-central1 (Iowa)（默认）。

      2. 在可用区字段中，选择一个可用区。

        例如，选择 us-central1-a (Iowa)。

  5. 配置其他配置页面：

    1. 在左侧窗格中，点击其他配置。 系统随即会打开其他配置页面。

    2. 对于您要装载到此作业的每个现有地区永久性磁盘，请执行以下操作：

      1. 在存储卷部分中，点击添加新卷。 系统随即会显示新建卷窗口。

      2. 在新建卷窗口中，执行以下操作：

        1. 在卷类型部分中，选择永久性磁盘（默认）。

        2. 在磁盘列表中，选择要装载到此作业的现有地区永久性磁盘。磁盘必须与此作业位于同一可用区。

          例如，选择您准备的现有地区永久性磁盘，该磁盘位于 us-central1-a 地区且包含文件 example.txt。

        3. 可选：如果要重命名此地区永久性磁盘，请执行以下操作：

          1. 选择自定义设备名称。

          2. 在设备名称字段中，为磁盘输入新名称。

        4. 在装载路径字段中，输入此永久性磁盘的装载路径 (MOUNT_PATH)：

          例如，输入以下内容：

          /mnt/disks/EXISTING_PERSISTENT_DISK_NAME

          将 EXISTING_PERSISTENT_DISK_NAME 替换为磁盘名称。如果您重命名了地区永久性磁盘，请使用新名称。

          例如，将 EXISTING_PERSISTENT_DISK_NAME 替换为 example-disk。

        5. 点击完成。

  6. 可选：配置此作业的其他字段。

  7. 可选：如需查看作业配置，请在左侧窗格中点击预览。

  8. 点击创建。

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

gcloud

以下示例使用 gcloud CLI 可创建一个作业来挂接和装载现有的永久性磁盘及新的永久性磁盘。 该作业包含 3 个任务，每个任务运行一个脚本，以在名为 output_task_TASK_INDEX.txt 的新永久性磁盘中创建文件，其中 TASK_INDEX 是每个任务的索引：0、1 和 2。

如需使用 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-standard、pd-balanced、pd-ssd 或 pd-extreme。对于批量作业，默认值为 pd-balanced。
      • 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 创建一个作业来挂接并装载现有的永久性磁盘及新的永久性磁盘。该作业包含 3 个任务，每个任务运行一个脚本，以在名为 output_task_TASK_INDEX.txt 的新永久性磁盘中创建文件，其中 TASK_INDEX 是每个任务的索引：0、1 和 2。

如需通过 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-standard、pd-balanced、pd-ssd 或 pd-extreme。对于批量作业，默认值为 pd-balanced。
    • NEW_PERSISTENT_DISK_NAME：新的永久性磁盘的名称。

  • 如果您为此作业使用虚拟机实例模板，请按上文所示创建 JSON 文件，但需要将 instances 字段替换为以下内容：

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

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

Go

如需使用 Go 版 Cloud 客户端库创建使用新的或现有的永久性磁盘的批处理作业，请使用 CreateJob 函数并添加以下内容：

如需查看类似使用场景的代码示例，请参阅使用 Cloud Storage 存储桶。

Java

如需使用 Java 版 Cloud 客户端库创建使用新的或现有的永久性磁盘的批处理作业，请使用 CreateJobRequest 类并添加以下代码：

如需查看类似使用场景的代码示例，请参阅使用 Cloud Storage 存储桶。

Node.js

如需使用 Node.js 版 Cloud 客户端库创建使用新的或现有的永久性磁盘的批处理作业，请使用 createJob 方法并添加以下代码：

如需查看类似使用场景的代码示例，请参阅使用 Cloud Storage 存储桶。

Python

如需使用 Python 版 Cloud 客户端库创建使用新的或现有的永久性磁盘的批处理作业，请使用 CreateJob 函数并添加以下代码：

  • 如需将永久性磁盘挂接到作业的虚拟机，请添加以下其中一项：
  • 如需将永久性磁盘装载到作业，请使用带有 device_name 属性和 mount_path 属性的 Volume 类。对于新的永久性磁盘，还使用 mount_options 特性来启用写入。

如需查看类似使用场景的代码示例，请参阅使用 Cloud Storage 存储桶。

C++

如需使用 C++ 版 Cloud 客户端库创建使用新的或现有的永久性磁盘的批处理作业，请使用 CreateJob 函数并添加以下内容：

  • 如需将永久性磁盘挂接到作业的虚拟机，请添加以下其中一项：
    • 如果您未为此作业使用虚拟机实例模板，请使用 set_remote_path 方法。
    • 如果您要为此作业使用虚拟机实例模板，请使用 set_instance_template 方法。
  • 如需将永久性磁盘装载到作业，请使用 volumes 字段以及 deviceName 和 mountPath 字段。对于新的永久性磁盘，还使用 mountOptions 字段启用写入。

如需查看类似使用场景的代码示例，请参阅使用 Cloud Storage 存储桶。

使用本地 SSD

使用本地 SSD 的作业具有以下限制：

您可以通过 gcloud CLI 或 Batch API 创建使用本地 SSD 的作业。以下示例介绍如何创建用于创建、挂接和装载本地 SSD 的作业。该作业还包含 3 个任务，每个任务运行脚本以在本地 SSD 中创建名为 output_task_TASK_INDEX.txt 的文件，其中 TASK_INDEX 是每个任务的索引：0、1 和 2。

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 方法。在此请求中，在 instances 字段中创建并挂接本地 SSD，并在 volumes 字段中装载本地 SSD。

  • 如果您未为此作业使用实例模板，请发出以下请求：

    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 FUSE 自动装载到作业的虚拟机上。
  • 使用 gsutil 命令行工具或适用于 Cloud Storage API 的客户端库，创建包含可直接访问 Cloud Storage 存储桶的任务的作业。如需了解如何直接从虚拟机访问 Cloud Storage 存储桶，请参阅 Compute Engine 文档中的写入和读取数据。

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

您可以通过 Google Cloud 控制台、gcloud CLI、Batch API、Go、Java、Node.js、Python 或 C++ 创建使用 Cloud Storage 存储桶的作业。

以下示例介绍如何创建装载 Cloud Storage 存储桶的作业。该作业还包含 3 个任务，每个任务运行一个脚本，以在名为output_task_TASK_INDEX.txt的存储桶中创建文件，其中 TASK_INDEX 是每项任务的索引：0、1 和 2。

控制台

如需通过 Google Cloud 控制台创建使用 Cloud Storage 存储桶的作业，请执行以下操作：

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

    转到作业列表

  2. 点击 创建。此时系统会打开创建批量作业页面。在左侧窗格中，选择作业详情页面。

  3. 配置作业详情页面：

    1. 可选：在作业名称字段中，自定义作业名称。

      例如，输入 example-bucket-job。

    2. 配置任务详情部分：

      1. 在新建可运行对象窗口中，添加至少一个脚本或容器来运行此作业。

        例如，您可以执行以下操作：

        1. 选中 Script 复选框。随即会出现一个文本框。

        2. 在文本框中输入以下脚本：

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

          将 MOUNT_PATH 替换为此作业的可运行对象用于访问现有 Cloud Storage 存储桶的装载路径。路径必须以 /mnt/disks/ 开头，后跟您选择的目录或路径。例如，如果要使用名为 my-bucket 的目录表示此存储桶，请将装载路径设置为 /mnt/disks/my-bucket。

        3. 点击完成。

      2. 在任务计数字段中，输入此作业的任务数量。

        例如，输入 3。

      3. 在并行数量字段中，输入要并发运行的任务数量。

        例如，输入 1（默认）。

  4. 配置其他配置页面：

    1. 在左侧窗格中，点击其他配置。 系统随即会打开其他配置页面。

    2. 对于要装载到此作业的每个 Cloud Storage 存储桶，请执行以下操作：

      1. 在存储卷部分中，点击添加新卷。 系统随即会显示新建卷窗口。

      2. 在新建卷窗口中，执行以下操作：

        1. 在卷类型部分，选择 Cloud Storage 存储桶。

        2. 在存储桶名称字段中，输入现有存储桶的名称。

          例如，输入您在此作业的可运行对象中指定的存储桶。

        3. 在装载路径字段中，输入您在 runnable 中指定的存储桶的装载路径 (MOUNT_PATH)。

        4. 点击完成。

  5. 可选：配置此作业的其他字段。

  6. 可选：如需查看作业配置，请在左侧窗格中点击预览。

  7. 点击创建。

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

gcloud

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

例如，如需创建将文件输出到 Cloud Storage 的作业，请执行以下操作：

  1. 使用以下内容创建 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。

  2. 运行以下命令：

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

    替换以下内容：

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

API

如需通过 Batch API 创建使用 Cloud Storage 存储桶的作业，请使用 jobs.create 方法，并在 volumes 字段中装载该存储桶。

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

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

替换以下内容：

  • PROJECT_ID：您的项目 ID。
  • LOCATION：作业的位置。
  • JOB_NAME：作业的名称。
  • BUCKET_PATH：您想让此作业访问的存储桶目录的路径，该路径必须以相应存储桶的名称开头。例如，对于名为 BUCKET_NAME 的存储桶，路径 BUCKET_NAME 表示该存储桶的根目录，路径 BUCKET_NAME/subdirectory 表示 subdirectory 子目录。
  • MOUNT_PATH：作业的可运行对象用于访问此存储桶的装载路径。路径必须以 /mnt/disks/ 开头，后跟您选择的目录或路径。例如，如果要使用名为 my-bucket 的目录表示此存储桶，请将装载路径设置为 /mnt/disks/my-bucket。

Go

Go

如需了解详情，请参阅批量 Go API 参考文档。

如需向 Batch 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。 

import (
	"context"
	"fmt"
	"io"

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

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

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

	// Define what will be done as part of the job.
	command := &batchpb.Runnable_Script_Text{
		Text: "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt",
	}

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

	// We can specify what resources are requested by each task.
	resources := &batchpb.ComputeResource{
		// CpuMilli is milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
		CpuMilli:  500,
		MemoryMib: 16,
	}

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

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

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

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

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

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

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

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

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

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

	return nil
}

Java

Java

如需了解详情，请参阅批量 Java API 参考文档。

如需向 Batch 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。 

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

public class CreateWithMountedBucket {

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

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

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

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

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

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

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

      Volume volume = Volume.newBuilder()
          .setGcs(GCS.newBuilder()
              .setRemotePath(bucketName)
              .build())
          .setMountPath("/mnt/share")
          .build();

      // We can specify what resources are requested by each task.
      ComputeResource computeResource =
          ComputeResource.newBuilder()
              // In milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
              .setCpuMilli(500)
              // In MiB.
              .setMemoryMib(16)
              .build();

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

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

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

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

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

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

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

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

Node.js

Node.js

如需了解详情，请参阅批量 Node.js API 参考文档。

如需向 Batch 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。 

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

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

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

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

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

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

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

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

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

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

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

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

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

callCreateJob();

Python

Python

如需了解详情，请参阅批量 Python API 参考文档。

如需向 Batch 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。 

from google.cloud import batch_v1

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

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

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

    # Define what will be done as part of the job.
    task = batch_v1.TaskSpec()
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt"
    task.runnables = [runnable]

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

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 500  # in milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
    resources.memory_mib = 16
    task.compute_resource = resources

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

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

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

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

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

    return client.create_job(create_request)

C++

C++

如需了解详情，请参阅批量 C++ API 参考文档。

如需向 Batch 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。 

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

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

使用网络文件系统

您可以通过 Google Cloud 控制台、gcloud CLI 或 Batch API 创建使用现有网络文件系统 (NFS)（如 Filestore 文件共享）的作业。

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

以下示例介绍如何创建指定和装载 NFS 的作业。该作业还包含 3 个任务，每个任务运行一个脚本，以在 NFS 中创建名为 output_task_TASK_INDEX.txt 的文件，其中 TASK_INDEX 是每个任务的索引：0、1 和 2。

控制台

如需使用 Google Cloud 控制台创建使用 NFS 的作业，请执行以下操作：

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

    转到作业列表

  2. 点击 创建。此时系统会打开创建批量作业页面。在左侧窗格中，选择作业详情页面。

  3. 配置作业详情页面：

    1. 可选：在作业名称字段中，自定义作业名称。

      例如，输入 example-nfs-job。

    2. 配置任务详情部分：

      1. 在新建可运行对象窗口中，添加至少一个脚本或容器来运行此作业。

        例如，您可以执行以下操作：

        1. 选中 Script 复选框。随即会出现一个文本框。

        2. 在文本框中输入以下脚本：

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

          将 MOUNT_PATH 替换为作业的可运行对象用于访问此 NFS 的装载路径。路径必须以 /mnt/disks/ 开头，后跟您选择的目录或路径。例如，如果要使用名为 my-nfs 的目录表示此 NFS，请将装载路径设置为 /mnt/disks/my-nfs。

        3. 点击完成。

      2. 在任务计数字段中，输入此作业的任务数量。

        例如，输入 3。

      3. 在并行数量字段中，输入要并发运行的任务数量。

        例如，输入 1（默认）。

  4. 配置其他配置页面：

    1. 在左侧窗格中，点击其他配置。 系统随即会打开其他配置页面。

    2. 对于要装载到此作业的每个 Cloud Storage 存储桶，请执行以下操作：

      1. 在存储卷部分中，点击添加新卷。 系统随即会显示新建卷窗口。

      2. 在新建卷窗口中，执行以下操作：

        1. 在卷类型部分中，选择网络文件系统。

        2. 在文件服务器字段中，输入您在此作业的可运行对象中指定的 NFS 所在的服务器的 IP 地址。

          例如，如果您的 NFS 是 Filestore 文件共享，请指定 Filestore 实例的 IP 地址，您可以通过描述 Filestore 实例来获取该地址。

        3. 在远程路径字段中，输入一个可以访问您在上一步中指定的 NFS 的路径。

          NFS 目录的路径必须以 / 开头，后跟 NFS 的根目录。

        4. 在装载路径字段中，输入您在上一步中指定的 NFS 的装载路径 (MOUNT_PATH)。

    3. 点击完成。

  5. 可选：配置此作业的其他字段。

  6. 可选：如需查看作业配置，请在左侧窗格中点击预览。

  7. 点击创建。

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

gcloud

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

  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 实例来获取该地址。
    • 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 实例来获取该地址。
  • 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。

后续步骤