Reservierungen nutzen

Console

Im folgenden Beispiel wird gezeigt, wie eine automatische Reservierung in der Zone us-central1-a für drei N2-Instanzen mit 32 vCPUs und Intel Cascade Lake als Mindest-CPU-Plattform erstellt wird. Außerdem wird gezeigt, wie Sie eine einzelne Instanz erstellen, die die Reservierung nutzt.

So erstellen Sie die automatische Beispielreservierung und nutzen sie:

1. So erstellen Sie eine Beispielreservierung:

   1. Rufen Sie in der Google Cloud Console die Seite IAM auf.

      Zu „Reservierungen“

      Die verbleibenden Schritte werden automatisch in derGoogle Cloud Console angezeigt.

   2. Klicken Sie auf dem Tab On-Demand-Reservierung (Standard) auf add_box Reservierung erstellen. Die Seite Reservierung erstellen wird angezeigt.

   3. Geben Sie im Feld Name einen Namen für die Reservierung ein. Geben Sie beispielsweise reservation-01 ein.

   4. Wählen Sie die Region und die Zone aus, in der Sie Ressourcen reservieren möchten. Wählen Sie beispielsweise us-central1 bzw. us-central1-a aus.

   5. Führen Sie im Abschnitt Freigabetyp einen der folgenden Schritte aus:

      • Wenn Sie eine Reservierung für ein einzelnes Projekt erstellen möchten, wählen Sie Lokal aus.

      • Wenn Sie eine freigegebene Reservierung erstellen möchten, wählen Sie Freigegeben aus und geben Sie dann die Projekte an, für die Sie die Reservierung freigeben möchten.

   6. Wählen Sie im Abschnitt Mit VM-Instanz verwenden die Option Reservierung automatisch verwenden aus, falls diese Option noch nicht ausgewählt ist.

   7. Geben Sie im Feld Anzahl der VM-Instanzen den Wert 3 ein.

   8. Wählen Sie auf dem Tab Allgemein die Option N2 aus.

   9. Wählen Sie im Bereich Maschinentyp auf dem Tab Voreinstellung (Standard) die Option n2-standard-32 aus.

   10. Maximieren Sie CPU-Plattform und GPU und wählen Sie dann im Feld CPU-Plattform die Option Intel Cascade Lake oder höher aus.

   11. Klicken Sie auf Erstellen.

2. So erstellen Sie eine Instanz, die die Beispielreservierung nutzt:

   1. Rufen Sie in der Google Cloud Console die Seite Instanz erstellen auf.

      Zur Seite „Instanz erstellen“

      Die Seite Instanz erstellen wird angezeigt und enthält den Bereich Maschinenkonfiguration.

   2. Führen Sie im Bereich „Maschinenkonfiguration“ die folgenden Schritte aus:

      1. Geben Sie im Feld Name einen Namen für die Instanz ein. Geben Sie für dieses Beispiel instance-01 ein.

      2. Geben Sie die Region und die Zone an, in der Sie Ressourcen reservieren möchten. Wählen Sie für dieses Beispiel us-central1 und us-central1-a aus.

      3. Wählen Sie auf dem Tab Allgemein die Option N2 aus.

      4. Wählen Sie im Bereich Maschinentyp auf dem Tab Voreinstellung (Standard) die Option n2-standard-32 aus.

      5. Maximieren Sie den Abschnitt Erweiterte Optionen und wählen Sie dann im Feld CPU-Plattform die Option Intel Cascade Lake oder höher aus.

   3. Optional: Das automatische Nutzen einer passenden Reservierung ist die Standardeinstellung. Wenn Sie diese Einstellung jedoch angeben möchten, gehen Sie so vor:

      1. Klicken Sie im Navigationsmenü auf Erweitert. Der Bereich Erweitert wird angezeigt.

      2. Wählen Sie im Bereich Reservierungen die Option Automatische Auswahl verwenden aus.

   4. Klicken Sie auf Erstellen.

gcloud

Im folgenden Beispiel wird gezeigt, wie eine automatische Reservierung in der Zone us-central1-a für drei N2-Instanzen mit 32 vCPUs und Intel Cascade Lake als Mindest-CPU-Plattform erstellt wird. Außerdem wird gezeigt, wie Sie eine einzelne Instanz erstellen, die die Reservierung nutzt.

So erstellen Sie die automatische Beispielreservierung und nutzen sie:

1. Verwenden Sie den Befehl gcloud compute reservations create, um die Beispielreservierung zu erstellen:

   gcloud compute reservations create reservation-01 \
       --machine-type=n2-standard-32 \
       --min-cpu-platform="Intel Cascade Lake" \
       --vm-count=3 \
       --zone=us-central1-a
   

2. Verwenden Sie zum Erstellen einer Instanz, die die Beispielreservierung nutzt, den Befehl gcloud compute instances create mit dem Flag --reservation-affinity, das auf any gesetzt ist. Da any die Standardkonfiguration ist, können Sie dieses Flag auch weglassen.

   gcloud compute instances create instance-01 \
       --machine-type=n2-standard-32 \
       --min-cpu-platform="Intel Cascade Lake" \
       --reservation-affinity=any \
       --zone=us-central1-a
   

Go

Verwenden Sie das folgende Codebeispiel, um die automatische Beispielreservierung mithilfe einer Instanzvorlage zu erstellen und eine Instanz zu erstellen, die die Reservierung mit derselben Vorlage nutzt:

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

// consumeAnyReservation creates instance, consuming any available reservation
func consumeAnyReservation(w io.Writer, projectID, zone, instanceName, sourceTemplate string) error {
	// projectID := "your_project_id"
	// zone := "us-west3-a"
	// instanceName := "your_instance_name"
	// sourceTemplate: existing template path. Following formats are allowed:
	//  	- projects/{project_id}/global/instanceTemplates/{template_name}
	//  	- projects/{project_id}/regions/{region}/instanceTemplates/{template_name}
	//  	- https://www.googleapis.com/compute/v1/projects/{project_id}/global/instanceTemplates/instanceTemplate
	//  	- https://www.googleapis.com/compute/v1/projects/{project_id}/regions/{region}/instanceTemplates/instanceTemplate

	ctx := context.Background()

	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer instancesClient.Close()

	req := &computepb.InsertInstanceRequest{
		Project:                projectID,
		Zone:                   zone,
		SourceInstanceTemplate: proto.String(sourceTemplate),
		InstanceResource: &computepb.Instance{
			Name: proto.String(instanceName),
			// specifies that any matching reservation should be consumed
			ReservationAffinity: &computepb.ReservationAffinity{
				ConsumeReservationType: proto.String("ANY_RESERVATION"),
			},
		},
	}

	op, err := instancesClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create instance: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}
	fmt.Fprintf(w, "Instance created from reservation\n")

	return nil
}

Java

Im folgenden Beispiel wird gezeigt, wie eine N1-Instanz mit vier vCPUs und Intel Skylake als Mindest-CPU-Plattform in der Zone us-central1-a erstellt wird. Die Instanz nutzt automatisch eine übereinstimmende Reservierung.

Verwenden Sie das folgende Codebeispiel, um die Beispielinstanz zu erstellen:

