Netzwerk für einen Job angeben

In diesem Dokument wird beschrieben, wie Sie das Netzwerk für die VMs angeben, auf denen ein Job ausgeführt wird.

Sie können die Verbindungen für die VMs steuern, auf denen ein Job ausgeführt wird, indem Sie ein Netzwerk mit dem gewünschten Zugriff angeben. Sie können beispielsweise ein Netzwerk angeben, über das ein Job auf die erforderlichen Ressourcen zugreifen kann, oder den Zugriff einschränken, um die Sicherheit zu verbessern. Wenn Sie keine Netzwerkanforderungen haben und das Netzwerk für einen Job nicht konfigurieren möchten, können Sie die Angabe des Netzwerks überspringen, um stattdessen die Standardnetzwerkkonfiguration zu verwenden.

Weitere Informationen zu Netzwerkkonzepten und zum Konfigurieren von Netzwerken finden Sie unter Batch-Netzwerk – Übersicht.

Hinweise

  1. Wenn Sie Batch noch nicht verwendet haben, lesen Sie den Hilfeartikel Batch-Dateien erstellen und ausführen und aktivieren Sie Batch, indem Sie die Voraussetzungen für Projekte und Nutzer erfüllen.

  2. Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Erstellen eines Jobs benötigen, der in einem bestimmten Netzwerk ausgeführt wird:

    Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

    Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

  3. Geben Sie das Netzwerk an, das Sie für den Job verwenden möchten. Das für einen Job angegebene Netzwerk muss die folgenden Anforderungen erfüllen: Weitere Informationen finden Sie unter VPC-Netzwerke erstellen und verwalten.
  4. Wenn ein Job in einem Subnetz eines freigegebene VPC-Netzwerks ausgeführt werden soll, das von einem anderen Projekt gehostet wird, muss dem Batch-Dienst-Agenten Ihres Projekts die Berechtigung zur Verwendung dieses Subnetzes erteilt werden.

    Damit der Batch-Dienst-Agent Ihres Projekts die erforderlichen Berechtigungen zum Erstellen eines Jobs hat, der in einem Subnetz eines freigegebene VPC-Netzwerks ausgeführt wird, bitten Sie Ihren Administrator, dem Batch-Dienst-Agent Ihres Projekts die IAM-Rolle Compute Network User (roles/compute.networkUser) für das Subnetz der freigegebene VPC zuzuweisen.

    Weitere Informationen finden Sie in der Dokumentation zum Einrichten einer freigegebene VPC für Dienstkonten.

Job erstellen, der in einem bestimmten Netzwerk ausgeführt wird

Geben Sie das Netzwerk für einen Job an, wenn Sie ihn erstellen. Sie müssen ein VPC-Netzwerk und ein Subnetz angeben, in dem der Job ausgeführt werden soll.

Wenn Sie beim Erstellen dieses Jobs eine VM-Instanzvorlage verwenden möchten, müssen Sie das Netzwerk in der VM-Instanzvorlage angeben. Andernfalls können Sie mit der gcloud CLI oder der Batch API das Netzwerk für einen Job angeben.

gcloud

Wenn Sie mit der gcloud CLI einen Job erstellen möchten, der in einem bestimmten Netzwerk ausgeführt wird, wählen Sie eine der folgenden Optionen aus:

Mit gcloud-Flags das Netzwerk für einen Job angeben

