ジョブのネットワークを指定する

このドキュメントでは、ジョブを実行する VM のネットワークを指定する方法について説明します。

必要なアクセス権を持つネットワークを指定することで、ジョブを実行する VM に対する接続を制御できます。たとえば、ジョブが必要なリソースにアクセスできるようにするネットワークを指定したり、セキュリティを強化するためにアクセスを制限したりできます。また、ネットワーキングの要件がなく、ジョブのネットワーキングを構成しない場合は、ネットワークの指定を省略し、代わりにデフォルトのネットワーキング構成を使用します。

ネットワーキングのコンセプトと、ネットワーキングを構成するタイミングについては、Batch ネットワーキングの概要をご覧ください。

始める前に

  1. Batch を以前に使用したことがない場合は、Batch を使ってみるを確認し、プロジェクトとユーザーの前提条件を完了して Batch を有効にします。

  2. 特定のネットワーク上で実行されるジョブを作成するために必要な権限を取得するには、次の IAM ロールを付与するように管理者へ依頼してください。

    ロールの付与については、プロジェクト、フォルダ、組織へのアクセス権の管理をご覧ください。

    必要な権限は、カスタムロールや他の事前定義ロールから取得することもできます。

  3. ジョブに使用するネットワークを特定します。ジョブに指定するネットワークは、次の要件を満たす必要があります。 詳細については、VPC ネットワークの作成と管理をご覧ください。
  4. 別のプロジェクトでホストされている共有 VPC ネットワークのサブネットでジョブを実行する場合は、プロジェクトのBatch サービス エージェントにそのサブネットを使用する権限が与えられている必要があります。

    プロジェクトの Batch サービス エージェントに、共有 VPC ネットワークのサブネットで実行されるジョブの作成に必要な権限を付与するには、プロジェクトの Batch サービス エージェントに共有 VPC サブネットに対する Compute ネットワーク ユーザー （roles/compute.networkUser）IAM ロールを付与するよう管理者に依頼します。

    詳細については、サービス アカウントの共有 VPC の設定に関するドキュメントをご覧ください。

特定のネットワークで動作するジョブを作成する

ジョブの作成時に、そのジョブのネットワークを指定します。具体的には、このジョブを実行する場所にある VPC ネットワークとサブネットを指定する必要があります。

このジョブの作成時に VM インスタンス テンプレートを使用する場合は、ネットワークを VM インスタンス テンプレートに指定する必要があります。テンプレートを使用しない場合は、gcloud CLI または Batch API を使用して、ジョブのネットワークを指定します。

gcloud

gcloud CLI を使用して特定のネットワークで実行されるジョブを作成するには、次のいずれかの方法を選択します。

gcloud フラグを使用してジョブのネットワークを指定する

ジョブを作成し、gcloud フラグを使用してジョブのネットワークを指定するには、次の操作を行います。

  1. ジョブの構成の詳細を指定する 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."
            }
          }
        ]
      },
      "taskCount": 3
    }
  ],
  "logsPolicy": {
    "destination": "CLOUD_LOGGING"
  }
}

  2. gcloud batch jobs submit コマンドを使用してジョブを作成します。ジョブのネットワークを指定するために、--network フラグと --subnetwork フラグを含めます。

    gcloud batch jobs submit JOB_NAME \
    --location LOCATION \
    --config JSON_CONFIGURATION_FILE \
    --network projects/HOST_PROJECT_ID/global/networks/NETWORK \
    --subnetwork projects/HOST_PROJECT_ID/regions/REGION/subnetworks/SUBNET

    以下を置き換えます。

    • JOB_NAME: このジョブの名前。
    • LOCATION: このジョブのロケーション。
    • JSON_CONFIGURATION_FILE: ジョブの構成の詳細を含む JSON ファイルへのパス。
    • HOST_PROJECT_ID: 指定したネットワークのプロジェクトのプロジェクト ID:
      • 共有 VPC ネットワークを使用している場合は、ホスト プロジェクトを指定します。
      • 共有 VPC ネットワークを使用していない場合は、現在のプロジェクトを指定します。
    • NETWORK: 現在のプロジェクト内の VPC ネットワークの名前、または現在のプロジェクトでホストまたは共有される共有 VPC ネットワークの名前。
    • REGION: ジョブのサブネットと VM が配置されているリージョン。
      • allowedLocations フィールドを追加して、ジョブの VM に対して許可されるロケーションを指定する場合は、ここで同じリージョンを指定する必要があります。
      • そうしない場合、リージョンはジョブに選択したロケーション（LOCATION）と同じでなければなりません。
    • SUBNET: VPC ネットワークの一部であり、ジョブの VM と同じリージョンにあるサブネットの名前。