import static com.google.cloud.compute.v1.ReservationAffinity.ConsumeReservationType.ANY_RESERVATION;

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.ReservationAffinity;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ConsumeAnyMatchingReservation {

  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";
    // Zone where the VM instance will be created.
    String zone = "us-central1-a";
    // Name of the VM instance you want to query.
    String instanceName = "YOUR_INSTANCE_NAME";
    // machineType: machine type of the VM being created.
    // *   For a list of machine types, see https://cloud.google.com/compute/docs/machine-types
    String machineTypeName = "n1-standard-4";
    // sourceImage: path to the operating system image to mount.
    // *   For details about images you can mount, see https://cloud.google.com/compute/docs/images
    String sourceImage = "projects/debian-cloud/global/images/family/debian-11";
    // diskSizeGb: storage size of the boot disk to attach to the instance.
    long diskSizeGb = 10L;
    // networkName: network interface to associate with the instance.
    String networkName = "default";
    // Minimum CPU platform of the instances.
    String minCpuPlatform = "Intel Skylake";

    createInstanceAsync(projectId, zone, instanceName, machineTypeName, sourceImage,
        diskSizeGb, networkName, minCpuPlatform);
  }

  // Create a virtual machine targeted with the reserveAffinity field.
  // In this consumption model, existing and new VMs automatically consume a reservation
  // if their properties match the VM properties specified in the reservation.
  public static Instance createInstanceAsync(String projectId, String zone,
      String instanceName, String machineTypeName, String sourceImage,
      long diskSizeGb, String networkName, String minCpuPlatform)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    String machineType = String.format("zones/%s/machineTypes/%s", zone, machineTypeName);
    // 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 (InstancesClient instancesClient = InstancesClient.create()) {
      AttachedDisk disk =
          AttachedDisk.newBuilder()
              .setBoot(true)
              .setAutoDelete(true)
              .setType(AttachedDisk.Type.PERSISTENT.toString())
              .setDeviceName("disk-1")
              .setInitializeParams(
                  AttachedDiskInitializeParams.newBuilder()
                      .setSourceImage(sourceImage)
                      .setDiskSizeGb(diskSizeGb)
                      .build())
              .build();

      NetworkInterface networkInterface = NetworkInterface.newBuilder()
          .setName(networkName)
          .build();

      ReservationAffinity reservationAffinity =
          ReservationAffinity.newBuilder()
              .setConsumeReservationType(ANY_RESERVATION.toString())
              .build();

      Instance instanceResource =
          Instance.newBuilder()
              .setName(instanceName)
              .setMachineType(machineType)
              .addDisks(disk)
              .addNetworkInterfaces(networkInterface)
              .setMinCpuPlatform(minCpuPlatform)
              .setReservationAffinity(reservationAffinity)
              .build();

      InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setInstanceResource(instanceResource)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.insertAsync(
          insertInstanceRequest);

      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        return null;
      }
      return instancesClient.get(projectId, zone, instanceName);
    }
  }
}

Node.js

Im folgenden Beispiel wird gezeigt, wie eine N1-Instanz mit vier vCPUs und Intel Skylake als Mindest-CPU-Plattform in der Zone us-central1-a erstellt wird. Die Instanz nutzt automatisch eine übereinstimmende Reservierung.

Verwenden Sie das folgende Codebeispiel, um die Beispielinstanz zu erstellen:

// Import the Compute library
const computeLib = require('@google-cloud/compute');
const compute = computeLib.protos.google.cloud.compute.v1;

// Instantiate a reservationsClient
const instancesClient = new computeLib.InstancesClient();
// Instantiate a zoneOperationsClient
const zoneOperationsClient = new computeLib.ZoneOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The ID of the project where you want to create instance.
const projectId = await instancesClient.getProjectId();
// The zone in which to create instance.
const zone = 'us-central1-a';
// The name of the instance to create.
// const instanceName = 'instance-01';
// Machine type to use for VM.
const machineType = 'n1-standard-4';

// Create instance to consume reservation if their properties match the VM properties
async function callCreateInstanceToConsumeAnyReservation() {
  // Describe the size and source image of the boot disk to attach to the instance.
  const disk = new compute.Disk({
    boot: true,
    autoDelete: true,
    type: 'PERSISTENT',
    initializeParams: {
      diskSizeGb: '10',
      sourceImage: 'projects/debian-cloud/global/images/family/debian-12',
    },
  });

  //  Define networkInterface
  const networkInterface = new compute.NetworkInterface({
    name: 'global/networks/default',
  });

  // Define reservationAffinity
  const reservationAffinity = new compute.ReservationAffinity({
    consumeReservationType: 'ANY_RESERVATION',
  });

  // Create an instance
  const instance = new compute.Instance({
    name: instanceName,
    machineType: `zones/${zone}/machineTypes/${machineType}`,
    minCpuPlatform: 'Intel Skylake',
    disks: [disk],
    networkInterfaces: [networkInterface],
    reservationAffinity,
  });

  const [response] = await instancesClient.insert({
    project: projectId,
    instanceResource: instance,
    zone,
  });

  let operation = response.latestResponse;

  // Wait for the create instance operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await zoneOperationsClient.wait({
      operation: operation.name,
      project: projectId,
      zone: operation.zone.split('/').pop(),
    });
  }

  console.log(`Instance ${instanceName} created.`);
}

await callCreateInstanceToConsumeAnyReservation();

Python

Das folgende Beispiel zeigt, wie Sie eine automatische Reservierung in der Zone us-central1-a für drei N1-Instanzen mit einer vCPU und Intel Ivy als Mindest-CPU-Plattform erstellen. Außerdem wird gezeigt, wie Sie eine einzelne Instanz erstellen, um die Reservierung zu nutzen.

So erstellen Sie die automatische Beispielreservierung und nutzen sie:

from __future__ import annotations

import sys
from typing import Any

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


def consume_any_project_reservation(
    project_id: str,
    zone: str,
    reservation_name: str,
    instance_name: str,
    machine_type: str = "n1-standard-1",
    min_cpu_platform: str = "Intel Ivy Bridge",
) -> compute_v1.Instance:
    """
    Creates a specific reservation in a single project and launches a VM
    that consumes the newly created reservation.
    Args:
        project_id (str): The ID of the Google Cloud project.
        zone (str): The zone to create the reservation.
        reservation_name (str): The name of the reservation to create.
        instance_name (str): The name of the instance to create.
        machine_type (str): The machine type for the instance.
        min_cpu_platform (str): The minimum CPU platform for the instance.
    """
    instance_properties = (
        compute_v1.AllocationSpecificSKUAllocationReservedInstanceProperties(
            machine_type=machine_type,
            min_cpu_platform=min_cpu_platform,
        )
    )

    reservation = compute_v1.Reservation(
        name=reservation_name,
        specific_reservation=compute_v1.AllocationSpecificSKUReservation(
            count=3,
            instance_properties=instance_properties,
        ),
    )

    # Create a reservation client
    client = compute_v1.ReservationsClient()
    operation = client.insert(
        project=project_id,
        zone=zone,
        reservation_resource=reservation,
    )
    wait_for_extended_operation(operation, "Reservation creation")

    instance = compute_v1.Instance()
    instance.name = instance_name
    instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
    instance.min_cpu_platform = min_cpu_platform
    instance.zone = zone

    # Set the reservation affinity to target any matching reservation
    instance.reservation_affinity = compute_v1.ReservationAffinity(
        consume_reservation_type="ANY_RESERVATION",  # Type of reservation to consume
    )
    # Define the disks for the instance
    instance.disks = [
        compute_v1.AttachedDisk(
            boot=True,  # Indicates that this is a boot disk
            auto_delete=True,  # The disk will be deleted when the instance is deleted
            initialize_params=compute_v1.AttachedDiskInitializeParams(
                source_image="projects/debian-cloud/global/images/family/debian-11",
                disk_size_gb=10,
            ),
        )
    ]
    instance.network_interfaces = [
        compute_v1.NetworkInterface(
            network="global/networks/default",  # The network to use
            access_configs=[
                compute_v1.AccessConfig(
                    name="External NAT",  # Name of the access configuration
                    type="ONE_TO_ONE_NAT",  # Type of access configuration
                )
            ],
        )
    ]
    # Create a request to insert the instance
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

    vm_client = compute_v1.InstancesClient()
    operation = vm_client.insert(request)
    wait_for_extended_operation(operation, "instance creation")
    print(f"Instance {instance_name} that targets any open reservation created.")

    return vm_client.get(project=project_id, zone=zone, instance=instance_name)

REST