So erstellen Sie einen Job und geben mit gcloud-Flags das Netzwerk für den Job an:

  1. Erstellen Sie eine JSON-Datei mit den Konfigurationsdetails des Jobs.

    Wenn Sie beispielsweise einen einfachen Script-Job erstellen möchten, erstellen Sie eine JSON-Datei mit folgendem Inhalt.

    {
  "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. Erstellen Sie den Job mit dem Befehl gcloud batch jobs submit. Fügen Sie die Flags --network und --subnetwork ein, um das Netzwerk für den Job anzugeben.

    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

    Ersetzen Sie Folgendes:

    • JOB_NAME: Der Name für diesen Job.
    • LOCATION: den Speicherort für diese Aufgabe.
    • JSON_CONFIGURATION_FILE: der Pfad zur JSON-Datei mit den Konfigurationsdetails des Jobs.
    • HOST_PROJECT_ID: die Projekt-ID des Projekts für das angegebene Netzwerk:
      • Wenn Sie ein freigegebene VPC-Netzwerk verwenden, geben Sie das Hostprojekt an.
      • Andernfalls geben Sie das aktuelle Projekt an.
    • NETWORK: Der Name eines VPC-Netzwerks im aktuellen Projekt oder eines freigegebenen VPC-Netzwerks, das vom aktuellen Projekt gehostet oder für dieses freigegeben wird.
    • REGION: die Region, in der sich das Subnetz und die VMs für den Job befinden:
      • Wenn Sie das Feld allowedLocations angeben, um den zulässigen Speicherort für die VMs für den Job anzugeben, müssen Sie hier dieselbe Region angeben.
      • Andernfalls muss die Region mit dem Standort übereinstimmen, den Sie für den Job ausgewählt haben (LOCATION).
    • SUBNET: der Name eines Subnetzes, das zum VPC-Netzwerk gehört und sich in derselben Region wie die VMs für den Job befindet.

Netzwerk für einen Job mit JSON-Feldern angeben

So erstellst du einen Job und verwendest Felder in der JSON-Konfigurationsdatei, um das Netzwerk für den Job anzugeben:

  1. Erstellen Sie eine JSON-Datei mit den Konfigurationsdetails des Jobs. Geben Sie das Netzwerk für den Job an, indem Sie die Felder network und subnetwork einfügen.

    Wenn Sie beispielsweise einen einfachen Script-Job erstellen möchten, der in einem bestimmten Netzwerk ausgeführt wird, erstellen Sie eine JSON-Datei mit dem folgenden Inhalt.

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

    Ersetzen Sie Folgendes:

    • HOST_PROJECT_ID: die Projekt-ID des Projekts für das angegebene Netzwerk:
      • Wenn Sie ein freigegebene VPC-Netzwerk verwenden, geben Sie das Hostprojekt an.
      • Andernfalls geben Sie das aktuelle Projekt an.
    • NETWORK: Der Name eines VPC-Netzwerks im aktuellen Projekt oder eines freigegebenen VPC-Netzwerks, das vom aktuellen Projekt gehostet oder für dieses freigegeben wird.
    • REGION: die Region, in der sich das Subnetz und die VMs für den Job befinden:
      • Wenn Sie das Feld allowedLocations angeben, um den zulässigen Speicherort für die VMs für den Job anzugeben, müssen Sie hier dieselbe Region angeben.
      • Andernfalls muss die Region mit dem Standort übereinstimmen, den Sie für den Job ausgewählt haben (LOCATION).
    • SUBNET: der Name eines Subnetzes, das zum VPC-Netzwerk gehört und sich in derselben Region wie die VMs für den Job befindet.

  2. Erstellen Sie den Job mit dem Befehl gcloud batch jobs submit.

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

    Ersetzen Sie Folgendes:

    • JOB_NAME: Der Name für diesen Job.
    • LOCATION: den Speicherort für diese Aufgabe.
    • JSON_CONFIGURATION_FILE: der Pfad zur JSON-Datei mit den Konfigurationsdetails des Jobs.

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

Wenn Sie einen Job mit der Batch API erstellen möchten, verwenden Sie die Methode jobs.create und geben Sie die Konfigurationsdetails des Jobs an. Geben Sie das Netzwerk für den Job an, indem Sie die Felder network und subnetwork einfügen.

Wenn Sie beispielsweise einen einfachen Script-Job erstellen möchten, der in einem bestimmten Netzwerk ausgeführt wird, stellen Sie die folgende POST-Anfrage:

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

Ersetzen Sie Folgendes:

  • PROJECT_ID: die Projekt-ID Ihres Projekts.
  • LOCATION: den Speicherort für diese Aufgabe.
  • JOB_NAME: Der Name für diesen Job.
  • HOST_PROJECT_ID: die Projekt-ID des Projekts für das angegebene Netzwerk:
    • Wenn Sie ein freigegebene VPC-Netzwerk verwenden, geben Sie das Hostprojekt an.
    • Geben Sie andernfalls das aktuelle Projekt (PROJECT_ID) an.
  • NETWORK: Der Name eines VPC-Netzwerks im aktuellen Projekt oder eines freigegebenen VPC-Netzwerks, das vom aktuellen Projekt gehostet oder für dieses freigegeben wird.
  • REGION: die Region, in der sich das Subnetz und die VMs für den Job befinden:
    • Wenn Sie das Feld allowedLocations angeben, um den zulässigen Speicherort für die VMs für den Job anzugeben, müssen Sie hier dieselbe Region angeben.
    • Andernfalls muss die Region mit dem Standort übereinstimmen, den Sie für den Job ausgewählt haben (LOCATION).
  • SUBNET: der Name eines Subnetzes, das Teil des VPC-Netzwerk ist und sich in derselben Region wie die VMs für den Job befindet.

Nächste Schritte