JSON フィールドを使用してジョブのネットワークを指定する

ジョブを作成し、JSON 構成ファイルのフィールドを使用してジョブのネットワークを指定する手順は次のとおりです。

  1. ジョブの構成の詳細を指定する JSON ファイルを作成します。ジョブのネットワークを指定するために、network フィールドと subnetwork フィールドを含めます。

    たとえば、特定のネットワークで実行される基本的なスクリプトのジョブを作成するには、次の内容の 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."
            }
          }
        ]
      },
      "taskCount": 3
    }
  ],
  "allocationPolicy": {
    "network": {
      "networkInterfaces": [
        {
          "network": "projects/HOST_PROJECT_ID/global/networks/NETWORK",
          "subnetwork": "projects/HOST_PROJECT_ID/regions/REGION/subnetworks/SUBNET"
        }
      ]
    }
  },
  "logsPolicy": {
    "destination": "CLOUD_LOGGING"
  }
}

    以下を置き換えます。

    • HOST_PROJECT_ID: 指定したネットワークのプロジェクトのプロジェクト ID:
      • 共有 VPC ネットワークを使用している場合は、ホスト プロジェクトを指定します。
      • 共有 VPC ネットワークを使用していない場合は、現在のプロジェクトを指定します。
    • NETWORK: 現在のプロジェクト内の VPC ネットワークの名前、または現在のプロジェクトでホストまたは共有される共有 VPC ネットワークの名前。
    • REGION: ジョブのサブネットと VM が配置されているリージョン。
      • allowedLocations フィールドを追加して、ジョブの VM に対して許可されるロケーションを指定する場合は、ここで同じリージョンを指定する必要があります。
      • そうしない場合、リージョンはジョブに選択したロケーション（LOCATION）と同じでなければなりません。
    • SUBNET: VPC ネットワークの一部であり、ジョブの VM と同じリージョンにあるサブネットの名前。

  2. gcloud batch jobs submit コマンドを使用してジョブを作成します。

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

    以下を置き換えます。

    • JOB_NAME: このジョブの名前。
    • LOCATION: このジョブのロケーション。
    • JSON_CONFIGURATION_FILE: ジョブの構成の詳細を含む JSON ファイルへのパス。

Java


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.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 CreateBatchCustomNetwork {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the region you want to use to run the job. Regions that are
    // available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
    String region = "europe-central2";
    // The name of the job that will be created.
    // It needs to be unique for each project and region pair.
    String jobName = "JOB_NAME";
    // The name of a VPC network in the current project or a Shared VPC network that is hosted by
    // or shared with the current project.

    String network = String.format("global/networks/%s", "test-network");
    // The name of a subnet that is part of the VPC network and is located
    // in the same region as the VMs for the job.
    String subnet = String.format("regions/%s/subnetworks/%s", region, "subnet");

    createBatchCustomNetwork(projectId, region, jobName, network, subnet);
  }

  // Create a job that runs on a specific network.
  public static Job createBatchCustomNetwork(String projectId, String region, String jobName,
                                             String network,  String subnet)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {
      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(
                          "echo Hello world! This is task ${BATCH_TASK_INDEX}. "
                              + "This job has a total of ${BATCH_TASK_COUNT} tasks.")
                      // You can also run a script from a file. Just remember, that needs to be a
                      // script that's already on the VM that will be running the job.
                      // Using setText() and setPath() is mutually exclusive.
                      // .setPath("/tmp/test.sh")
                      .build())
              .build();

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

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

      // Specifies a VPC network and a subnet for Allocation Policy
      AllocationPolicy.NetworkPolicy networkPolicy =
          AllocationPolicy.NetworkPolicy.newBuilder()
              .addNetworkInterfaces(AllocationPolicy.NetworkInterface.newBuilder()
                  .setNetwork(network) // Set the network name
                  .setSubnetwork(subnet) // Set the subnet name
                  .setNoExternalIpAddress(true) // Blocks external access for all VMs
                  .build())
              .build();

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

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

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

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

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

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

      return result;
    }
  }
}

Node.js

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

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

/**
 * TODO(developer): Update these variables before running the sample.
 */