Im folgenden Beispiel wird gezeigt, wie eine automatische Reservierung in der Zone us-central1-a für drei N2-Instanzen mit 32 vCPUs und Intel Cascade Lake als Mindest-CPU-Plattform erstellt wird. Außerdem wird gezeigt, wie Sie eine einzelne Instanz erstellen, die die Reservierung nutzt.

So erstellen Sie die automatische Beispielreservierung und nutzen sie:

1. Senden Sie zum Erstellen der Beispielreservierung eine POST-Anfrage an die Methode reservations.insert:

   POST https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/reservations
   
   {
     "name": "reservation-01",
     "specificReservation": {
       "count": "3",
       "instanceProperties": {
         "machineType": "n2-standard-32",
         "minCpuPlatform": "Intel Cascade Lake",
       }
     }
   }
   

2. Wenn Sie eine Instanz erstellen möchten, die die Beispielreservierung nutzt, stellen Sie eine POST-Anfrage an die Methode instances.insert. Geben Sie im Anfragetext das Feld consumeReservationType an, das auf ANY_RESERVATION gesetzt ist. Da ANY_RESERVATION jedoch die Standardkonfiguration ist, können Sie das Feld auch weglassen.

   POST https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/instances
   
   {
     "name": "instance-01",
     "machineType": "zones/us-central1-a/machineTypes/n2-standard-32",
     "minCpuPlatform": "Intel Cascade Lake",
     "disks": [
       {
         "boot": true,
         "initializeParams": {
           "sourceImage": "projects/debian-cloud/global/images/family/debian-12"
         }
       }
     ],
     "networkInterfaces": [
       {
         "network": "global/networks/default"
       }
     ],
     "reservationAffinity": {
       "consumeReservationType": "ANY_RESERVATION"
     }
   }
   

Console

Im folgenden Beispiel wird gezeigt, wie Sie eine bestimmte Reservierung in der Zone us-central1-a für drei N2-Instanzen mit 32 vCPUs und Intel Cascade Lake als Mindest-CPU-Plattform erstellen. Außerdem wird gezeigt, wie Sie eine einzelne Instanz erstellen, die die Reservierung nutzt.

So erstellen Sie die Beispielreservierung und nutzen sie:

1. So erstellen Sie eine Beispielreservierung:

   1. Rufen Sie in der Google Cloud Console die Seite IAM auf.

      Zu „Reservierungen“

      Die verbleibenden Schritte werden automatisch in derGoogle Cloud Console angezeigt.

   2. Klicken Sie auf dem Tab On-Demand-Reservierung (Standard) auf add_box Reservierung erstellen. Die Seite Reservierung erstellen wird angezeigt.

   3. Geben Sie im Feld Name einen Namen für die Reservierung ein. Geben Sie beispielsweise reservation-02 ein.

   4. Geben Sie die Region und die Zone an, in der Sie Ressourcen reservieren möchten. Wählen Sie für dieses Beispiel us-central1 und us-central1-a aus.

   5. Führen Sie im Abschnitt Freigabetyp einen der folgenden Schritte aus:

      • Wenn Sie eine Reservierung für ein einzelnes Projekt erstellen möchten, wählen Sie Lokal aus.

      • Wenn Sie eine freigegebene Reservierung erstellen möchten, wählen Sie Freigegeben aus und geben Sie dann die Projekte an, für die Sie die Reservierung freigeben möchten.

   6. Wählen Sie im Abschnitt Mit VM-Instanz verwenden die Option Spezifische Reservierung auswählen aus.

   7. Geben Sie im Feld Anzahl der VM-Instanzen den Wert 3 ein.

   8. Wählen Sie auf dem Tab Allgemein die Option N2 aus.

   9. Wählen Sie im Bereich Maschinentyp auf dem Tab Voreinstellung (Standard) die Option n2-standard-32 aus.

   10. Maximieren Sie CPU-Plattform und GPU und wählen Sie dann im Feld CPU-Plattform die Option Intel Cascade Lake oder höher aus.

   11. Klicken Sie auf Erstellen.

2. So erstellen Sie eine Instanz, die die Beispielreservierung nutzt:

   1. Rufen Sie in der Google Cloud Console die Seite Instanz erstellen auf.

      Zur Seite „Instanz erstellen“

      Die Seite Instanz erstellen wird angezeigt und enthält den Bereich Maschinenkonfiguration.

   2. Führen Sie im Bereich „Maschinenkonfiguration“ die folgenden Schritte aus:

      1. Geben Sie im Feld Name einen Namen für die Instanz ein. Geben Sie für dieses Beispiel instance-02 ein.

      2. Geben Sie die Region und die Zone an, in der Sie Ressourcen reservieren möchten. Wählen Sie für dieses Beispiel us-central1 und us-central1-a aus.

      3. Wählen Sie auf dem Tab Allgemein die Option N2 aus.

      4. Wählen Sie im Bereich Maschinentyp auf dem Tab Voreinstellung (Standard) die Option n2-standard-32 aus.

      5. Maximieren Sie den Abschnitt Erweiterte Optionen und wählen Sie dann im Feld CPU-Plattform die Option Intel Cascade Lake oder höher aus.

   3. Klicken Sie im Navigationsmenü auf Erweitert. Der Bereich Erweitert wird angezeigt.

   4. Wählen Sie im Bereich Reservierungen die Option Reservierung auswählen und dann Reservierung auswählen aus.

   5. Führen Sie im angezeigten Bereich Reservierung auswählen die folgenden Schritte aus:

      1. Wählen Sie die spezifische Reservierung aus, die Sie in den vorherigen Schritten erstellt haben. Wenn Sie eine freigegebene Reservierung nutzen möchten, die in einem anderen Projekt vorhanden ist, wählen Sie in der Liste Projekt das Projekt aus, in dem sich die Reservierung befindet.

      2. Klicken Sie auf Auswählen.

   6. Klicken Sie auf Erstellen.

gcloud

Im folgenden Beispiel wird gezeigt, wie Sie eine bestimmte Reservierung in der Zone us-central1-a für drei N2-Instanzen mit 32 vCPUs und Intel Cascade Lake als Mindest-CPU-Plattform erstellen. Außerdem wird gezeigt, wie Sie eine einzelne Instanz erstellen, die die Reservierung nutzt.

So erstellen Sie die Beispielreservierung und nutzen sie:

1. Verwenden Sie zum Erstellen der Beispielreservierung den Befehl gcloud compute reservations create mit dem Flag --require-specific-reservation:

   gcloud compute reservations create reservation-02 \
       --machine-type=n2-standard-32 \
       --min-cpu-platform="Intel Cascade Lake" \
       --require-specific-reservation \
       --vm-count=3 \
       --zone=us-central1-a
   

2. Verwenden Sie zum Erstellen einer Instanz, die die Beispielreservierung nutzt, den Befehl gcloud compute instances create mit den Flags --reservation und --reservation-affinity=specific:

   gcloud compute instances create instance-02 \
       --machine-type=n2-standard-32 \
       --min-cpu-platform="Intel Cascade Lake" \
       --reservation-affinity=specific \
       --reservation=RESERVATION_URL \
       --zone=us-central1-a
   

   Ersetzen Sie RESERVATION_URL durch die URL der Reservierung. Geben Sie einen der folgenden Werte an:

   • Wenn Sie die Reservierung im selben Projekt erstellt haben: reservation-02

   • Wenn sich die Reservierung in einem anderen Projekt befindet: projects/PROJECT_ID/reservations/reservation-02

Go

In den folgenden Beispielen wird gezeigt, wie Sie eine N2-Instanz mit 32 vCPUs und Intel Cascade Lake als Mindest-CPU-Plattform in der Zone us-central1-a erstellen, um eine bestimmte, passende Reservierung zu nutzen:

• Verwenden Sie das folgende Codebeispiel, um die Beispielinstanz zum Verbrauchen einer spezifischen Reservierung für ein einzelnes Projekt zu erstellen:

  import (
  	"context"
  	"fmt"
  	"io"
  
  	compute "cloud.google.com/go/compute/apiv1"
  	computepb "cloud.google.com/go/compute/apiv1/computepb"
  	"google.golang.org/protobuf/proto"
  )
  
  // consumeSpecificReservation creates instance, consuming specific reservation
  // Note: respective reservation should have SpecificReservationRequired: true
  func consumeSpecificReservation(w io.Writer, projectID, zone, instanceName, reservationName string) error {
  	// projectID := "your_project_id"
  	// zone := "us-west3-a"
  	// reservationName := "your_reservation_name"
  	// instanceName := "your_instance_name"
  
  	ctx := context.Background()
  	machineType := fmt.Sprintf("zones/%s/machineTypes/%s", zone, "n2-standard-32")
  	sourceImage := "projects/debian-cloud/global/images/family/debian-12"
  
  	instancesClient, err := compute.NewInstancesRESTClient(ctx)
  	if err != nil {
  		return fmt.Errorf("NewInstancesRESTClient: %w", err)
  	}
  	defer instancesClient.Close()
  
  	req := &computepb.InsertInstanceRequest{
  		Project: projectID,
  		Zone:    zone,
  		InstanceResource: &computepb.Instance{
  			Disks: []*computepb.AttachedDisk{
  				{
  					InitializeParams: &computepb.AttachedDiskInitializeParams{
  						DiskSizeGb:  proto.Int64(10),
  						SourceImage: proto.String(sourceImage),
  					},
  					AutoDelete: proto.Bool(true),
  					Boot:       proto.Bool(true),
  					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
  				},
  			},
  			MachineType:    proto.String(machineType),
  			MinCpuPlatform: proto.String("Intel Cascade Lake"),
  			Name:           proto.String(instanceName),
  			NetworkInterfaces: []*computepb.NetworkInterface{
  				{
  					Name: proto.String("global/networks/default"),
  				},
  			},
  			// specifies particular reservation, which should be consumed
  			ReservationAffinity: &computepb.ReservationAffinity{
  				ConsumeReservationType: proto.String("SPECIFIC_RESERVATION"),
  				Key:                    proto.String("compute.googleapis.com/reservation-name"),
  				Values:                 []string{reservationName},
  			},
  		},
  	}
  
  	op, err := instancesClient.Insert(ctx, req)
  	if err != nil {
  		return fmt.Errorf("unable to create instance: %w", err)
  	}
  
  	if err = op.Wait(ctx); err != nil {
  		return fmt.Errorf("unable to wait for the operation: %w", err)
  	}
  	fmt.Fprintf(w, "Instance created from reservation\n")
  
  	return nil
  }
  

• Verwenden Sie das folgende Codebeispiel, um die Beispielinstanz zum Verbrauchen einer freigegebenen, bestimmten Reservierung zu erstellen:

  import (
  	"context"
  	"fmt"
  	"io"
  
  	computepb "cloud.google.com/go/compute/apiv1/computepb"
  	"google.golang.org/protobuf/proto"
  )
  
  // consumeSpecificSharedReservation consumes specific shared reservation in particular zone
  func consumeSpecificSharedReservation(w io.Writer, client InstanceClientInterface, projectID, baseProjectId, zone, instanceName, reservationName string) error {
  	// client, err := compute.NewInstancesRESTClient(ctx)
  	// projectID := "your_project_id". Project where reservation is created.
  	// baseProjectId := "shared_project_id". Project where instance will be consumed and created.
  	// zone := "us-west3-a"
  	// reservationName := "your_reservation_name"
  	// instanceName := "your_instance_name"
  
  	ctx := context.Background()
  	machineType := fmt.Sprintf("zones/%s/machineTypes/%s", zone, "n2-standard-32")
  	sourceImage := "projects/debian-cloud/global/images/family/debian-12"
  	sharedReservation := fmt.Sprintf("projects/%s/reservations/%s", baseProjectId, reservationName)
  
  	req := &computepb.InsertInstanceRequest{
  		Project: projectID,
  		Zone:    zone,
  		InstanceResource: &computepb.Instance{
  			Disks: []*computepb.AttachedDisk{
  				{
  					InitializeParams: &computepb.AttachedDiskInitializeParams{
  						DiskSizeGb:  proto.Int64(10),
  						SourceImage: proto.String(sourceImage),
  					},
  					AutoDelete: proto.Bool(true),
  					Boot:       proto.Bool(true),
  					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
  				},
  			},
  			MachineType:    proto.String(machineType),
  			MinCpuPlatform: proto.String("Intel Cascade Lake"),
  			Name:           proto.String(instanceName),
  			NetworkInterfaces: []*computepb.NetworkInterface{
  				{
  					Name: proto.String("global/networks/default"),
  				},
  			},
  			// specifies particular reservation, which should be consumed
  			ReservationAffinity: &computepb.ReservationAffinity{
  				ConsumeReservationType: proto.String("SPECIFIC_RESERVATION"),
  				Key:                    proto.String("compute.googleapis.com/reservation-name"),
  				Values:                 []string{sharedReservation},
  			},
  		},
  	}
  
  	op, err := client.Insert(ctx, req)
  	if err != nil {
  		return fmt.Errorf("unable to create instance: %w", err)
  	}
  
  	if op != nil {
  		if err = op.Wait(ctx); err != nil {
  			return fmt.Errorf("unable to wait for the operation: %w", err)
  		}
  	}
  	fmt.Fprintf(w, "Instance created from shared reservation\n")
  
  	return nil
  }
  

Java

In den folgenden Beispielen wird gezeigt, wie Sie eine N1-Instanz mit vier vCPUs und Intel Skylake als Mindest-CPU-Plattform in der Zone us-central1-a erstellen, um eine bestimmte, passende Reservierung zu nutzen:

