Reservierungen nutzen

In diesem Dokument wird erläutert, wie Sie Reservierungen inCompute Engine nutzen. Informationen zur Nutzung von Reservierungen in anderen Google Cloud-Produkten, die Reservierungen unterstützen, finden Sie in der folgenden Dokumentation:

Nachdem Sie eine Reservierung erstellt haben oder Compute Engine automatisch eine Reservierung für Sie erstellt hat, um eine vorausschauende Reservierung oder eine vorausschauende Reservierung im Kalendermodus zu erfüllen, hält Compute Engine Ihre reservierten Ressourcen für Ihr Projekt und alle Projekte, mit denen Sie die Reservierung teilen, bereit. Wenn Sie Compute Engine-Instanzen erstellen, die den Attributen der Reservierung entsprechen, verbrauchen Sie die Reservierung, indem Sie die reservierten Ressourcen zum Erstellen Ihrer Compute-Instanzen verwenden, anstatt die verfügbaren Ressourcen in der Zone der Compute-Instanzen zu verwenden. Sie können Ihre Reservierung zum Erstellen von Compute-Instanzen verwenden, bis die Reservierung vollständig verbraucht ist.

Beschränkungen

Sie können eine Reservierung nicht verwenden, um die folgenden Compute Engine-Ressourcen zu erstellen:

  • Flex-Start-VMs

  • Spot-VMs oder Instanzen auf Abruf

  • Knoten für einzelne Mandanten

Hinweis

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen zuzuweisen, um die Berechtigungen zu erhalten, die Sie zur Nutzung von Reservierungen benötigen:

  • So nutzen Sie eine Reservierung: Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1) für das Projekt
  • So nutzen Sie eine freigegebene Reservierung aus einem Nutzerprojekt: Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1) für das Inhaberprojekt und das Nutzerprojekt

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

Diese vordefinierten Rollen enthalten die Berechtigungen, die zum Verwenden von Reservierungen erforderlich sind. Maximieren Sie den Abschnitt Erforderliche Berechtigungen, um die notwendigen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind zum Nutzen von Reservierungen erforderlich:

  • Zum Erstellen von Reservierungen: compute.reservations.create für das Projekt
  • So erstellen Sie Compute-Instanzen:
    • compute.instances.create für das Projekt
    • Zum Erstellen der VM mit einem benutzerdefinierten Image: compute.images.useReadOnly für das Image
    • Zum Erstellen der VM mit einem Snapshot: compute.snapshots.useReadOnly für den Snapshot
    • Zum Erstellen der VM mit einer Instanzvorlage: compute.instanceTemplates.useReadOnly für die Instanzvorlage
    • Zum Zuweisen eines Legacy-Netzwerks zur VM: compute.networks.use für das Projekt
    • Zum Festlegen einer statische IP-Adresse für die VM: compute.addresses.use für das Projekt
    • Zum Zuweisen einer externen IP-Adresse zur VM bei Verwendung eines Legacy-Netzwerks: compute.networks.useExternalIp für das Projekt
    • Zum Angeben eines Subnetzes für die VM: compute.subnetworks.use für das Projekt oder für das ausgewählte Subnetz
    • Zum Zuweisen einer externen IP-Adresse zur VM, wenn Sie ein VPC-Netzwerk verwenden: compute.subnetworks.useExternalIp für das Projekt oder für das ausgewählte Subnetz
    • Zum Festlegen von Metadaten der VM-Instanz für die VM: compute.instances.setMetadata für das Projekt
    • Zum Festlegen von Tags für die VM: compute.instances.setTags für die VM
    • Zum Festlegen von Labels für die VM: compute.instances.setLabels für die VM
    • Zum Festlegen eines Dienstkontos, das die VM verwenden soll: compute.instances.setServiceAccount für die VM
    • Zum Erstellen eines neuen Laufwerks für die VM: compute.disks.create für das Projekt
    • Zum Anhängen eines vorhandenen Laufwerks im Lese- oder Lese-/Schreibmodus: compute.disks.use für das Laufwerk
    • Zum Anhängen eines vorhandenen Laufwerks im Lesemodus: compute.disks.useReadOnly für das Laufwerk
  • Zum Erstellen von Instanzvorlagen: compute.instanceTemplates.create für das Projekt

Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Reservierung nutzen