// Project ID or project number of the Google Cloud project you want to use.
const projectId = await batchClient.getProjectId();
// Name of the region you want to use to run the job. Regions that are
// available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
const region = 'europe-central2';
// The name of the job that will be created.
// It needs to be unique for each project and region pair.
const jobName = 'example-job';
// The name of a VPC network in the current project or a Shared VPC network that is hosted by
// or shared with the current project.
const network = 'global/networks/test-network';
// The name of a subnetwork that is part of the VPC network and is located
// in the same region as the VMs for the job.
const subnetwork = `regions/${region}/subnetworks/subnet`;

// Define what will be done as part of the job.
const runnable = new batch.Runnable({
  script: new batch.Runnable.Script({
    commands: ['-c', 'echo Hello world! This is task ${BATCH_TASK_INDEX}.'],
  }),
});

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

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

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

// Specify VPC network and a subnet for Allocation Policy
const networkPolicy = new batch.AllocationPolicy.NetworkPolicy({
  networkInterfaces: [
    new batch.AllocationPolicy.NetworkInterface({
      // Set the network name
      network,
      // Set the subnetwork name
      subnetwork,
      // Blocks external access for all VMs
      noExternalIpAddress: true,
    }),
  ],
});

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

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  policy: instancePolicy,
  network: networkPolicy,
});

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

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

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

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

await callCreateBatchCustomNetwork();

Python

from google.cloud import batch_v1


def create_with_custom_network(
    project_id: str,
    region: str,
    network_name: str,
    subnet_name: str,
    job_name: str,
) -> batch_v1.Job:
    """Create a Batch job that runs on a specific network and subnet.

    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/locations
        network_name: The name of a VPC network in the current project or a Shared VPC network.
        subnet_name: Name of the subnetwork to be used within the specified region.
        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.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."

    # 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 = 3
    group.task_spec = task

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

    # Create a NetworkInterface object to specify network settings for the job
    network_interface = batch_v1.AllocationPolicy.NetworkInterface()
    # Set the network to the specified network name within the project
    network_interface.network = f"projects/{project_id}/global/networks/{network_name}"
    # Set the subnetwork to the specified subnetwork within the region
    network_interface.subnetwork = (
        f"projects/{project_id}/regions/{region}/subnetworks/{subnet_name}"
    )
    allocation_policy.network.network_interfaces = [network_interface]

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    # 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)

API

Batch API を使用してジョブを作成するには、jobs.create メソッドを使用してジョブの構成の詳細を指定します。ジョブのネットワークを指定するために、network フィールドと subnetwork フィールドを含めます。

たとえば、特定のネットワークで実行される基本的なスクリプトのジョブを作成するには、次の POST リクエストを行います。

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

{
  "taskGroups": [
    {
      "taskSpec": {
        "runnables": [
          {
            "script": {
              "text": "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
            }
          }
        ]
      },
      "taskCount": 3
    }
  ],
  "allocationPolicy": {
    "network": {
      "networkInterfaces": [
        {
          "network": "projects/HOST_PROJECT_ID/global/networks/NETWORK",
          "subnetwork": "projects/HOST_PROJECT_ID/regions/REGION/subnetworks/SUBNET"
        }
      ]
    }
  },
  "logsPolicy": {
    "destination": "CLOUD_LOGGING"
  }
}

以下を置き換えます。

  • PROJECT_ID: プロジェクトのプロジェクト ID
  • LOCATION: このジョブのロケーション。
  • JOB_NAME: このジョブの名前。
  • HOST_PROJECT_ID: 指定したネットワークのプロジェクトのプロジェクト ID:
    • 共有 VPC ネットワークを使用している場合は、ホスト プロジェクトを指定します。
    • 共有 VPC ネットワークを使用していない場合は、現在のプロジェクト（PROJECT_ID）を指定します。
  • NETWORK: 現在のプロジェクト内の VPC ネットワークの名前、または現在のプロジェクトでホストまたは共有される共有 VPC ネットワークの名前。
  • REGION: ジョブのサブネットと VM が配置されているリージョン。
    • allowedLocations フィールドを追加して、ジョブの VM に対して許可されるロケーションを指定する場合は、ここで同じリージョンを指定する必要があります。
    • そうしない場合、リージョンはジョブに選択したロケーション（LOCATION）と同じでなければなりません。
  • SUBNET: VPC ネットワークの一部であり、ジョブの VM と同じリージョンにあるサブネットの名前。

次のステップ