작업 네트워크 지정

이 문서에서는 작업을 실행하는 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 네트워크를 사용하는 경우 호스트 프로젝트를 지정합니다.
      • 그렇지 않으면 현재 프로젝트를 지정합니다.
    • NETWORK: 현재 프로젝트에 있는 VPC 네트워크 또는 현재 프로젝트에서 호스팅되거나 공유되는 공유 VPC 네트워크의 이름
    • REGION: 작업의 서브넷 및 VM이 있는 리전
      • 작업의 VM에 허용되는 위치를 지정하기 위해 allowedLocations 필드를 포함하는 경우 여기에서 동일한 리전을 지정해야 합니다.
      • 그렇지 않으면 리전은 작업에 선택한 위치(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 네트워크를 사용하는 경우 호스트 프로젝트를 지정합니다.
      • 그렇지 않으면 현재 프로젝트를 지정합니다.
    • NETWORK: 현재 프로젝트에 있는 VPC 네트워크 또는 현재 프로젝트에서 호스팅되거나 공유되는 공유 VPC 네트워크의 이름
    • REGION: 작업의 서브넷 및 VM이 있는 리전
      • 작업의 VM에 허용되는 위치를 지정하기 위해 allowedLocations 필드를 포함하는 경우 여기에서 동일한 리전을 지정해야 합니다.
      • 그렇지 않으면 리전은 작업에 선택한 위치(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 파일의 경로입니다.

자바


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 네트워크를 사용하는 경우 호스트 프로젝트를 지정합니다.
    • 그렇지 않으면 현재 프로젝트(PROJECT_ID)를 지정합니다.
  • NETWORK: 현재 프로젝트에 있는 VPC 네트워크 또는 현재 프로젝트에서 호스팅되거나 공유되는 공유 VPC 네트워크의 이름
  • REGION: 작업의 서브넷 및 VM이 있는 리전
    • 작업의 VM에 허용되는 위치를 지정하기 위해 allowedLocations 필드를 포함하는 경우 여기에서 동일한 리전을 지정해야 합니다.
    • 그렇지 않으면 리전은 작업에 선택한 위치(LOCATION)와 동일해야 합니다.
  • SUBNET: VPC 네트워크에 속하며 작업의 VM과 동일한 리전에 있는 서브넷의 이름

다음 단계