In den Beispielen in den folgenden Abschnitten wird gezeigt, wie Sie eine Reservierung nutzen, indem Sie eine einzelne Compute-Instanz erstellen. Sie können Reservierungen auch nutzen, indem Sie Compute-Instanzen erstellen, die den Attributen der Reservierungen entsprechen. Verwenden Sie dazu eine andere Bereitstellungsoption oder aktualisieren Sie die Attribute vorhandener Compute-Instanzen, damit sie Ihren automatisch genutzten Reservierungen entsprechen.

Verwenden Sie eine der folgenden Methoden, um eine Reservierung zu nutzen:

  • Informationen zum Erstellen einer Compute-Instanz, die eine von Ihnen erstellte automatische Reservierung nutzt oder die von Compute Engine automatisch erstellt wurde, um eine vorausschauende Reservierung zu erfüllen, finden Sie unter Automatisch genutzte Reservierung nutzen.

  • Informationen zum Erstellen einer Compute-Instanz, die eine von Ihnen erstellte spezifische Reservierung nutzt oder die von Compute Engine automatisch erstellt wurde, um eine vorausschauende Reservierung zu erfüllen, finden Sie unter Spezifisch ausgewählte Reservierung nutzen.

  • Informationen zum Erstellen einer Compute-Instanz, die eine bestimmte Reservierung nutzt, die von Compute Engine automatisch erstellt wurde, um eine vorausschauende Reservierung im Kalendermodus zu erfüllen, finden Sie unter Automatisch erstellte Reservierung für eine Anfrage im Kalendermodus nutzen.

Automatisch genutzte Reservierung nutzen

Automatisch genutzte Reservierungen ermöglichen es allen Compute-Instanzen, die den Attributen der Reservierung entsprechen, diese automatisch zu nutzen. Dieses Nutzungsverhalten gilt sowohl für neue als auch für vorhandene, laufende Compute-Instanzen. Wenn Sie On-Demand-Reservierungen erstellen oder Compute Engine automatisch eine Reservierung erstellt, um eine vorausschauende Reservierung zu erfüllen, ist dieser Reservierungstyp die Standardeinstellung.

Wenn die Attribute einer automatischen Reservierung für ein einzelnes Projekt und einer freigegebenen automatischen Reservierung übereinstimmen, nutzen die Compute-Instanzen in Ihrem Projekt zuerst die Reservierung für ein einzelnes Projekt und dann die freigegebene Reservierung. Weitere Informationen finden Sie unter Verbrauchsreihenfolge für Reservierungen.

Wählen Sie eine der folgenden Optionen aus, um eine automatische Beispielreservierung zu erstellen und zu nutzen:

Console

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

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 Reservierungen auf.

      Zu „Reservierungen“

      Die verbleibenden Schritte werden automatisch in derGoogle Cloud Console angezeigt.

    2. Klicken Sie auf dem Tab On-Demand-Reservierung (Standard) auf 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:

      • Um eine Reservierung für ein Einzelprojekt zu erstellen, 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 die Zahl 3 ein.

    8. Wählen Sie auf dem Tab Für allgemeine Zwecke 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 Compute-Instanz, die die Beispielreservierung verbraucht:

    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 Compute-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 bzw. us-central1-a aus.

      3. Wählen Sie auf dem Tab Für allgemeine Zwecke 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: Die automatische Nutzung einer übereinstimmenden 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 Sie eine automatische Reservierung in der Zone us-central1-a für drei N2-Instanzen mit 32 vCPUs und Intel Cascade Lake als kleinstmögliche CPU-Plattform erstellen. Außerdem wird gezeigt, wie Sie eine einzelne Compute-Instanz erstellen, um die Reservierung zu nutzen.

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 Compute-Instanz, die die Beispielreservierung nutzt, den Befehl gcloud compute instances create, wobei das Flag --reservation-affinity 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 Sie eine N1-Instanz mit vier vCPUs und Intel Skylake als kleinstmögliche CPU-Plattform in der Zone us-central1-a erstellen. 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-13";
    // 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 Sie eine N1-Instanz mit vier vCPUs und Intel Skylake als kleinstmögliche CPU-Plattform in der Zone us-central1-a erstellen. 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 kleinstmögliche 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-13",
                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 Sie eine automatische Reservierung in der Zone us-central1-a für drei N2-Instanzen mit 32 vCPUs und Intel Cascade Lake als kleinstmögliche 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:

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

    POST https://compute./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. Senden Sie zum Erstellen einer Instanz, die die Beispielreservierung nutzt, 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./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"
  }
}