• Verwenden Sie das folgende Codebeispiel, um eine Beispielreservierung als Reservierung für ein einzelnes Projekt zu erstellen und eine Instanz zu erstellen, die sie nutzt:

  import static com.google.cloud.compute.v1.ReservationAffinity.ConsumeReservationType.SPECIFIC_RESERVATION;
  
  import com.google.api.gax.longrunning.OperationFuture;
  import com.google.cloud.compute.v1.AttachedDisk;
  import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
  import com.google.cloud.compute.v1.InsertInstanceRequest;
  import com.google.cloud.compute.v1.Instance;
  import com.google.cloud.compute.v1.InstancesClient;
  import com.google.cloud.compute.v1.NetworkInterface;
  import com.google.cloud.compute.v1.Operation;
  import com.google.cloud.compute.v1.ReservationAffinity;
  import java.io.IOException;
  import java.util.concurrent.ExecutionException;
  import java.util.concurrent.TimeUnit;
  import java.util.concurrent.TimeoutException;
  
  public class ConsumeSingleProjectReservation {
    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 zone where the reservation is located.
      String zone = "us-central1-a";
      // Name of the reservation you want to query.
      String reservationName = "YOUR_RESERVATION_NAME";
      // Name of the VM instance you want to query.
      String instanceName = "YOUR_INSTANCE_NAME";
      // machineType: machine type of the VM being created.
      // *   For a list of machine types, see https://cloud.google.com/compute/docs/machine-types
      String machineTypeName = "n1-standard-4";
      // sourceImage: path to the operating system image to mount.
      // *   For details about images you can mount, see https://cloud.google.com/compute/docs/images
      String sourceImage = "projects/debian-cloud/global/images/family/debian-11";
      // diskSizeGb: storage size of the boot disk to attach to the instance.
      long diskSizeGb = 10L;
      // networkName: network interface to associate with the instance.
      String networkName = "default";
      // Minimum CPU platform of the instances.
      String minCpuPlatform = "Intel Skylake";
  
      createInstanceAsync(projectId, zone, instanceName, reservationName, machineTypeName,
          sourceImage, diskSizeGb, networkName, minCpuPlatform);
    }
  
    // Create a virtual machine targeted with the reserveAffinity field.
    // Ensure that the VM's properties match the reservation's VM properties.
    public static Instance createInstanceAsync(String projectId, String zone, String instanceName,
        String reservationName, String machineTypeName, String sourceImage, long diskSizeGb,
        String networkName, String minCpuPlatform)
        throws IOException, InterruptedException, ExecutionException, TimeoutException {
      String machineType = String.format("zones/%s/machineTypes/%s", zone, machineTypeName);
      // 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 (InstancesClient instancesClient = InstancesClient.create()) {
        AttachedDisk disk =
            AttachedDisk.newBuilder()
                .setBoot(true)
                .setAutoDelete(true)
                .setType(AttachedDisk.Type.PERSISTENT.toString())
                .setDeviceName("disk-1")
                .setInitializeParams(
                    AttachedDiskInitializeParams.newBuilder()
                        .setSourceImage(sourceImage)
                        .setDiskSizeGb(diskSizeGb)
                        .build())
                .build();
  
        NetworkInterface networkInterface = NetworkInterface.newBuilder()
            .setName(networkName)
            .build();
  
        ReservationAffinity reservationAffinity =
            ReservationAffinity.newBuilder()
                .setConsumeReservationType(SPECIFIC_RESERVATION.toString())
                .setKey("compute.googleapis.com/reservation-name")
                // Set specific reservation
                .addValues(reservationName)
                .build();
  
        Instance instanceResource =
            Instance.newBuilder()
                .setName(instanceName)
                .setMachineType(machineType)
                .addDisks(disk)
                .addNetworkInterfaces(networkInterface)
                .setMinCpuPlatform(minCpuPlatform)
                .setReservationAffinity(reservationAffinity)
                .build();
  
        InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
            .setProject(projectId)
            .setZone(zone)
            .setInstanceResource(instanceResource)
            .build();
  
        OperationFuture<Operation, Operation> operation = instancesClient.insertAsync(
            insertInstanceRequest);
        Operation response = operation.get(3, TimeUnit.MINUTES);
  
        if (response.hasError()) {
          return null;
        }
        return instancesClient.get(projectId, zone, instanceName);
      }
    }
  }

• Mit dem folgenden Codebeispiel können Sie eine Beispielreservierung als freigegebene Reservierung erstellen und eine Instanz erstellen, um sie zu nutzen:

  import static com.google.cloud.compute.v1.ReservationAffinity.ConsumeReservationType.SPECIFIC_RESERVATION;
  
  import com.google.api.gax.longrunning.OperationFuture;
  import com.google.cloud.compute.v1.AttachedDisk;
  import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
  import com.google.cloud.compute.v1.InsertInstanceRequest;
  import com.google.cloud.compute.v1.Instance;
  import com.google.cloud.compute.v1.InstancesClient;
  import com.google.cloud.compute.v1.NetworkInterface;
  import com.google.cloud.compute.v1.Operation;
  import com.google.cloud.compute.v1.ReservationAffinity;
  import java.io.IOException;
  import java.util.concurrent.ExecutionException;
  import java.util.concurrent.TimeUnit;
  import java.util.concurrent.TimeoutException;
  
  public class ConsumeSpecificSharedReservation {
    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 zone the reservation is located.
      String zone = "us-central1-a";
      // Name of the reservation you want to query.
      String reservationName = "YOUR_RESERVATION_NAME";
      // Name of the VM instance you want to query.
      String instanceName = "YOUR_INSTANCE_NAME";
      // machineType: machine type of the VM being created.
      // *   For a list of machine types, see https://cloud.google.com/compute/docs/machine-types
      String machineTypeName = "n1-standard-4";
      // sourceImage: path to the operating system image to mount.
      // *   For details about images you can mount, see https://cloud.google.com/compute/docs/images
      String sourceImage = "projects/debian-cloud/global/images/family/debian-11";
      // diskSizeGb: storage size of the boot disk to attach to the instance.
      long diskSizeGb = 10L;
      // networkName: network interface to associate with the instance.
      String networkName = "default";
      // Minimum CPU platform of the instances.
      String minCpuPlatform = "Intel Skylake";
  
      createInstanceAsync(projectId, zone, instanceName, reservationName, machineTypeName,
          sourceImage, diskSizeGb, networkName, minCpuPlatform);
    }
  
    // Create a virtual machine targeted with the reserveAffinity field.
    // Ensure that the VM's properties match the reservation's VM properties.
    public static Instance createInstanceAsync(String projectId, String zone, String instanceName,
        String reservationName, String machineTypeName, String sourceImage, long diskSizeGb,
        String networkName, String minCpuPlatform)
        throws IOException, InterruptedException, ExecutionException, TimeoutException {
      String machineType = String.format("zones/%s/machineTypes/%s", zone, machineTypeName);
      // To consume this reservation from any consumer projects that this reservation is shared with,
      // you must also specify the owner project of the reservation - the path to the reservation.
      String reservationPath =
          String.format("projects/%s/reservations/%s", projectId, reservationName);
      // 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 (InstancesClient instancesClient = InstancesClient.create()) {
        AttachedDisk disk =
            AttachedDisk.newBuilder()
                .setBoot(true)
                .setAutoDelete(true)
                .setType(AttachedDisk.Type.PERSISTENT.toString())
                .setDeviceName("disk-1")
                .setInitializeParams(
                    AttachedDiskInitializeParams.newBuilder()
                        .setSourceImage(sourceImage)
                        .setDiskSizeGb(diskSizeGb)
                        .build())
                .build();
  
        NetworkInterface networkInterface = NetworkInterface.newBuilder()
            .setName(networkName)
            .build();
  
        ReservationAffinity reservationAffinity =
            ReservationAffinity.newBuilder()
                .setConsumeReservationType(SPECIFIC_RESERVATION.toString())
                .setKey("compute.googleapis.com/reservation-name")
                // Set specific reservation
                .addValues(reservationPath)
                .build();
  
        Instance instanceResource =
            Instance.newBuilder()
                .setName(instanceName)
                .setMachineType(machineType)
                .addDisks(disk)
                .addNetworkInterfaces(networkInterface)
                .setMinCpuPlatform(minCpuPlatform)
                .setReservationAffinity(reservationAffinity)
                .build();
  
        InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
            .setProject(projectId)
            .setZone(zone)
            .setInstanceResource(instanceResource)
            .build();
  
        OperationFuture<Operation, Operation> operation = instancesClient.insertAsync(
            insertInstanceRequest);
        Operation response = operation.get(3, TimeUnit.MINUTES);
  
        if (response.hasError()) {
          return null;
        }
        return instancesClient.get(projectId, zone, instanceName);
      }
    }
  }

Node.js

In den folgenden Beispielen wird gezeigt, wie Sie eine N1-Instanz mit 4 vCPUs und Intel Skylake als Mindest-CPU-Plattform in der Zone us-central1-a erstellen, um eine bestimmte, passende Reservierung zu nutzen:

// Import the Compute library
const computeLib = require('@google-cloud/compute');
const compute = computeLib.protos.google.cloud.compute.v1;

// Instantiate a reservationsClient
const instancesClient = new computeLib.InstancesClient();
// Instantiate a zoneOperationsClient
const zoneOperationsClient = new computeLib.ZoneOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The ID of the project where you want to create instance.
const projectId = await instancesClient.getProjectId();
// The zone in which to create instance.
const zone = 'us-central1-a';
// The name of the instance to create.
// const instanceName = 'instance-01';
// The name of the reservation to consume.
// Ensure that the specificReservationRequired field in reservation properties is set to true.
// const reservationName = 'reservation-01';
// Machine type to use for VM.
const machineType = 'n1-standard-4';

// Create instance to consume a specific single-project reservation
async function callCreateInstanceToConsumeSingleProjectReservation() {
  // Describe the size and source image of the boot disk to attach to the instance.
  // Ensure that the VM's properties match the reservation's VM properties,
  // including the zone, machine type (machine family, vCPUs, and memory),
  // minimum CPU platform, GPU amount and type, and local SSD interface and size
  const disk = new compute.Disk({
    boot: true,
    autoDelete: true,
    type: 'PERSISTENT',
    initializeParams: {
      diskSizeGb: '10',
      sourceImage: 'projects/debian-cloud/global/images/family/debian-12',
    },
  });

  //  Define networkInterface
  const networkInterface = new compute.NetworkInterface({
    name: 'global/networks/default',
  });

  // Define reservationAffinity
  const reservationAffinity = new compute.ReservationAffinity({
    consumeReservationType: 'SPECIFIC_RESERVATION',
    key: 'compute.googleapis.com/reservation-name',
    values: [reservationName],
  });

  // Create an instance
  const instance = new compute.Instance({
    name: instanceName,
    machineType: `zones/${zone}/machineTypes/${machineType}`,
    minCpuPlatform: 'Intel Skylake',
    disks: [disk],
    networkInterfaces: [networkInterface],
    reservationAffinity,
  });

  const [response] = await instancesClient.insert({
    project: projectId,
    instanceResource: instance,
    zone,
  });

  let operation = response.latestResponse;

  // Wait for the create instance operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await zoneOperationsClient.wait({
      operation: operation.name,
      project: projectId,
      zone: operation.zone.split('/').pop(),
    });
  }

  console.log(`Instance ${instanceName} created.`);
}

await callCreateInstanceToConsumeSingleProjectReservation();

Python

In den folgenden Beispielen wird gezeigt, wie Sie eine N2-Instanz mit 32 vCPUs und Intel Cascade Lake als Mindest-CPU-Plattform in der Zone us-central1-a erstellen, um eine bestimmte, passende Reservierung zu nutzen:

So erstellen Sie die Beispielreservierung und nutzen sie:

• Verwenden Sie das folgende Codebeispiel, um die Beispielreservierung als Reservierung für ein einzelnes Projekt zu erstellen und zu nutzen:

  from __future__ import annotations
  
  import sys
  from typing import Any
  
  from google.api_core.extended_operation import ExtendedOperation
  from google.cloud import compute_v1
  
  
  def wait_for_extended_operation(
      operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
  ) -> Any:
      """
      Waits for the extended (long-running) operation to complete.
  
      If the operation is successful, it will return its result.
      If the operation ends with an error, an exception will be raised.
      If there were any warnings during the execution of the operation
      they will be printed to sys.stderr.
  
      Args:
          operation: a long-running operation you want to wait on.
          verbose_name: (optional) a more verbose name of the operation,
              used only during error and warning reporting.
          timeout: how long (in seconds) to wait for operation to finish.
              If None, wait indefinitely.
  
      Returns:
          Whatever the operation.result() returns.
  
      Raises:
          This method will raise the exception received from `operation.exception()`
          or RuntimeError if there is no exception set, but there is an `error_code`
          set for the `operation`.
  
          In case of an operation taking longer than `timeout` seconds to complete,
          a `concurrent.futures.TimeoutError` will be raised.
      """
      result = operation.result(timeout=timeout)
  
      if operation.error_code:
          print(
              f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
              file=sys.stderr,
              flush=True,
          )
          print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
          raise operation.exception() or RuntimeError(operation.error_message)
  
      if operation.warnings:
          print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
          for warning in operation.warnings:
              print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)
  
      return result
  
  
  def consume_specific_single_project_reservation(
      project_id: str,
      zone: str,
      reservation_name: str,
      instance_name: str,
      machine_type: str = "n1-standard-1",
      min_cpu_platform: str = "Intel Ivy Bridge",
  ) -> compute_v1.Instance:
      """
      Creates a specific reservation in a single project and launches a VM
      that consumes the newly created reservation.
      Args:
          project_id (str): The ID of the Google Cloud project.
          zone (str): The zone to create the reservation.
          reservation_name (str): The name of the reservation to create.
          instance_name (str): The name of the instance to create.
          machine_type (str): The machine type for the instance.
          min_cpu_platform (str): The minimum CPU platform for the instance.
      """
      instance_properties = (
          compute_v1.AllocationSpecificSKUAllocationReservedInstanceProperties(
              machine_type=machine_type,
              min_cpu_platform=min_cpu_platform,
          )
      )
  
      reservation = compute_v1.Reservation(
          name=reservation_name,
          specific_reservation=compute_v1.AllocationSpecificSKUReservation(
              count=3,
              instance_properties=instance_properties,
          ),
          # Only VMs that target the reservation by name can consume from this reservation
          specific_reservation_required=True,
      )
  
      # Create a reservation client
      client = compute_v1.ReservationsClient()
      operation = client.insert(
          project=project_id,
          zone=zone,
          reservation_resource=reservation,
      )
      wait_for_extended_operation(operation, "Reservation creation")
  
      instance = compute_v1.Instance()
      instance.name = instance_name
      instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
      instance.min_cpu_platform = min_cpu_platform
      instance.zone = zone
  
      # Set the reservation affinity to target the specific reservation
      instance.reservation_affinity = compute_v1.ReservationAffinity(
          consume_reservation_type="SPECIFIC_RESERVATION",  # Type of reservation to consume
          key="compute.googleapis.com/reservation-name",  # Key for the reservation
          values=[reservation_name],  # Reservation name to consume
      )
      # Define the disks for the instance
      instance.disks = [
          compute_v1.AttachedDisk(
              boot=True,  # Indicates that this is a boot disk
              auto_delete=True,  # The disk will be deleted when the instance is deleted
              initialize_params=compute_v1.AttachedDiskInitializeParams(
                  source_image="projects/debian-cloud/global/images/family/debian-11",
                  disk_size_gb=10,
              ),
          )
      ]
      instance.network_interfaces = [
          compute_v1.NetworkInterface(
              network="global/networks/default",  # The network to use
              access_configs=[
                  compute_v1.AccessConfig(
                      name="External NAT",  # Name of the access configuration
                      type="ONE_TO_ONE_NAT",  # Type of access configuration
                  )
              ],
          )
      ]
      # Create a request to insert the instance
      request = compute_v1.InsertInstanceRequest()
      request.zone = zone
      request.project = project_id
      request.instance_resource = instance
  
      vm_client = compute_v1.InstancesClient()
      operation = vm_client.insert(request)
      wait_for_extended_operation(operation, "instance creation")
      print(f"Instance {instance_name} with specific reservation created successfully.")
  
      return vm_client.get(project=project_id, zone=zone, instance=instance_name)
  
  