Eine gezielte Reservierung nutzen

Spezifisch ausgewählte Reservierungen ermöglichen es neuen Compute-Instanzen, die mit den Attributen der Reservierung übereinstimmen und auf die Reservierung abzielen, diese zu nutzen. Sie können Compute-Instanzen nur dann erstellen, wenn ihre Attribute mit den Reservierungsattributen übereinstimmen. Andernfalls schlägt die Erstellungsanfrage fehl.

Erstellen Sie basierend auf der gewünschten Erstellungsmethode spezifische Reservierungen und Compute-Instanzen, die auf diese abzielen, so:

Erstellungsmethode Beim Erstellen einer Reservierung Wenn Sie Compute-Instanzen erstellen, um die Reservierung zu nutzen
Google Cloud Console Wählen Sie im Abschnitt Mit VM-Instanz verwenden die Option Spezifische Reservierung auswählen aus. Wählen Sie im Bereich Erweitert im Abschnitt Reservierungen die Option Reservierung auswählen aus. Folgen Sie dann den Aufforderungen, um eine Reservierung auszuwählen.
Google Cloud CLI Fügen Sie das Flag --require-specific-reservation ein. Fügen Sie die folgenden Flags hinzu:
  • Das Flag --reservation-affinity, das auf specific gesetzt ist.
  • Das Flag --reservation, das auf den Ressourcenpfad zur Reservierung im Format projects/OWNER_PROJECT_ID/reservations/RESERVATION_NAME festgelegt ist.
Go Geben Sie das Feld SpecificReservationRequired an, das auf true gesetzt ist. Fügen Sie im Feld ReservationAffinity die folgenden Felder ein:
  • Das Feld ConsumeReservationType ist auf SPECIFIC_RESERVATION gesetzt.
  • Das Feld Key ist auf compute.googleapis.com/reservation-name gesetzt.
  • Das Feld Values ist auf den Ressourcenpfad zur Reservierung im Format projects/OWNER_PROJECT_ID/reservations/RESERVATION_NAME festgelegt.
Java Geben Sie das Feld setSpecificReservationRequired an, das auf true gesetzt ist. Fügen Sie im Feld ReservationAffinity die folgenden Felder ein:
  • Das Feld setConsumeReservationType ist auf SPECIFIC_RESERVATION gesetzt.
  • Das Feld setKey ist auf compute.googleapis.com/reservation-name gesetzt.
  • Das Feld addValues ist auf den Ressourcenpfad zur Reservierung im Format projects/OWNER_PROJECT_ID/reservations/RESERVATION_NAME festgelegt.
Node.js und REST API Geben Sie das Feld specificReservationRequired an, das auf true gesetzt ist. Fügen Sie im Feld reservationAffinity die folgenden Felder ein:
  • Das Feld consumeReservationType ist auf SPECIFIC_RESERVATION gesetzt.
  • Das Feld key ist auf compute.googleapis.com/reservation-name gesetzt.
  • Das Feld values ist auf eine Liste festgelegt, die ein einzelnes Element mit dem Ressourcenpfad zur Reservierung enthält, formatiert als projects/OWNER_PROJECT_ID/reservations/RESERVATION_NAME.
Python Geben Sie das Feld specific_reservation_required an, das auf true gesetzt ist. Fügen Sie im Feld reservation_affinity die folgenden Felder ein:
  • Das Feld consume_reservation_type ist auf SPECIFIC_RESERVATION gesetzt.
  • Das Feld key ist auf compute.googleapis.com/reservation-name gesetzt.
  • Das Feld values ist auf den Ressourcenpfad zur Reservierung im Format projects/OWNER_PROJECT_ID/reservations/RESERVATION_NAME festgelegt.