• Verwenden Sie das folgende Codebeispiel, um die Beispielreservierung als freigegebene Reservierung zu erstellen und zu nutzen:

  from __future__ import annotations
  
  import sys
  from typing import Any
  
  from google.api_core.extended_operation import ExtendedOperation
  from google.cloud import compute_v1
  
  
  def wait_for_extended_operation(
      operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
  ) -> Any:
      """
      Waits for the extended (long-running) operation to complete.
  
      If the operation is successful, it will return its result.
      If the operation ends with an error, an exception will be raised.
      If there were any warnings during the execution of the operation
      they will be printed to sys.stderr.
  
      Args:
          operation: a long-running operation you want to wait on.
          verbose_name: (optional) a more verbose name of the operation,
              used only during error and warning reporting.
          timeout: how long (in seconds) to wait for operation to finish.
              If None, wait indefinitely.
  
      Returns:
          Whatever the operation.result() returns.
  
      Raises:
          This method will raise the exception received from `operation.exception()`
          or RuntimeError if there is no exception set, but there is an `error_code`
          set for the `operation`.
  
          In case of an operation taking longer than `timeout` seconds to complete,
          a `concurrent.futures.TimeoutError` will be raised.
      """
      result = operation.result(timeout=timeout)
  
      if operation.error_code:
          print(
              f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
              file=sys.stderr,
              flush=True,
          )
          print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
          raise operation.exception() or RuntimeError(operation.error_message)
  
      if operation.warnings:
          print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
          for warning in operation.warnings:
              print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)
  
      return result
  
  
  def consume_specific_shared_project_reservation(
      owner_project_id: str,
      shared_project_id: str,
      zone: str,
      reservation_name: str,
      instance_name: str,
      machine_type: str = "n1-standard-1",
      min_cpu_platform: str = "Intel Ivy Bridge",
  ) -> compute_v1.Instance:
      """
      Creates a specific reservation in a single project and launches a VM
      that consumes the newly created reservation.
      Args:
          owner_project_id (str): The ID of the Google Cloud project.
          shared_project_id: The ID of the owner project of the reservation in the same zone.
          zone (str): The zone to create the reservation.
          reservation_name (str): The name of the reservation to create.
          instance_name (str): The name of the instance to create.
          machine_type (str): The machine type for the instance.
          min_cpu_platform (str): The minimum CPU platform for the instance.
      """
      instance_properties = (
          compute_v1.AllocationSpecificSKUAllocationReservedInstanceProperties(
              machine_type=machine_type,
              min_cpu_platform=min_cpu_platform,
          )
      )
  
      reservation = compute_v1.Reservation(
          name=reservation_name,
          specific_reservation=compute_v1.AllocationSpecificSKUReservation(
              count=3,
              instance_properties=instance_properties,
          ),
          # Only VMs that target the reservation by name can consume from this reservation
          specific_reservation_required=True,
          share_settings=compute_v1.ShareSettings(
              share_type="SPECIFIC_PROJECTS",
              project_map={
                  shared_project_id: compute_v1.ShareSettingsProjectConfig(
                      project_id=shared_project_id
                  )
              },
          ),
      )
  
      # Create a reservation client
      client = compute_v1.ReservationsClient()
      operation = client.insert(
          project=owner_project_id,
          zone=zone,
          reservation_resource=reservation,
      )
      wait_for_extended_operation(operation, "Reservation creation")
  
      instance = compute_v1.Instance()
      instance.name = instance_name
      instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
      instance.min_cpu_platform = min_cpu_platform
      instance.zone = zone
  
      # Set the reservation affinity to target the specific reservation
      instance.reservation_affinity = compute_v1.ReservationAffinity(
          consume_reservation_type="SPECIFIC_RESERVATION",  # Type of reservation to consume
          key="compute.googleapis.com/reservation-name",
          # To consume this reservation from any consumer projects, specify the owner project of the reservation
          values=[f"projects/{owner_project_id}/reservations/{reservation_name}"],
      )
      # Define the disks for the instance
      instance.disks = [
          compute_v1.AttachedDisk(
              boot=True,  # Indicates that this is a boot disk
              auto_delete=True,  # The disk will be deleted when the instance is deleted
              initialize_params=compute_v1.AttachedDiskInitializeParams(
                  source_image="projects/debian-cloud/global/images/family/debian-11",
                  disk_size_gb=10,
              ),
          )
      ]
      instance.network_interfaces = [
          compute_v1.NetworkInterface(
              network="global/networks/default",  # The network to use
              access_configs=[
                  compute_v1.AccessConfig(
                      name="External NAT",  # Name of the access configuration
                      type="ONE_TO_ONE_NAT",  # Type of access configuration
                  )
              ],
          )
      ]
      # Create a request to insert the instance
      request = compute_v1.InsertInstanceRequest()
      request.zone = zone
      # The instance will be created in the shared project
      request.project = shared_project_id
      request.instance_resource = instance
  
      vm_client = compute_v1.InstancesClient()
      operation = vm_client.insert(request)
      wait_for_extended_operation(operation, "instance creation")
      print(f"Instance {instance_name} from project {owner_project_id} created.")
      # The instance is created in the shared project, so we return it from there.
      return vm_client.get(project=shared_project_id, zone=zone, instance=instance_name)
  
  

REST

Im folgenden Beispiel wird gezeigt, wie Sie eine bestimmte Reservierung in der Zone us-central1-a für drei N2-Instanzen mit 32 vCPUs und Intel Cascade Lake als Mindest-CPU-Plattform erstellen. Außerdem wird gezeigt, wie Sie eine einzelne Instanz erstellen, die die Reservierung nutzt.

So erstellen Sie die Beispielreservierung und nutzen sie:

1. Senden Sie zum Erstellen der Beispielreservierung eine POST-Anfrage an die Methode instances.insert. Geben Sie im Anfragetext das Feld specificReservationRequired an, das auf true gesetzt ist:

   POST https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/reservations
   
   {
     "name": "reservation-02",
     "specificReservation": {
       "count": "3",
       "instanceProperties": {
         "machineType": "n2-standard-32",
         "minCpuPlatform": "Intel Cascade Lake",
       }
     },
     "specificReservationRequired": true
   }
   

2. Wenn Sie eine Instanz erstellen möchten, die die Beispielreservierung nutzt, stellen Sie eine POST-Anfrage an die Methode instances.insert. Geben Sie im Anfragetext im Feld reservationAffinity Folgendes an:

   • Das Feld consumeReservationType ist auf SPECIFIC_RESERVATION gesetzt.

   • Das Feld key ist auf compute.googleapis.com/reservation-name gesetzt.

   • Das Feld values ist auf die URL der Reservierung festgelegt.

   Die Anfrage sieht etwa so aus:

   POST https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/instances
   
   {
     "name": "instance-02",
     "machineType": "zones/us-central1-a/machineTypes/n2-standard-32",
     "minCpuPlatform": "Intel Cascade Lake",
     "disks": [
       {
         "boot": true,
         "initializeParams": {
           "sourceImage": "projects/debian-cloud/global/images/family/debian-12"
         }
       }
     ],
     "networkInterfaces": [
       {
         "network": "global/networks/default"
       }
     ],
     "reservationAffinity": {
       "consumeReservationType": "SPECIFIC_RESERVATION",
       "key": "compute.googleapis.com/reservation-name",
       "values": [
         "RESERVATION_URL"
       ]
     }
   }
   

   Ersetzen Sie RESERVATION_URL durch die URL der Reservierung. Geben Sie einen der folgenden Werte an:

   • Wenn Sie die Reservierung im selben Projekt erstellt haben: reservation-02

   • Wenn sich die Reservierung in einem anderen Projekt befindet: projects/PROJECT_ID/reservations/reservation-02

Console

1. Erstellen Sie eine Beispielanfrage für fünf A3 Ultra-Instanzen und senden Sie sie zur Überprüfung:

   1. Rufen Sie in der Google Cloud Console die Seite IAM auf.

      Zu „Reservierungen“

   2. Klicken Sie auf den Tab Zukünftige Reservierungen.

   3. Klicken Sie auf add_boxZukünftige Reservierung erstellen. Die Seite Zukünftige Reservierung erstellen wird angezeigt.

   4. Wählen Sie im Abschnitt Hardwarekonfiguration die Option Maschinentyp angeben aus und geben Sie eine A3 Ultra-Instanz an.

   5. Führen Sie im Bereich Methode zur Erlangung die folgenden Schritte aus:

      1. Wählen Sie Nach Kapazität für bis zu 90 Tage suchen aus.

      2. Geben Sie in den Listen Region und Zone die Region und Zone an, in der Ressourcen reserviert werden sollen. Wählen Sie für dieses Beispiel us-central1 bzw. us-central1-a aus.

      3. Geben Sie im Feld Benötigte Gesamtkapazität den Wert 5 ein.

      4. Geben Sie im Abschnitt Reservierungszeitraum den Reservierungszeitraum für die Reservierung an.

   6. Geben Sie die restlichen Felder an und klicken Sie dann auf Senden.