Terraform Geben Sie das Feld specific_reservation_required an, das auf true gesetzt ist. Fügen Sie im Feld reservation_affinity die folgenden Felder ein:
  • Das Feld type ist auf SPECIFIC_RESERVATION gesetzt.
  • Das Feld specific_reservation, das die folgenden Felder enthält:
    • Das Feld key ist auf compute.googleapis.com/reservation-name gesetzt.
    • Das Feld values ist auf eine Liste festgelegt, die ein einzelnes Element mit dem Ressourcenpfad zur Reservierung enthält, formatiert als projects/OWNER_PROJECT_ID/reservations/RESERVATION_NAME.

Wählen Sie eine der folgenden Optionen aus, um eine beispielhafte spezifische Reservierung und eine Compute-Instanz zu erstellen, die diese Reservierung nutzt:

Console

Im folgenden Beispiel wird gezeigt, wie Sie eine spezifische Reservierung in der Zone us-central1-a für drei N2-Instanzen mit 32 vCPUs und Intel Cascade Lake als kleinstmögliche CPU-Plattform erstellen. Außerdem wird gezeigt, wie Sie eine einzelne Compute-Instanz erstellen, um die Reservierung zu nutzen.

So erstellen Sie die spezifische Beispielreservierung und nutzen sie:

  1. So erstellen Sie eine Beispielreservierung:

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

      Zu „Reservierungen“

      Die verbleibenden Schritte werden automatisch in derGoogle Cloud Console angezeigt.

    2. Klicken Sie auf dem Tab On-Demand-Reservierung (Standard) auf 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 bzw. us-central1-a aus.

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

      • Um eine Reservierung für ein Einzelprojekt zu erstellen, 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 die Zahl 3 ein.

    8. Wählen Sie auf dem Tab Für allgemeine Zwecke 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 Compute-Instanz, die die Beispielreservierung verbraucht:

    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 Compute-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 bzw. us-central1-a aus.

      3. Wählen Sie auf dem Tab Für allgemeine Zwecke 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 die Reservierung vorhanden ist.

      2. Klicken Sie auf Auswählen.

    6. Klicken Sie auf Erstellen.

gcloud

Im folgenden Beispiel wird gezeigt, wie Sie eine spezifische Reservierung in der Zone us-central1-a für drei N2-Instanzen mit 32 vCPUs und Intel Cascade Lake als kleinstmögliche CPU-Plattform erstellen. Außerdem wird gezeigt, wie Sie eine einzelne Compute-Instanz erstellen, um die Reservierung zu nutzen.

So erstellen Sie die spezifische 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 den Befehl gcloud compute instances create mit den Flags --reservation und --reservation-affinity=specific, um eine Compute-Instanz zu erstellen, die die Beispielreservierung nutzt:

    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 kleinstmögliche CPU-Plattform in der Zone us-central1-a erstellen, um eine bestimmte, übereinstimmende Reservierung zu nutzen:

  • Verwenden Sie das folgende Codebeispiel, um die Beispiel-Compute-Instanz zu erstellen, die eine bestimmte Reservierung für ein einzelnes Projekt 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"
)

// 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{
				{
					Network: 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 Beispiel-Compute-Instanz zu erstellen, die eine freigegebene, spezifische Reservierung nutzt:

    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{
				{
					Network: 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 kleinstmögliche CPU-Plattform in der Zone us-central1-a erstellen, um eine bestimmte, übereinstimmende Reservierung zu nutzen:

  • Verwenden Sie das folgende Codebeispiel, um eine Beispielreservierung als Reservierung für ein Einzelprojekt zu erstellen und eine Compute-Instanz zu erstellen, die diese Reservierung 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-13";
    // 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);
    }
  }
}

  • Verwenden Sie das folgende Codebeispiel, um eine Beispielreservierung als freigegebene Reservierung zu erstellen und eine Compute-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 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-13";
    // 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

Die folgenden Beispiele zeigen, wie Sie eine N1-Instanz mit 4 vCPUs und Intel Skylake als kleinstmögliche CPU-Plattform in der Zone us-central1-a erstellen, um eine bestimmte, übereinstimmende 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 kleinstmögliche CPU-Plattform in der Zone us-central1-a erstellen, um eine bestimmte, übereinstimmende Reservierung zu nutzen:

So erstellen Sie die spezifische Beispielreservierung und nutzen sie:

  • Verwenden Sie das folgende Codebeispiel, um die Beispielreservierung als Reservierung für ein Einzelprojekt 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-13",
                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-13",
                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 spezifische Reservierung in der Zone us-central1-a für drei N2-Instanzen mit 32 vCPUs und Intel Cascade Lake als kleinstmögliche CPU-Plattform erstellen. Außerdem wird gezeigt, wie Sie eine einzelne Instanz erstellen, um die Reservierung zu nutzen.

So erstellen Sie die spezifische Beispielreservierung und nutzen sie:

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

    POST https://compute./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 Compute-Instanz erstellen möchten, die die Beispielreservierung nutzt, senden 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./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./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

Automatisch erstellte Reservierung für eine Anfrage im Kalendermodus nutzen

Mit diesem Reservierungstyp können neue Compute-Instanzen eine Reservierung nutzen, die von Compute Engine automatisch erstellt wird, um eine vorausschauende Reservierung im Kalendermodus zu erfüllen.

Wenn Sie diese Art von Reservierung nutzen möchten, müssen Sie eine Compute-Instanz so erstellen:

  • Die Compute-Instanz muss spezifisch auf die Reservierung abzielen.

  • Die Compute-Instanz muss zum Ende der Reservierung beendet oder gelöscht werden.

  • Die Compute-Instanz muss das reservierungsgebundene Bereitstellungsmodell verwenden. Wenn Sie eine Compute-Instanz erstellen, können Sie dieses Modell so angeben:

    • Wenn Sie in der Google Cloud -Konsole einen unterstützten Maschinentyp für vorausschauende Reservierungen im Kalendermodus angeben, wird das reservierungsgebundene Modell automatisch ausgewählt.

    • Fügen Sie in der gcloud CLI das Flag --provisioning-model ein, das auf RESERVATION_BOUND gesetzt ist.

    • Geben Sie in der REST API das Feld provisioningModel mit dem Wert RESERVATION_BOUND an.

Im folgenden Beispiel wird eine Anfrage für eine vorausschauende Reservierung im Kalendermodus für A3 Ultra-Instanzen erstellt. Das Beispiel zeigt auch die Felder, die Sie angeben müssen, wenn Sie eine eigenständige A3 Ultra-Instanz erstellen, um die automatisch erstellte Reservierung für die Anfrage zu nutzen.

Wählen Sie eine der folgenden Optionen aus, um die automatisch erstellte Beispielreservierung zu nutzen:

Console

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

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

      Zu „Reservierungen“

    2. Klicken Sie auf den Tab Vorausschauende Reservierungen.

    3. Klicken Sie auf Vorausschauende Reservierung erstellen. Die Seite Vorausschauende Reservierung erstellen wird angezeigt.

    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.

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

    6. Geben Sie im Abschnitt Reservierungszeitraum den Beginn und die Dauer des Reservierungszeitraums an.

    7. Klicken Sie auf Nach Kapazität suchen und wählen Sie dann im Abschnitt Verfügbare Kapazität eine der verfügbaren Maschinen aus.

    8. Klicken Sie auf Erstellen.

  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 Compute-Instanz ein. Geben Sie für dieses Beispiel example-instance ein.

    3. Geben Sie die Region und die Zone an, in der die automatisch erstellte Reservierung vorhanden ist. Wählen Sie für dieses Beispiel us-central1 bzw. us-central1-b 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 die automatisch erstellte Beispielreservierung aus.

      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 (Standard) oder Löschen aus.

    10. Klicken Sie auf Erstellen.

gcloud

  1. Verwenden Sie den Befehl gcloud compute future-reservations create, um eine Beispielanfrage für fünf A3 Ultra-VMs zu erstellen und zur Überprüfung einzureichen:

    gcloud 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-setting=local \
    --start-time=2026-03-05T00:00:00Z \
    --end-time=2026-03-19T00:00:00Z \
    --machine-type=a3-ultragpu-8g \
    --total-count=5 \
    --zone=us-central1-b

    Angenommen, Google Cloud genehmigt die Anfrage und Compute Engine erstellt automatisch eine leere Reservierung. Zum Startzeitpunkt der Anfrage am 5. März 2026 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 Startzeitpunkt der Anfrage den Befehl gcloud compute instances create mit den folgenden Flags, um eine A3 Ultra-Instanz zu erstellen, die die automatisch erstellte Beispielreservierung nutzt:

    • 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 instances create example-a3ultra-instance \
    --machine-type=a3-ultragpu-8g \
    --instance-termination-action=TERMINATION_ACTION \
    --provisioning-model=RESERVATION_BOUND \
    --reservation-affinity=specific \
    --reservation=RESERVATION_URL \
    --zone=us-central1-b \
    ...

    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, senden Sie eine POST-Anfrage an die Methode futureReservations.insert:

    POST https://compute./compute/v1/projects/example-project/zones/us-central1-b/futureReservations