2. So erstellen Sie zum Startzeitpunkt der Anfrage eine A3 Ultra-Instanz, um die automatisch erstellte Beispielreservierung zu nutzen:

   1. Rufen Sie in der Google Cloud Console die Seite Instanz erstellen auf.

      Zur Seite „Instanz erstellen“

   2. Geben Sie im Feld Name einen Namen für die Instanz ein. Geben Sie für dieses Beispiel example-instance ein.

   3. Geben Sie die Region und die Zone an, in der Sie Ressourcen reservieren möchten. Wählen Sie für dieses Beispiel us-central1 bzw. us-central1-a aus.

   4. Klicken Sie auf den Tab GPUs und wählen Sie dann in der Liste GPU-Typ die Option NVIDIA H200 141 GB aus. Mit dieser Aktion wird eine A3 Ultra-Instanz angegeben und das Bereitstellungsmodell auf Reservierungsgebunden festgelegt.

   5. Klicken Sie im Navigationsmenü auf Erweitert.

   6. Wählen Sie im Bereich Reservierungen die Option Reservierung auswählen und dann Reservierung auswählen aus.

   7. Führen Sie im Bereich Reservierung auswählen die folgenden Schritte aus:

      1. Wählen Sie eine bestimmte Reservierung aus. Wenn Sie eine freigegebene Reservierung nutzen möchten, die in einem anderen Projekt vorhanden ist, wählen Sie in der Liste Projekt das Projekt aus, in dem sich die Reservierung befindet.

      2. Klicken Sie auf Auswählen.

   8. Maximieren Sie im Abschnitt Bereitstellungsmodell den Abschnitt Erweiterte Einstellungen für das VM-Bereitstellungsmodell.

   9. Wählen Sie in der Liste Bei VM-Beendigung die Option Beenden (Standardeinstellung) oder Löschen aus.

   10. Klicken Sie auf Erstellen.

gcloud

1. Wenn Sie eine Beispielanfrage für fünf A3 Ultra-VMs erstellen und zur Überprüfung einreichen möchten, verwenden Sie den Befehl gcloud beta compute future-reservations create:

   gcloud beta compute future-reservations create example-fr \
       --auto-delete-auto-created-reservations \
       --deployment-type=DENSE \
       --planning-status=SUBMITTED \
       --require-specific-reservation \
       --reservation-mode=CALENDAR \
       --reservation-name=example-reservation \
       --share-type=local \
       --start-time=2025-10-05T00:00:00Z \
       --end-time=2025-10-19T00:00:00Z \
       --machine-type=a3-ultragpu-8g \
       --total-count=5 \
       --zone=us-central1-a
   

   Angenommen, Google Cloud genehmigt die Anfrage und Compute Engine erstellt automatisch eine leere Reservierung. Zur Startzeit der Anfrage am 5. Oktober 2025 erhöht Compute Engine die Anzahl der reservierten GPU-VMs in der Reservierung. Anschließend können Sie die Reservierung nutzen.

2. Verwenden Sie zum Erstellen einer A3 Ultra-Instanz zur Nutzung der automatisch erstellten Beispielreservierung zur Startzeit der Anfrage den Befehl gcloud compute instances create mit den folgenden Flags:

   • Das Flag --instance-termination-action.

   • Das Flag --provisioning-model, das auf RESERVATION_BOUND gesetzt ist.

   • Das Flag --reservation.

   • Das Flag --reservation-affinity, das auf specific gesetzt ist.

   Der Befehl sieht in etwa so aus: Die vollständigen Anforderungen zum Erstellen einer A3 Ultra-Instanz finden Sie unter A3 Ultra- oder A4-Instanz erstellen.

   gcloud compute instance create example-instance  \
       --machine-type=a3-ultragpu-8g \
       --instance-termination-action=TERMINATION_ACTION \
       --provisioning-model=RESERVATION_BOUND \
       --reservation-affinity=specific \
       --reservation=RESERVATION_URL \
       --zone=us-central1-a \
       ...
   

   Der Befehl enthält die folgenden Werte:

   • TERMINATION_ACTION: Gibt an, ob Compute Engine die VM am Ende des Reservierungszeitraums beendet (STOP) oder löscht (DELETE).

   • RESERVATION_URL: die URL der Reservierung, die so formatiert ist:

     • Wenn die automatisch erstellte Reservierung in Ihrem Projekt vorhanden ist: example-reservation.

     • Wenn die automatisch erstellte Reservierung in einem anderen Projekt vorhanden ist: projects/PROJECT_ID/reservations/example-reservation.

REST

1. Wenn Sie eine Beispielanfrage für fünf A3 Ultra-Instanzen erstellen und zur Überprüfung einreichen möchten, stellen Sie eine POST-Anfrage an die Betamethode futureReservations.insert:

   POST https://compute.googleapis.com/compute/beta/projects/example-project/zones/us-central1-a/futureReservations
   
   {
     "name": "example-request-calendar-mode",
     "autoDeleteAutoCreatedReservations": true,
     "deploymentType": "DENSE",
     "planningStatus": "SUBMITTED",
     "reservationMode": "CALENDAR",
     "reservationName": "example-reservation",
     "shareSettings": {
       "shareType": "LOCAL"
     },
     "specificReservationRequired": true,
     "specificSkuProperties": {
       "machineType": "a3-ultragpu-8g",
       "totalCount": 5
     },
     "timeWindow": {
       "startTime": "2025-10-05T00:00:00Z",
       "endTime": "2025-10-19T00:00:00Z"
     }
   }
   

   Angenommen, Google Cloud genehmigt die Anfrage und Compute Engine erstellt automatisch eine leere Reservierung. Zur Startzeit der Anfrage am 5. Oktober 2025 erhöht Compute Engine die Anzahl der reservierten GPU-VMs in der Reservierung. Anschließend können Sie die Reservierung nutzen.

2. Wenn Sie zum Startzeitpunkt der Anfrage eine A3 Ultra-Instanz erstellen möchten, um die automatisch erstellte Beispielreservierung zu nutzen, senden Sie eine POST-Anfrage an die Methode instances.insert. Geben Sie im Anfragetext die folgenden Felder an:

   • Das Feld reservationAffinity.consumeReservationType ist auf SPECIFIC_RESERVATION gesetzt.

   • Das Feld reservationAffinity.key ist auf compute.googleapis.com/reservation-name gesetzt.

   • Das Feld reservationAffinity.values ist auf die URL der Reservierung festgelegt.

   • Das Feld scheduling.instanceTerminationAction.

   • Das Feld scheduling.provisioningModel ist auf RESERVATION_BOUND gesetzt.

   Die Anfrage sieht in etwa so aus: Die vollständigen Anforderungen zum Erstellen einer A3 Ultra-Instanz finden Sie unter A3 Ultra- oder A4-Instanz erstellen.

   POST https://compute.googleapis.com/compute/beta/projects/example-project/zones/us-central1-a/
   
   {
     {
       "machineType": "projects/example-project/zones/us-central1-a/machineTypes/a3-ultragpu-8g",
       "name": "example-instance",
       "reservationAffinity": {
         "consumeReservationType": "SPECIFIC_RESERVATION",
         "key": "compute.googleapis.com/reservation-name",
         "values":[
           "RESERVATION_URL"
         ],
       },
       "scheduling": {
         "instanceTerminationAction": "TERMINATION_ACTION",
         "provisioningModel": "RESERVATION_BOUND"
       },
       ...
     }
   }
   

   Der Anfragetext enthält die folgenden Werte:

   • RESERVATION_URL: die URL der Reservierung, die so formatiert ist:

     • Wenn die automatisch erstellte Reservierung in Ihrem Projekt vorhanden ist: example-reservation.

     • Wenn die automatisch erstellte Reservierung in einem anderen Projekt vorhanden ist: projects/PROJECT_ID/reservations/example-reservation.

   • TERMINATION_ACTION: Gibt an, ob Compute Engine die VM am Ende des Reservierungszeitraums beendet (STOP) oder löscht (DELETE).