{
  "name": "example-request-calendar-mode",
  "autoDeleteAutoCreatedReservations": true,
  "deploymentType": "DENSE",
  "planningStatus": "SUBMITTED",
  "reservationMode": "CALENDAR",
  "reservationName": "example-reservation",
  "shareSettings": {
    "shareType": "LOCAL"
  },
  "specificReservationRequired": true,
  "specificSkuProperties": {
    "instanceProperties": {
      "machineType": "a3-ultragpu-8g"
    },
    "totalCount": "5"
  },
  "timeWindow": {
    "startTime": "2026-03-05T00:00:00Z",
    "endTime": "2026-03-19T00:00:00Z"
  }
}

    Angenommen, Google Cloud genehmigt die Anfrage und Compute Engine erstellt automatisch eine leere Reservierung. Zum Startzeitpunkt der Anfrage am 5. März 2026 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 gesetzt.

    • Das Feld scheduling.instanceTerminationAction.

    • Das Feld scheduling.provisioningModel ist auf RESERVATION_BOUND gesetzt.

    Die Anfrage sieht 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./compute/v1/projects/example-project/zones/us-central1-b/instances

{
  "machineType": "projects/example-project/zones/us-central1-b/machineTypes/a3-ultragpu-8g",
  "name": "example-a3ultra-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).

Prüfen, ob die Attribute der Compute-Instanz mit einer automatisch genutzten Reservierung übereinstimmen

Im Gegensatz zu spezifisch ausgewählten Reservierungen geben automatisch genutzte Reservierungen keinen Fehler zurück, wenn die Attribute der Compute-Instanz nicht übereinstimmen. Stattdessen versucht Compute Engine, eine Compute-Instanz mit On-Demand-Kapazität zu erstellen. Wenn Sie prüfen möchten, ob die Attribute Ihrer Compute-Instanz mit einer automatisch genutzten Reservierung übereinstimmen, bevor Sie Ihre Arbeitslasten starten, testen Sie die Attribute mit einer speziell auf den Test ausgerichteten Reservierung, die dieselben Attribute hat.

So testen Sie, ob die Attribute einer Compute-Instanz mit einer automatisch genutzten Reservierung übereinstimmen:

  1. Testreservierung erstellen: Erstellen Sie eine speziell ausgewählte Reservierung mit denselben Compute-Instanzattributen wie die automatisch genutzte Reservierung, die Sie testen möchten. Legen Sie die Anzahl der reservierten Compute-Instanzen auf 1 fest.

  2. Test-Compute-Instanz erstellen: Versuchen Sie, eine Compute-Instanz zu erstellen, indem Sie Ihre Testreservierung als Ziel angeben. Das Ergebnis dieses Schritts ist eines der folgenden:

    • Wenn Sie die Compute-Instanz erfolgreich erstellen, stimmen die Attribute der Compute-Instanz und der Testreservierung überein.

    • Wenn Sie die Compute-Instanz nicht erstellen können und eine Fehlermeldung erhalten, stimmen die Attribute möglicherweise nicht überein. Informationen zur Fehlerbehebung finden Sie unter Fehlerbehebung bei der Nutzung von Reservierungen.

  3. Ressourcen bereinigen: Wenn Sie eine Compute-Instanz erfolgreich erstellt haben, indem Sie die Testreservierung als Ziel festgelegt haben, löschen Sie die Testressourcen, um unnötige Kosten zu vermeiden:

Reservierungsnutzung prüfen

Verwenden Sie eine der folgenden Methoden, um die Nutzung von Reservierungen zu prüfen:

Nächste Schritte