Diese Seite wurde von der Cloud Translation API übersetzt.

Reservierungen nutzen

In diesem Dokument wird beschrieben, wie Sie mit Compute Engine Folgendes tun:

Nutzen Sie reservierte VM-Instanzen.
Prüfen Sie die Reservierungsnutzung.
Sehen Sie sich Nutzungsberichte zu Reservierungen an.

Weitere Informationen zur Nutzung von Reservierungen in anderen Google Cloud-Produkten, die VMs verwenden, finden Sie in der Reservierungsdokumentation für die folgenden Produkte:

Batch
Dataflow
Dataproc
Google Kubernetes Engine
Vertex AI:
- Reservierungen mit Vorhersage verwenden
- Reservierungen mit Schulungen verwenden

Vorbereitung

Informationen zu den Anforderungen und Einschränkungen für Reservierungen
Richten Sie die Authentifizierung ein, falls Sie dies noch nicht getan haben. Bei der Authentifizierung wird Ihre Identität für den Zugriff auf Google Cloud-Dienste und APIs überprüft. Zur Ausführung von Code oder Beispielen aus einer lokalen Entwicklungsumgebung können Sie sich bei Compute Engine authentifizieren. Wählen Sie dazu eine der folgenden Optionen aus:

Select the tab for how you plan to use the samples on this page:
Console

When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.
gcloud
1. Install the Google Cloud CLI, then initialize it by running the following command:
  gcloud init
  Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
2. Set a default region and zone.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Compute-Instanzadministrator (v1) (roles/compute.instanceAdmin.v1) für das Projekt zu gewähren, um die Berechtigungen zu erhalten, die Sie zum Nutzen von Reservierungen benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierte Rolle enthält die Berechtigungen, die zum Verbrauchen von Reservierungen erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind zum Nutzen von Reservierungen erforderlich:

Zum Erstellen von Reservierungen: compute.reservations.create für das Projekt
Zum Erstellen von VMs:
- compute.instances.create für das Projekt
- Zur Erstellung der VM mit einem benutzerdefinierten Image: compute.images.useReadOnly für das Image
- Zur Erstellung der VM mithilfe eines Snapshots: compute.snapshots.useReadOnly für den Snapshot
- Zur Erstellung der VM mithilfe einer Instanzvorlage: compute.instanceTemplates.useReadOnly für die Instanzvorlage
- Um der VM ein Legacy-Netzwerk zuzuweisen: compute.networks.use für das Projekt
- Zum Festlegen einer statische IP-Adresse für die VM: compute.addresses.use für das Projekt
- Zur Zuweisung einer externen IP-Adresse zur VM bei Verwendung eines Legacy-Netzwerks: compute.networks.useExternalIp für das Projekt
- Um ein Subnetz für die VM anzugeben: compute.subnetworks.use für das Projekt oder für das ausgewählte Subnetz
- Um der VM eine externe IP-Adresse zuzuweisen, wenn Sie ein VPC-Netzwerk verwenden: compute.subnetworks.useExternalIp für das Projekt oder für das ausgewählte Subnetz
- Um die Metadaten der VM-Instanz für die VM festzulegen: compute.instances.setMetadata für das Projekt
- Um Tags für die VM festzulegen: compute.instances.setTags für die VM
- Um Labels für die VM festzulegen: compute.instances.setLabels für die VM
- Um ein Dienstkonto festzulegen, das die VM verwenden soll: compute.instances.setServiceAccount für die VM
- Um ein neues Laufwerk für die VM zu erstellen: compute.disks.create für das Projekt
- Um ein vorhandenes Laufwerk im Lese- oder Lese‑/Schreibmodus anzuhängen: compute.disks.use für das Laufwerk
- Um ein vorhandenes Laufwerk im Lesemodus anzuhängen: compute.disks.useReadOnly für das Laufwerk
So erstellen Sie Instanzvorlagen: compute.instanceTemplates.create für das Projekt

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

Reservierte VMs nutzen

Wenn Sie eine VM-Instanz (virtuelle Maschine) erstellen, beginnt die VM erst dann, eine Reservierung zu nutzen, wenn die Eigenschaften der VM und der Reservierung übereinstimmen. Darüber hinaus müssen Sie das Attribut für die Reservierungsaffinität der VM auf eine der folgenden Optionen festlegen:

Beliebige übereinstimmende Reservierung nutzung: Die VM kann automatisch jede Reservierung mit übereinstimmenden Attributen nutzen (Standard).

Diese Option ist nützlich, wenn Sie viele VMs erstellen und löschen sowie die Reservierungen nach Möglichkeit verwenden möchten. In diesem Szenario kann eine VM erstellt werden, unabhängig davon, ob ihre Attribute mit einer Reservierung übereinstimmen oder nicht. Wenn sie übereinstimmen, verwendet die VM die Reservierung je nach Nutzungsreihenfolge der Reservierung.
Eine bestimmte Reservierung nutzen: Die VM kann nur eine bestimmte Reservierung nutzen. Die Reservierung kann nicht automatisch in Anspruch genommen werden.

Diese Option ist beispielsweise nützlich, wenn Sie bestimmte Kapazitäten für besondere Ereignisse bereithalten möchten. In diesem Szenario kann eine VM nur erstellt werden, wenn ihre Attribute und die Attribute der spezifischen Reservierung übereinstimmen.

Hinweis: Sie können eine bestimmte Reservierung und eine VM mit dieser Affinität erstellen, um zu testen, ob die VM richtig konfiguriert ist, um automatisch eine übereinstimmende Reservierung zu nutzen.
Keine Reservierung kann genutzt werden: Die VM kann keine Reservierung nutzen.

Diese Option ist nützlich, wenn Sie beispielsweise eine temporäre VM erstellen, die keine reservierten Ressourcen nutzen soll.

VMs aus jeder übereinstimmenden Reservierung nutzen

In diesem Nutzungsmodell nutzen vorhandene und neue VMs automatisch eine Reservierung, wenn ihre Attribute mit den in der Reservierung angegebenen VM-Attributen übereinstimmen.

Bei Verwendung dieses Nutzungsmodells nutzen die VMs im aktuellen Projekt zuerst alle Reservierungen für ein einzelnes Projekt, bevor sie freigegebene Reservierungen nutzen. Weitere Informationen zur automatischen Nutzung von Reservierungen finden Sie unter Nutzungsreihenfolge.

Wenn Sie eine Reservierung erstellen, ist dies das Standard-Nutzungsmodell, solange Sie nicht das Flag oder die Option verwenden, die angibt, dass bestimmte Reservierungen erforderlich sind.

Console

So erstellen Sie eine Reservierung mit Ressourcen, die von VMs mit einem Reservierungsaffinitätsattribut verwendet werden können, das für die Nutzung von Reservierungen konfiguriert ist (Standard):
1. Wählen Sie die Art der Reservierung aus, die Sie erstellen möchten:
  - So erstellen Sie eine eigenständige Reservierung:
    1. Öffnen Sie in der Google Cloud Console die Seite Reservierungen.
      
      Zu „Reservierungen“
    2. Klicken Sie auf dem Tab On-Demand-Reservierung (Standard) auf Reservierung erstellen.
      
      Die Seite Reservierung erstellen wird geöffnet.
  - So erstellen Sie eine Reservierung, die mit einer Nutzungszusicherung verbunden ist:
    1. Öffnen Sie in der Google Cloud Console die Seite Rabatte für zugesicherte Nutzung.
      
      Zur Seite "Rabatte für zugesicherte Nutzung"
      
      Die Seite Zusicherungsliste wird geöffnet.
    2. Klicken Sie auf Zusicherung kaufen.
      
      Die Seite Rabatt für zugesicherte Nutzung kaufen wird geöffnet.
    3. Geben Sie die Attribute der Zusicherung an. Klicken Sie dann im Abschnitt Reservierungen auf Element hinzufügen.
      
      Der Abschnitt Neue Reservierung hinzufügen wird angezeigt.
      
      Weitere Informationen zum Kauf einer Nutzungszusicherung mit einer angehängten Reservierung finden Sie unter Zusicherungen mit angehängten Reservierungen erwerben.
2. Geben Sie im Feld Name einen Namen für die Reservierung ein. Geben Sie für dieses Beispiel reservation-01 ein.
3. Wählen Sie die Region und die Zone aus, in der Sie Ressourcen reservieren möchten. Wählen Sie für dieses Beispiel us-central1 als Region und us-central1-a als Zone aus.
4. Wählen Sie den gewünschten Freigabetyp:
  - Um eine Reservierung für ein einzelnes Projekt zu erstellen, wählen Sie Lokal aus.
  - Um eine freigegebene Reservierung für mehrere Projekte zu erstellen, wählen Sie Freigegeben aus. Klicken Sie auf Projekte hinzufügen und wählen Sie die gewünschten Projekte aus der Organisation des aktuellen Projekts aus, um diese Reservierung für andere Projekte freizugeben.
5. Wählen Sie im Abschnitt Mit VM-Instanz verwenden die Option Reservierung automatisch verwenden aus, damit alle übereinstimmenden VMs diese Reservierung automatisch verwenden können.
6. Geben Sie im Feld Anzahl der VM-Instanzen die Anzahl der VMs ein, die Sie reservieren möchten. Geben Sie für dieses Beispiel 2 ein.
7. Geben Sie die Ressourcen an, die Sie für die jeweilige VM reservieren möchten:
  - Wenn Sie VMs reservieren möchten, die einer vorhandenen Instanzvorlage entsprechen, wählen Sie Instanzvorlage verwenden und dann eine Instanzvorlage aus der Liste aus.
  - Wählen Sie andernfalls Maschinentyp angeben und geben Sie Folgendes an:
    1. Wählen Sie in den Feldern Maschinenfamilie, Reihe und Maschinentyp eine Maschinenfamilie, eine Reihe und einen Maschinentyp aus.
    2. Optional: Geben Sie eine Mindest-CPU-Plattform und/oder GPUs an:
      1. Klicken Sie zum Erweitern des Abschnitts CPU-Plattform und GPU auf den Erweiterungspfeil .
      2. Optional: Wählen Sie in der Liste CPU-Formular eine Option aus, um eine Minimalanforderung für die CPU-Plattform anzugeben.
      3. Optional: Klicken Sie zum Hinzufügen von GPUs auf GPU hinzufügen. Wählen Sie dann in den Feldern GPU-Typ und Anzahl der GPUs den Typ und die Anzahl der GPUs für jede VM aus.
    3. Optional: Fügen Sie lokale SSDs hinzu:
      1. Wählen Sie im Feld Anzahl der Laufwerke die Anzahl der lokalen SSDs für jede VM aus.
      2. Wählen Sie im Feld Schnittstellentyp die Schnittstelle für die lokalen SSDs aus.
  Wählen Sie für dieses Beispiel Maschinentyp angeben aus. Wählen Sie dann den Maschinentyp n2-standard-32 für die Maschinenfamilie General-purpose und die Maschinenserie N2 aus und wählen Sie die Mindest-CPU-Plattform Intel Cascade Lake aus.
8. Schließen Sie das Erstellen der Reservierung ab:
  - Wenn Sie eine eigenständige Reservierung erstellen, klicken Sie auf Erstellen.
  - Wenn Sie eine Reservierung erstellen, die mit einer Nutzungszusicherung verbunden ist:
    1. Klicken Sie auf Fertig, um das Festlegen der Attribute für diese Reservierung abzuschließen.
    2. Klicken Sie auf Kaufen, um das Erstellen der Zusicherung und der angehängten Reservierungen abzuschließen.
Erstellen Sie in demselben Projekt oder in einem Projekt, für das die Reservierung freigegeben ist, eine VM, die auf eine beliebige offene Reservierung abzielt.

Die Attribute der VM müssen mit den VM-Attributen in reservation-01 übereinstimmen, einschließlich Zone, Maschinentyp (Maschinenfamilie, vCPUs und Arbeitsspeicher), Mindest-CPU-Plattform, GPU-Anzahl und -Typ sowie Schnittstelle und Größe der lokalen SSD.

Weitere Informationen zum Erstellen einer VM finden Sie unter VM erstellen und starten.
1. Rufen Sie in der Google Cloud Console die Seite Instanz erstellen auf.
  
  Zur Seite „Instanz erstellen“
  
  Die Seite Instanz erstellen wird geöffnet.
2. Geben Sie einen Namen für Ihre VM an.
3. Wählen Sie in den folgenden Abschnitten eine Konfiguration aus, die genau mit allen Attributen Ihrer Reservierung übereinstimmt, einschließlich eventueller optionaler Attribute. In diesem Beispiel müssen Sie folgende VM-Attribute mit reservation-01 abgleichen:
  - Region: us-central1
  - Zone: us-central1-a
  - Maschinentyp: n2-standard-32
  - Mindest-CPU-Plattform: Intel Cascade Lake
  - GPUs: keine
  - Lokale SSDs: keine
4. Maximieren Sie den Bereich Erweiterte Optionen und dann den Bereich Verwaltung. Wählen Sie in der Liste Reservierungen Automatisch erstellte Reservierung verwenden.
5. Klicken Sie auf Erstellen, um die VM zu erstellen.

gcloud

Erstellen Sie eine offene Reservierung mit dem Namen reservation-01.

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

Erstellen Sie eine VM, die auf eine beliebige offene Reservierung abzielt und deren Attribute mit den VM-Attributen von reservation-01 übereinstimmen, einschließlich jener für Zone, Maschinentyp (Maschinenfamilie, vCPUs und Speicher), Mindest-CPU-Plattform, GPU-Anzahl und -Typ sowie lokale SSD-Anzahl und -Schnittstelle.
```
gcloud compute instances create instance-1 \
    --machine-type=n2-standard-32 \
    --min-cpu-platform="Intel Cascade Lake" \
    --zone=us-central1-a \
    --reservation-affinity=any
```

Go

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

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

// 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

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

Erstellen Sie eine offene Reservierung mit dem Namen reservation-01.

POST https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central1-a/reservations

{
  "name": "reservation-01",
  "specificReservation": {
    "count": "2",
    "instanceProperties": {
      "machineType": "n2-standard-32",
      "minCpuPlatform": "Intel Cascade Lake",
    }
  }
}

Erstellen Sie eine VM, die auf eine beliebige offene Reservierung abzielt und deren Attribute mit den VM-Attributen von reservation-01 übereinstimmen, einschließlich jener für Zone, Maschinentyp (Maschinenfamilie, vCPUs und Speicher), Mindest-CPU-Plattform, GPU-Anzahl und -Typ sowie lokale SSD-Anzahl und -Schnittstelle.

POST https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central1-a/instances

{
  "name": "instance-1",
  "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"
  }
}

VMs aus einer bestimmten Reservierung nutzen

In diesem Nutzungsmodell nutzen nur neue VMs, die namentlich auf eine bestimmte Reservierung abzielen, diese Reservierung, und die Reservierung wird nicht automatisch genutzt.

Geben Sie beim Erstellen der Reservierung an, dass VMs auf die spezifische Reservierung abzielen müssen. Verwenden Sie dazu eine der folgenden Methoden:

Klicken Sie in der Google Cloud Console das Kästchen Bestimmte Reservierung auswählen an.
Fügen Sie in der gcloud CLI das Flag --require-specific-reservation ein.
Legen Sie in der Compute Engine API das Feld specificReservationRequired auf true fest.
Legen Sie in Terraform das Feld specific_reservation_required auf true fest.

Erstellen Sie dann VMs, die ausdrücklich auf diese Reservierung abzielen. Sie können eine VM nur erstellen, die auf eine bestimmte Reservierung abzielt, wenn die VM-Attribute und die Reservierungsattribute übereinstimmen. Andernfalls schlägt das Erstellen der VM fehl.

Wenn Sie zum Erstellen von VMs in einer regional verwalteten Instanzgruppe Instanzvorlagen verwenden, erstellen Sie in allen zutreffenden Zonen identische Reservierungen mit demselben Namen. Wählen Sie die Reservierungen dann in der Instanzvorlage der Gruppe namentlich aus.

Erstellen Sie beispielsweise eine spezifische Reservierung mit dem Namen reservation-02 und erstellen Sie dann eine übereinstimmende VM, die auf diese Reservierung abzielt und mit den VM-Attributen der Reservierung übereinstimmt.

Führen Sie je nach Art der zu verwendenden VM die folgenden Schritte aus: Eine bestimmte Reservierung für ein einzelnes Projekt nutzen oder Eine bestimmte freigegebene Reservierung nutzen.

Eine bestimmte Reservierung für ein einzelnes Projekt verwenden

Wenn Sie eine bestimmte Reservierung für ein einzelnes Projekt nutzen möchten, wählen Sie eine der folgenden Optionen aus:

Console

So erstellen Sie eine Reservierung mit Ressourcen, die nur von VMs verwendet werden können, die ausdrücklich auf diese Reservierung namentlich abzielen.
1. Wählen Sie eine der folgenden Optionen aus:
  - So erstellen Sie eine eigenständige Reservierung:
    1. Öffnen Sie in der Google Cloud Console die Seite Reservierungen.
      
      Zu „Reservierungen“
    2. Klicken Sie auf dem Tab On-Demand-Reservierungen (Standard) auf Reservierung erstellen.
      
      Die Seite Reservierung erstellen wird geöffnet.
  - So erstellen Sie eine Reservierung, die mit einer Nutzungszusicherung verbunden ist:
    1. Öffnen Sie in der Google Cloud Console die Seite Rabatte für zugesicherte Nutzung.
      
      Zur Seite "Rabatte für zugesicherte Nutzung"
    2. Klicken Sie auf Zusicherung kaufen.
      
      Die Seite Rabatt für zugesicherte Nutzung kaufen wird geöffnet.
    3. Geben Sie die Attribute der Zusicherung an. Klicken Sie dann im Abschnitt Reservierungen auf Element hinzufügen.
      
      Der Abschnitt Neue Reservierung hinzufügen wird angezeigt.
      
      Weitere Informationen zum Kauf einer Nutzungszusicherung mit einer angehängten Reservierung finden Sie unter Zusicherungen mit angehängten Reservierungen erwerben.
2. Geben Sie im Feld Name einen Namen für die Reservierung ein. Geben Sie für dieses Beispiel reservation-02 ein.
3. Wählen Sie die Region und die Zone aus, in der Sie Ressourcen reservieren möchten. Wählen Sie für dieses Beispiel us-central1 als Region und us-central1-a als Zone aus.
4. Wenn Sie angeben möchten, dass es sich bei Ihrer Reservierung um eine Reservierung für ein einzelnes Projekt handelt, wählen Sie als Freigabetyp Lokal aus.
5. Wählen Sie im Abschnitt Mit VM-Instanz verwenden die Option Spezifische Reservierung auswählen aus, damit diese Reservierung nur von übereinstimmenden VMs verwendet werden kann, die namentlich auf diese Reservierung abzielen.
6. Geben Sie im Feld Anzahl der VM-Instanzen die Anzahl der VMs ein, die Sie reservieren möchten. Geben Sie für dieses Beispiel 10 ein.
7. Geben Sie die Ressourcen an, die Sie für die jeweilige VM reservieren möchten:
  - Wenn Sie VMs reservieren möchten, die einer vorhandenen Instanzvorlage entsprechen, wählen Sie Instanzvorlage verwenden und dann eine Instanzvorlage aus der Liste aus.
  - Wählen Sie andernfalls Maschinentyp angeben und geben Sie Folgendes an:
    1. Wählen Sie in den Feldern Maschinenfamilie, Reihe und Maschinentyp eine Maschinenfamilie, eine Reihe und einen Maschinentyp aus.
    2. Optional: Geben Sie eine Mindest-CPU-Plattform und/oder GPUs an:
      1. Klicken Sie zum Erweitern des Abschnitts CPU-Plattform und GPU auf den Erweiterungspfeil .
      2. Optional: Wählen Sie in der Liste CPU-Formular eine Option aus, um eine Minimalanforderung für die CPU-Plattform anzugeben.
      3. Optional: Klicken Sie zum Hinzufügen von GPUs auf GPU hinzufügen. Wählen Sie dann in den Feldern GPU-Typ und Anzahl der GPUs den Typ und die Anzahl der GPUs für jede VM aus.
    3. Optional: Fügen Sie lokale SSDs hinzu:
      1. Wählen Sie im Feld Anzahl der Laufwerke die Anzahl der lokalen SSDs für jede VM aus.
      2. Wählen Sie im Feld Schnittstellentyp die Schnittstelle für die lokalen SSDs aus.
  Wählen Sie für dieses Beispiel Maschinentyp angeben aus. Wählen Sie dann den Maschinentyp n2-standard-32 für die Maschinenfamilie General-purpose und die Maschinenserie N2 aus und wählen Sie die Mindest-CPU-Plattform Intel Cascade Lake aus.
8. Schließen Sie das Erstellen der Reservierung ab:
  - Wenn Sie eine eigenständige Reservierung erstellen, klicken Sie auf Erstellen.
  - Wenn Sie eine Reservierung erstellen, die mit einer Nutzungszusicherung verbunden ist:
    1. Klicken Sie auf Fertig, um das Festlegen der Attribute für diese Reservierung abzuschließen.
    2. Klicken Sie auf Kaufen, um das Erstellen der Zusicherung und der angehängten Reservierungen abzuschließen.
Erstellen Sie im selben Projekt eine VM, die per Namen auf die jeweilige Reservierung abzielt.

Die Attribute der VM müssen mit den VM-Attributen dieser bestimmten Reservierung übereinstimmen, einschließlich Zone, Maschinentyp (Maschinenfamilie, vCPUs und Arbeitsspeicher), Mindest-CPU-Plattform, GPU-Anzahl und -Typ sowie Schnittstelle und Größe der lokalen SSD.

Weitere Informationen zum Erstellen einer VM finden Sie unter VM erstellen und starten.
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 VM ein.
3. Wählen Sie in den folgenden Abschnitten eine Konfiguration aus, die genau mit allen Attributen Ihrer Reservierung übereinstimmt, einschließlich eventueller optionaler Attribute. In diesem Beispiel müssen Sie folgende VM-Attribute mit reservation-02 abgleichen:
  - Region: us-central1
  - Zone: us-central1-a
  - Maschinentyp: n2-standard-32
  - Mindest-CPU-Plattform: Intel Cascade Lake
  - GPUs: keine
  - Lokale SSDs: keine
4. Maximieren Sie den Abschnitt Erweiterte Optionen und gehen Sie dann so vor:
  1. Maximieren Sie den Bereich Verwaltung.
  2. Wählen Sie im Bereich Reservierungen in der Liste Anwendungsrichtlinie die Option Bestimmte Reservierung auswählen aus.
  3. Wählen Sie die Reservierung mit den gewünschten VM-Attributen aus, die Ihre VM verbrauchen darf. Wählen Sie für dieses Beispiel reservation-02 aus.
5. Klicken Sie auf Erstellen, um die VM zu erstellen.

gcloud

Erstellen Sie mit dem Flag --require-specific-reservation eine Reservierung mit dem Namen reservation-02. Diese reservierten Ressourcen können nur von VMs verwendet werden, für die diese Reservierung ausdrücklich namentlich ausgewählt wurde.
```
gcloud compute reservations create reservation-02 \
    --machine-type=n2-standard-32 \
    --min-cpu-platform="Intel Cascade Lake" \
    --vm-count=10 \
    --zone=us-central1-a \
    --require-specific-reservation
```
Erstellen Sie mit den Flags --reservation-affinity und --reservation eine VM, die namentlich mit reservation-02 verknüpft ist.

Die Attribute der VM müssen mit den VM-Attributen der Reservierung übereinstimmen, einschließlich Zone, Maschinentyp (Maschinenfamilie, vCPUs und Arbeitsspeicher), Mindest-CPU-Plattform, GPU-Anzahl und -Typ sowie Schnittstelle und Größe der lokalen SSD.
```
gcloud compute instances create instance-2 \
    --machine-type=n2-standard-32 \
    --min-cpu-platform="Intel Cascade Lake" \
    --zone=us-central1-a \
    --reservation-affinity=specific \
    --reservation=reservation-02
```

Go

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
}

Java

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);
    }
  }
}

Node.js

// 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

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)

REST

Erstellen Sie mit dem auf true festgelegten Feld specificReservationRequired eine Reservierung mit dem Namen reservation-02.

POST https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central1-a/reservations

{
  "name":"reservation-02",
  "specificReservation":{
    "count":"10",
    "instanceProperties":{
      "machineType":"n2-standard-32",
      "minCpuPlatform": "Intel Cascade Lake",
    }
  },
  "specificReservationRequired": true
}

Erstellen Sie mit den Feld reservationAffinity eine VM, die namentlich mit reservation-02 verknüpft ist.

Die Attribute der VM müssen mit den VM-Attributen der Reservierung übereinstimmen, einschließlich Zone, Maschinentyp (Maschinenfamilie, vCPUs und Arbeitsspeicher), Mindest-CPU-Plattform, GPU-Anzahl und -Typ sowie Schnittstelle und Größe der lokalen SSD.

POST https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central1-a/instances

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

Eine bestimmte freigegebene Reservierung nutzen

Wählen Sie eine der folgenden Optionen aus, um eine bestimmte freigegebene Reservierung zu nutzen:

Console

So erstellen Sie eine freigegebene Reservierung mit Ressourcen, die nur von VMs verwendet werden können, die ausdrücklich auf diese Reservierung namentlich abzielen:
1. Wählen Sie eine der folgenden Optionen aus:
  - So erstellen Sie eine eigenständige Reservierung:
    1. Öffnen Sie in der Google Cloud Console die Seite Reservierungen.
      
      Zu „Reservierungen“
    2. Klicken Sie auf dem Tab On-Demand-Reservierungen (Standard) auf Reservierung erstellen.
      
      Die Seite Reservierung erstellen wird geöffnet.
  - So erstellen Sie eine Reservierung, die mit einer Nutzungszusicherung verbunden ist:
    1. Öffnen Sie in der Google Cloud Console die Seite Rabatte für zugesicherte Nutzung.
      
      Zur Seite "Rabatte für zugesicherte Nutzung"
    2. Klicken Sie auf Zusicherung kaufen.
      
      Die Seite Rabatt für zugesicherte Nutzung kaufen wird geöffnet.
    3. Geben Sie die Attribute der Zusicherung an. Klicken Sie dann im Abschnitt Reservierungen auf Element hinzufügen.
      
      Der Abschnitt Neue Reservierung hinzufügen wird angezeigt.
      
      Weitere Informationen zum Kauf einer Nutzungszusicherung mit einer angehängten Reservierung finden Sie unter Zusicherungen mit angehängten Reservierungen erwerben.
2. Geben Sie im Feld Name einen Namen für die Reservierung ein. Geben Sie für dieses Beispiel reservation-02 ein.
3. Wählen Sie die Region und die Zone aus, in der Sie Ressourcen reservieren möchten. Wählen Sie für dieses Beispiel us-central1 als Region und us-central1-a als Zone aus.
4. Um anzugeben, dass Ihre Reservierung eine freigegebene Reservierung ist, wählen Sie Freigegeben als Freigabetyp aus.
5. Klicken Sie auf Projekte hinzufügen und wählen Sie die Projekte aus der Organisation des aktuellen Projekts aus, 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, damit diese Reservierung nur von übereinstimmenden VMs verwendet werden kann, die namentlich auf diese Reservierung abzielen.
7. Geben Sie im Feld Anzahl der VM-Instanzen die Anzahl der VMs ein, die Sie reservieren möchten. Geben Sie für dieses Beispiel 10 ein.
8. Geben Sie die Ressourcen an, die Sie für die jeweilige VM reservieren möchten:
  - Wenn Sie VMs reservieren möchten, die einer vorhandenen Instanzvorlage entsprechen, wählen Sie Instanzvorlage verwenden und dann eine Instanzvorlage aus der Liste aus.
  - Wählen Sie andernfalls Maschinentyp angeben und geben Sie Folgendes an:
    1. Wählen Sie in den Feldern Maschinenfamilie, Reihe und Maschinentyp eine Maschinenfamilie, eine Reihe und einen Maschinentyp aus.
    2. Optional: Geben Sie eine Mindest-CPU-Plattform und/oder GPUs an:
      1. Klicken Sie zum Erweitern des Abschnitts CPU-Plattform und GPU auf den Erweiterungspfeil .
      2. Optional: Wählen Sie in der Liste CPU-Formular eine Option aus, um eine Minimalanforderung für die CPU-Plattform anzugeben.
      3. Optional: Klicken Sie zum Hinzufügen von GPUs auf GPU hinzufügen. Wählen Sie dann in den Feldern GPU-Typ und Anzahl der GPUs den Typ und die Anzahl der GPUs für jede VM aus.
    3. Optional: Fügen Sie lokale SSDs hinzu:
      1. Wählen Sie im Feld Anzahl der Laufwerke die Anzahl der lokalen SSDs für jede VM aus.
      2. Wählen Sie im Feld Schnittstellentyp die Schnittstelle für die lokalen SSDs aus.
  Wählen Sie für dieses Beispiel Maschinentyp angeben aus. Wählen Sie dann den Maschinentyp n2-standard-32 für die Maschinenfamilie General-purpose und die Maschinenserie N2 aus und wählen Sie die Mindest-CPU-Plattform Intel Cascade Lake aus. 1. Schließen Sie das Erstellen der Reservierung ab:
  - Wenn Sie eine eigenständige Reservierung erstellen, klicken Sie auf Erstellen.
  - Wenn Sie eine Reservierung erstellen, die mit einer Nutzungszusicherung verbunden ist:
    1. Klicken Sie auf Fertig, um das Festlegen der Attribute für diese Reservierung abzuschließen.
    2. Klicken Sie auf Kaufen, um das Erstellen der Zusicherung und der angehängten Reservierungen abzuschließen.
Erstellen Sie in demselben Projekt oder in einem Projekt, für das die Reservierung freigegeben ist, eine VM, die auf eine bestimmte Reservierung abzielt.

Die Attribute der VM müssen mit den VM-Attributen dieser bestimmten Reservierung übereinstimmen, einschließlich Zone, Maschinentyp (Maschinenfamilie, vCPUs und Arbeitsspeicher), Mindest-CPU-Plattform, GPU-Anzahl und -Typ sowie Schnittstelle und Größe der lokalen SSD.
1. Rufen Sie in der Google Cloud Console die Seite Instanz erstellen auf.
  
  Zur Seite „Instanz erstellen“
  
  Die Seite Instanz erstellen wird geöffnet.
2. Geben Sie einen Namen für Ihre VM an.
3. Wählen Sie in den folgenden Abschnitten eine Konfiguration aus, die genau mit allen Attributen Ihrer Reservierung übereinstimmt, einschließlich eventueller optionaler Attribute. In diesem Beispiel müssen Sie folgende VM-Attribute mit reservation-02 abgleichen:
  - Region: us-central1
  - Zone: us-central1-a
  - Maschinentyp: n2-standard-32
  - Mindest-CPU-Plattform: Intel Cascade Lake
  - GPUs: keine
  - Lokale SSDs: keine
4. Maximieren Sie den Bereich Erweiterte Optionen und dann den Bereich Verwaltung. Wählen Sie in der Liste Reservierungen die Option Bestimmte Reservierung auswählen und führen Sie dann folgende Schritte aus:
  1. Wählen Sie ein Reservierungsprojekt aus, das freigegebene Reservierungen für Ihr aktuelles Projekt enthält. Wählen Sie für dieses Beispiel das Projekt aus, mit dem Sie reservation-02 erstellt haben.
  2. Wählen Sie den Reservierungsnamen der freigegebenen Reservierung aus, die diese VM nutzen soll. Wählen Sie für dieses Beispiel reservation-02 aus.
5. Klicken Sie auf Erstellen, um die VM zu erstellen.

gcloud

Erstellen Sie mit dem Flag --require-specific-reservation eine Reservierung mit dem Namen reservation-02. Diese reservierten Ressourcen können nur von VMs verwendet werden, für die diese Reservierung ausdrücklich namentlich ausgewählt wurde.

gcloud compute reservations create reservation-02 \
    --machine-type=n2-standard-32 \
    --min-cpu-platform="Intel Cascade Lake" \
    --vm-count=10 \
    --zone=us-central1-a \
    --project=my-owner-project \
    --share-setting=projects \
    --share-with=project-1,project-2 \
    --require-specific-reservation

Erstellen Sie mit den Flags --reservation-affinity und --reservation eine VM, die namentlich mit reservation-02 verknüpft ist. Um diese Reservierung von allen Nutzerprojekten zu nutzen, für die diese Reservierung freigegeben wird, müssen Sie auch das Projekt angeben, mit dem die Reservierung erstellt wurde: my-owner-project.

Die Attribute der VM müssen mit den VM-Attributen der Reservierung übereinstimmen, einschließlich Zone, Maschinentyp (Maschinenfamilie, vCPUs und Arbeitsspeicher), Mindest-CPU-Plattform, GPU-Anzahl und -Typ sowie Schnittstelle und Größe der lokalen SSD.
```
gcloud compute instances create instance-2 \
    --machine-type=n2-standard-32 \
    --min-cpu-platform="Intel Cascade Lake" \
    --zone=us-central1-a \
    --reservation-affinity=specific \
    --reservation=projects/my-owner-project/reservations/reservation-02
```

Go

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

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);
    }
  }
}

Python

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

Erstellen Sie mit dem auf true festgelegten Feld specificReservationRequired eine Reservierung mit dem Namen reservation-02.

POST https://compute.googleapis.com/compute/v1/projects/my-owner-project/zones/us-central1-a/reservations

{
  "name":"reservation-02",
  "specificReservation":{
    "count":"10",
    "instanceProperties":{
      "machineType":"n2-standard-32",
      "minCpuPlatform": "Intel Cascade Lake"
    }
  },
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "project-1": {
        "projectId": "project-1"
      },
      "project-2": {
        "projectId": "project-2"
      }
    }
  },
  "specificReservationRequired": true
}

Erstellen Sie mit den Feld reservationAffinity eine VM, die namentlich mit reservation-02 verknüpft ist. Um diese Reservierung von allen Nutzerprojekten zu nutzen, für die diese Reservierung freigegeben wird, müssen Sie auch das Inhaberprojekt der Reservierung angeben: my-owner-project.

POST https://compute.googleapis.com/compute/v1/projects/project-2/zones/us-central1-a/instances

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

VMs erstellen, ohne Reservierungen zu nutzen

Wenn Sie eine automatisch genutzte Reservierung erstellen, kann die Reservierung von allen laufenden VMs mit übereinstimmenden Attributen in Ihrem Projekt genutzt werden. So verhindern Sie, dass eine oder mehrere Ihrer VMs die Reservierung verbrauchen:

Legen Sie das Attribut „Reservierungsaffinität“ der VMs so fest, dass keine Reservierungen verwendet werden, wie in diesem Abschnitt beschrieben.
Ihre VMs stimmen nicht mit den VM-Attributen der Reservierung überein.

Wählen Sie eine der folgenden Methoden aus, um VMs zu erstellen, die explizit keine Reservierungen verbrauchen:

Erstellen Sie eine VM, die keine Reservierungen verbraucht.
Erstellen Sie eine Instanzvorlage, die keine Reservierungen nutzt.

VM erstellen, die keine Reservierungen nutzt

Wählen Sie eine der folgenden Optionen aus, um eine VM zu erstellen, die explizit keine Reservierungen nutzt:

Console

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

Zur Seite „Instanz erstellen“
Geben Sie im Feld Name einen Namen für die VM ein.
Wählen Sie in den Listen Region und Zone die Region und Zone aus, in der die VM erstellt werden soll.
Geben Sie im Abschnitt Maschinenkonfiguration den Maschinentyp an, der für die VM verwendet werden soll.
Maximieren Sie den Abschnitt Erweiterte Optionen und gehen Sie dann so vor:
1. Maximieren Sie den Bereich Verwaltung.
2. Wählen Sie im Bereich Reservierungen in der Liste Anwendungsrichtlinie die Option Nicht verwenden aus.
Klicken Sie auf Erstellen.

gcloud

Verwenden Sie zum Erstellen einer VM, die explizit keine Reservierungen nutzt, den Befehl gcloud compute instances create mit dem Flag --reservation-affinity=none.

gcloud compute instances create VM_NAME \
    --machine-type=MACHINE_TYPE \
    --reservation-affinity=none \
    --zone=ZONE

Ersetzen Sie dabei Folgendes:

VM_NAME: der Name der VM.
MACHINE_TYPE ist der für die VM zu verwendende Maschinentyp.
ZONE: die Zone, in der die VM-Instanz erstellt werden soll.

Go

import (
	"context"
	"fmt"
	"io"

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

// createInstanceNotConsumeReservation creates VM, without consuming reservation
func createInstanceNotConsumeReservation(w io.Writer, projectID, zone, instanceName string) error {
	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"),
				},
			},
			ReservationAffinity: &computepb.ReservationAffinity{
				ConsumeReservationType: proto.String("NO_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\n")

	return nil
}

Java

import static com.google.cloud.compute.v1.ReservationAffinity.ConsumeReservationType.NO_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 CreateInstanceWithoutConsumingReservation {
  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 you want to use.
    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.
    // *   This value uses the format zones/{zone}/machineTypes/{type_name}.
    // *   For a list of machine types, see https://cloud.google.com/compute/docs/machine-types
    String machineTypeName = "n1-standard-1";
    // 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";

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

  // Create a virtual machine that explicitly doesn't consume reservations
  public static Instance createInstanceWithoutConsumingReservationAsync(
      String project, String zone, String instanceName,
      String machineTypeName, String sourceImage, long diskSizeGb, String networkName)
      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(NO_RESERVATION.toString())
              .build();

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

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

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

      // Wait for the operation to complete.
      Operation response = operation.get(3, TimeUnit.MINUTES);

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

Node.js

// 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 a VM that explicitly doesn't consume reservations
async function callCreateInstanceToNotConsumeReservation() {
  // 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: 'NO_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 callCreateInstanceToNotConsumeReservation();

Python

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 create_vm_not_consume_reservation(
    project_id: str, zone: str, instance_name: str, machine_type: str = "n2-standard-2"
) -> compute_v1.Instance:
    """Creates a VM that explicitly doesn't consume reservations
    Args:
        project_id (str): The ID of the Google Cloud project.
        zone (str): The zone where the VM will be created.
        instance_name (str): The name of the instance to create.
        machine_type (str, optional): The machine type for the instance.
    Returns:
        compute_v1.Instance: The created instance.
    """
    instance = compute_v1.Instance()
    instance.name = instance_name
    instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
    instance.zone = zone

    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
                )
            ],
        )
    ]

    # Set the reservation affinity to not consume any reservation
    instance.reservation_affinity = compute_v1.ReservationAffinity(
        consume_reservation_type="NO_RESERVATION",  # Prevents the instance from consuming reservations
    )

    # 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"Creating the {instance_name} instance in {zone}...")

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

REST

Wenn Sie eine VM erstellen möchten, die explizit keine Reservierungen nutzt, senden Sie eine POST-Anfrage an die Methode instances.insert. Geben Sie im Anfragetext das Feld consumeReservationType an, das auf NO_RESERVATION gesetzt ist.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances

{
  "name": "VM_NAME",
  "machineType": "zones/ZONE/machineTypes/MACHINE_TYPE",
  "disks": [
    {
      "boot": true,
      "initializeParams": {
        "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
      }
    }
  ],
  "networkInterfaces": [
    {
      "network": "global/networks/default"
    }
  ],
  "reservationAffinity": {
    "consumeReservationType": "NO_RESERVATION"
  }
}

Ersetzen Sie dabei Folgendes:

PROJECT_ID: ID des Projekts, in dem die VM erstellt werden soll.
ZONE: die Zone, in der die VM-Instanz erstellt werden soll.
VM_NAME: der Name der VM.
MACHINE_TYPE ist der für die VM zu verwendende Maschinentyp.
IMAGE_PROJECT: das Image-Projekt, das das Betriebssystem-Image enthält, z. B. debian-cloud. Weitere Informationen zu den unterstützten Image-Projekten finden Sie unter Öffentliche Images.
IMAGE: Wählen Sie eine der folgenden Optionen aus:
- Eine bestimmte Version des Betriebssystem-Images; Beispiel: debian-12-bookworm-v20240617.
- Eine Image-Familie, die als family/IMAGE_FAMILY formatiert sein muss. Damit wird das neueste nicht verworfene Betriebssystem-Image angegeben. Beispiel: Wenn Sie family/debian-12 angeben, wird die aktuelle Version in der Debian 12-Image-Familie verwendet. Weitere Informationen zur Verwendung von Image-Familien finden Sie unter Best Practices für Image-Familien.

Weitere Informationen zum Erstellen einer VM finden Sie unter Compute Engine-Instanz erstellen und starten.

Instanzvorlage erstellen, die keine Reservierungen nutzt

Wählen Sie eine der folgenden Optionen aus, um eine Instanzvorlage zu erstellen, mit der VMs erstellt werden, die explizit keine Reservierungen verbrauchen:

Console

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

Zur Seite "Instanzvorlage erstellen".
Geben Sie im Feld Name einen Namen für die Instanzvorlage ein.
Geben Sie im Bereich Speicherort an, ob Sie eine regionale (Standardeinstellung) oder globale Instanzvorlage erstellen möchten.
Geben Sie im Abschnitt Maschinenkonfiguration den Maschinentyp an, der für die mit der Vorlage erstellten VMs verwendet werden soll.
Maximieren Sie den Abschnitt Erweiterte Optionen und gehen Sie dann so vor:
1. Maximieren Sie den Bereich Verwaltung.
2. Wählen Sie im Bereich Reservierungen in der Liste Anwendungsrichtlinie die Option Nicht verwenden aus.
Klicken Sie auf Erstellen.

gcloud

Verwenden Sie den Befehl gcloud compute instances-templates create mit dem Flag --reservation-affinity=none, um eine Instanzvorlage zu erstellen, mit der VMs erstellt werden, die explizit keine Reservierungen verbrauchen.

Führen Sie beispielsweise den folgenden Befehl aus, um eine globale Instanzvorlage zu erstellen, die VMs erstellt, die explizit keine Reservierungen nutzen:

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --machine-type=MACHINE_TYPE \
    --reservation-affinity=none

Ersetzen Sie dabei Folgendes:

INSTANCE_TEMPLATE_NAME ist der Name der Instanzvorlage.
MACHINE_TYPE: Maschinentyp für die mithilfe der Instanzvorlage erstellten VMs.

Go

import (
	"context"
	"fmt"
	"io"

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

// createInstanceNotConsumeReservation creates a new instance template, which won't consume reservations
func createTemplateNotConsumeReservation(w io.Writer, projectID, templateName string) error {
	// projectID := "your_project_id"
	// templateName := "your_template_name"

	ctx := context.Background()
	instanceTemplatesClient, err := compute.NewInstanceTemplatesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstanceTemplatesRESTClient: %w", err)
	}
	defer instanceTemplatesClient.Close()

	req := &computepb.InsertInstanceTemplateRequest{
		Project: projectID,
		InstanceTemplateResource: &computepb.InstanceTemplate{
			Name: proto.String(templateName),
			Properties: &computepb.InstanceProperties{
				// The template describes the size and source image of the boot disk
				// to attach to the instance.
				Disks: []*computepb.AttachedDisk{
					{
						InitializeParams: &computepb.AttachedDiskInitializeParams{
							DiskSizeGb:  proto.Int64(250),
							SourceImage: proto.String("projects/debian-cloud/global/images/family/debian-11"),
						},
						AutoDelete: proto.Bool(true),
						Boot:       proto.Bool(true),
					},
				},
				MachineType: proto.String("e2-standard-4"),
				// The template connects the instance to the `default` network,
				// without specifying a subnetwork.
				NetworkInterfaces: []*computepb.NetworkInterface{
					{
						Name: proto.String("global/networks/default"),
						// The template lets the instance use an external IP address.
						AccessConfigs: []*computepb.AccessConfig{
							{
								Name:        proto.String("External NAT"),
								Type:        proto.String(computepb.AccessConfig_ONE_TO_ONE_NAT.String()),
								NetworkTier: proto.String(computepb.AccessConfig_PREMIUM.String()),
							},
						},
					},
				},
				ReservationAffinity: &computepb.ReservationAffinity{
					ConsumeReservationType: proto.String("NO_RESERVATION"),
				},
			},
		},
	}

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

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

	fmt.Fprintf(w, "Instance template created\n")

	return nil
}

Java

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

import com.google.cloud.compute.v1.AccessConfig;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.InsertInstanceTemplateRequest;
import com.google.cloud.compute.v1.InstanceProperties;
import com.google.cloud.compute.v1.InstanceTemplate;
import com.google.cloud.compute.v1.InstanceTemplatesClient;
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 CreateTemplateWithoutConsumingReservation {
  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 template you want to query.
    String templateName = "YOUR_INSTANCE_TEMPLATE_NAME";
    String machineType = "e2-standard-4";
    String sourceImage = "projects/debian-cloud/global/images/family/debian-11";

    createTemplateWithoutConsumingReservationAsync(
        projectId, templateName, machineType, sourceImage);
  }


  // Create a template that explicitly doesn't consume any reservations.
  public static InstanceTemplate createTemplateWithoutConsumingReservationAsync(
      String projectId, String templateName, String machineType, String sourceImage)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create()) {
      AttachedDisk attachedDisk = AttachedDisk.newBuilder()
          .setInitializeParams(AttachedDiskInitializeParams.newBuilder()
              .setSourceImage(sourceImage)
              .setDiskType("pd-balanced")
              .setDiskSizeGb(250)
              .build())
          .setAutoDelete(true)
          .setBoot(true)
          .build();

      NetworkInterface networkInterface = NetworkInterface.newBuilder()
          .setName("global/networks/default")
          .addAccessConfigs(AccessConfig.newBuilder()
              .setName("External NAT")
              .setType(AccessConfig.Type.ONE_TO_ONE_NAT.toString())
              .setNetworkTier(AccessConfig.NetworkTier.PREMIUM.toString())
              .build())
          .build();

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

      InstanceProperties instanceProperties = InstanceProperties.newBuilder()
          .addDisks(attachedDisk)
          .setMachineType(machineType)
          .setReservationAffinity(reservationAffinity)
          .addNetworkInterfaces(networkInterface)
          .build();

      InsertInstanceTemplateRequest insertInstanceTemplateRequest = InsertInstanceTemplateRequest
          .newBuilder()
          .setProject(projectId)
          .setInstanceTemplateResource(InstanceTemplate.newBuilder()
              .setName(templateName)
              .setProperties(instanceProperties)
              .build())
          .build();

      Operation response = instanceTemplatesClient.insertAsync(insertInstanceTemplateRequest)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        return null;
      }
      return instanceTemplatesClient.get(projectId, templateName);
    }
  }
}

Node.js

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

// Instantiate an instanceTemplatesClient
const instanceTemplatesClient = new computeLib.InstanceTemplatesClient();
// Instantiate a globalOperationsClient
const globalOperationsClient = new computeLib.GlobalOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The ID of the project where you want to create template.
const projectId = await instanceTemplatesClient.getProjectId();
// The name of the template to create.
// const templateName = 'instance-01';

// Create an instance template that creates VMs that don't explicitly consume reservations
async function callCreateTemplateToNotConsumeReservation() {
  // Define the boot disk for the instance template
  const disk = new compute.AttachedDisk({
    initializeParams: new compute.AttachedDiskInitializeParams({
      sourceImage:
        'projects/debian-cloud/global/images/debian-12-bookworm-v20240815',
      diskSizeGb: '100',
      diskType: 'pd-balanced',
    }),
    autoDelete: true,
    boot: true,
    type: 'PERSISTENT',
  });

  // Define the network interface for the instance template
  const network = new compute.NetworkInterface({
    network: `projects/${projectId}/global/networks/default`,
  });

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

  // Define instance template
  const instanceTemplate = new compute.InstanceTemplate({
    name: templateName,
    properties: {
      disks: [disk],
      machineType: 'e2-medium',
      // The template connects the instance to the `default` network,
      // without specifying a subnetwork.
      networkInterfaces: [network],
      reservationAffinity,
    },
  });

  const [response] = await instanceTemplatesClient.insert({
    project: projectId,
    instanceTemplateResource: instanceTemplate,
  });

  let operation = response.latestResponse;

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

  console.log(`Template ${templateName} created.`);
}

await callCreateTemplateToNotConsumeReservation();

Python

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 create_instance_template_not_consume_reservation(
    project_id: str,
    template_name: str,
    machine_type: str = "n1-standard-1",
) -> compute_v1.InstanceTemplate:
    """
    Creates an instance template that creates VMs that don't explicitly consume reservations

    Args:
        project_id: project ID or project number of the Cloud project you use.
        template_name: name of the new template to create.
        machine_type: machine type for the instance.
    Returns:
        InstanceTemplate object that represents the new instance template.
    """

    template = compute_v1.InstanceTemplate()
    template.name = template_name
    template.properties.machine_type = machine_type
    # The template describes the size and source image of the boot disk
    # to attach to the instance.
    template.properties.disks = [
        compute_v1.AttachedDisk(
            boot=True,
            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,
            ),
        )
    ]
    # The template connects the instance to the `default` network,
    template.properties.network_interfaces = [
        compute_v1.NetworkInterface(
            network="global/networks/default",
            access_configs=[
                compute_v1.AccessConfig(
                    name="External NAT",
                    type="ONE_TO_ONE_NAT",
                )
            ],
        )
    ]
    # The template doesn't explicitly consume reservations
    template.properties.reservation_affinity = compute_v1.ReservationAffinity(
        consume_reservation_type="NO_RESERVATION"
    )

    template_client = compute_v1.InstanceTemplatesClient()
    operation = template_client.insert(
        project=project_id, instance_template_resource=template
    )

    wait_for_extended_operation(operation, "instance template creation")

    return template_client.get(project=project_id, instance_template=template_name)

REST

Wenn Sie eine Instanzvorlage erstellen möchten, mit der VMs erstellt werden, die explizit keine Reservierungen verbrauchen, senden Sie eine POST-Anfrage an eine der folgenden Methoden:

So erstellen Sie eine globale Instanzvorlage: instanceTemplates.insert-Methode
Zum Erstellen einer regionalen Instanzvorlage: regionInstanceTemplates.insert-Methode.

Fügen Sie im Anfragetext das Feld consumeReservationType ein und legen Sie es auf NO_RESERVATION fest.

Wenn Sie beispielsweise eine globale Instanzvorlage erstellen möchten, die VMs erstellt, die explizit keine Reservierungen nutzen, stellen Sie so eine Anfrage:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/InstanceTemplates

{
  "name": "INSTANCE_TEMPLATE_NAME",
  "properties": {
    "machineType": "MACHINE_TYPE",
    "disks": [
      {
        "boot": true,
        "initializeParams": {
          "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
        }
      }
    ],
    "networkInterfaces": [
      {
        "network": "global/networks/default"
      }
    ],
    "reservationAffinity": {
      "consumeReservationType": "NO_RESERVATION"
    }
  }
}

Ersetzen Sie dabei Folgendes:

PROJECT_ID: die ID des Projekts, in dem die Instanzvorlage erstellt werden soll.
INSTANCE_TEMPLATE_NAME ist der Name der Instanzvorlage.
MACHINE_TYPE: Maschinentyp für die mithilfe der Instanzvorlage erstellten VMs.
IMAGE_PROJECT: das Image-Projekt, das das Betriebssystem-Image enthält, z. B. debian-cloud. Weitere Informationen zu den unterstützten Image-Projekten finden Sie unter Öffentliche Images.
IMAGE: Wählen Sie eine der folgenden Optionen aus:
- Eine bestimmte Version des Betriebssystem-Images; Beispiel: debian-12-bookworm-v20240617.
- Eine Image-Familie, die als family/IMAGE_FAMILY formatiert sein muss. Damit wird das neueste nicht verworfene Betriebssystem-Image angegeben. Beispiel: Wenn Sie family/debian-12 angeben, wird die aktuelle Version in der Debian 12-Image-Familie verwendet. Weitere Informationen zur Verwendung von Image-Familien finden Sie unter Best Practices für Image-Familien.

Weitere Informationen zum Erstellen von Instanzvorlagen finden Sie unter Instanzvorlagen erstellen.

Testen, ob VM-Attribute mit einer Reservierung übereinstimmen

Wenn Sie testen möchten, ob VMs automatisch eine Reservierung nutzen können, erstellen Sie eine Kopie der Reservierung als bestimmte Reservierung und prüfen dann, ob eine zu erstellende VM diese Reservierung nutzen kann. Wenn Sie die VM erstellen können, haben Sie bestätigt, dass die VM die übereinstimmende Reservierung korrekt nutzen kann. Andernfalls schlägt das Erstellen der VM fehl, da: die Attribute nicht übereinstimmen oder weil keine reservierten Ressourcen verfügbar sind. Nach dem Test können Sie einen oder mehrere der folgenden Schritte ausführen:

Löschen oder aktualisieren Sie die spezifische Reservierung, die Sie für den Test verwendet haben.
Löschen Sie die VM oder aktualisieren Sie sie, um eine andere Reservierungsaffinität (reservationAffinity) zu haben.

Reservierungsnutzung prüfen

Sie können mit den folgenden Methoden prüfen, ob Ihre VMs Ihre Reservierungen effektiv nutzen:

Details zur Reservierung ansehen

Wenn die Anzahl der VMs, die eine Reservierung nutzen, nach dem Erstellen oder Aktualisieren einer VM um 1 erhöht wird, hat Ihre Aktion wahrscheinlich dazu geführt, dass die VM diese Reservierung nutzt. So können Sie am schnellsten prüfen, ob eine Reservierung in Anspruch genommen wird. Sie eignet sich jedoch möglicherweise nicht dazu, um zu ermitteln, welche VM eine Reservierung nutzt.
VM erstellen, die auf eine bestimmte Reservierung ausgerichtet ist

Wenn Sie eine VM erfolgreich erstellen können, die auf eine bestimmte Reservierung abzielt, nutzt die VM die Reservierung. Dies ist die zuverlässigste Methode, um zu prüfen, ob eine bestimmte VM eine Reservierung nutzt und ob die Attribute der VM mit den Attributen der Reservierung übereinstimmen.
Reservierungsnutzung überwachen

Mit Cloud Monitoring können Sie auf die Informationen zur Nutzung der Reservierungen zugreifen, die in Ihrem Projekt erstellt wurden. Die Daten zur Reservierungsnutzung werden mindestens alle 30 Minuten aktualisiert. Diese Methode ist nützlich, um den Nutzungsverlauf einer oder mehrerer Reservierungen in einem Projekt zu prüfen und Benachrichtigungen für nicht ausgelastete oder nicht verwendete Reservierungen zu erhalten.

Vergangene Nutzung Ihrer Reservierungen ansehen

Mit dem Kapazitätsplaner (Vorabversion) können Sie auf die bisherige Nutzung Ihrer Reservierungen zugreifen und sie sich ansehen, von ihrer Erstellung bis zu ihrer Löschung. Im Kapazitätsplaner werden die Daten zum Verbrauch von Reservierungen alle 24 Stunden aktualisiert. Diese Methode ist nützlich, um die bisherige Inanspruchnahme Ihrer Reservierungen in einem Projekt, Ordner oder einer Organisation zu überprüfen und zukünftige Kapazitätsanforderungen zu planen.

Wenn eine VM eine Reservierung nicht nutzt, obwohl die Reservierungsaffinität der VM die Reservierung nutzen kann, die Reservierung nicht vollständig genutzt wird und die Attribute der VM und der Reservierung übereinstimmen, lesen Sie den Hilfeartikel Ressourcenverfügbarkeit.

Nutzungsberichte zu Reservierungen ansehen

Exportieren Sie detaillierte Berichte zur Nutzung von Compute Engine mit dem Exportfeature in einen Cloud Storage-Bucket. Eine Anleitung finden Sie unter Nutzungsberichte ansehen.

Der Bericht enthält folgende Angaben:

Genutzte reservierte Ressourcen. Diese Einträge werden als normale Ressourcen in Bezug auf vCPUs, Arbeitsspeicher, GPUs und lokale SSDs angezeigt.
Ungenutzte reservierte Ressourcen. Diese Einträge haben normale SKU-Namen und Reservierungsressourcen-URIs.
Die Gesamtzahl der reservierten Ressourcen. Diese Einträge haben Reservierungs-SKU-Namen und Reservierungsressourcen-URIs. Mit diesen Einträgen sind keine Kosten verbunden. Berechnen Sie anhand dieser Einträge, wie viel von Ihren Reservierungen Sie nutzen.

Messung	`MeasurementId`-Format	`Resource URI`-Format
Genutzte reservierte Ressourcen	`com.google.cloud/services/compute-engine/SKU_NAME`	`https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/RESOURCE_TYPE/RESOURCE_NAME`. Beispiel: `https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central1-a/instances/my-instance`
Ungenutzte reservierte Ressourcen	`com.google.cloud/services/compute-engine/SKU_NAME`	`https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations/RESERVATION_NAME`. Beispiel: `https://compute.googleapis.com/compute/v1/projects/my-project/zones/europe-west1-b/reservations/my-reservation`
Reservierte Ressourcen insgesamt	`com.google.cloud/services/compute-engine/ReservationSKU_NAME`	`https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations/RESERVATION_NAME`. Beispiel: `https://compute.googleapis.com/compute/v1/projects/my-project/zones/europe-west1-b/reservations/my-reservation`

Das folgende Snippet aus einem Nutzungsbericht für eine Reservierung namens my-reservation enthält z. B. folgende Informationen:

Zeile 1 gibt den reservierten RAM an, der aktuell genutzt wird. Die ResourceId der Zeile zeigt, dass dieser RAM von einer VM namens my-instance genutzt wird.
Zeile 2 gibt reservierten RAM an, der nicht genutzt wird. Die ResourceId der Zeile gibt an, dass der reservierte RAM von my-reservation genutzt wird. Er wird noch nicht von einer VM verwendet.
Zeile 3 gibt den gesamten reservierten RAM an.

Report Date,MeasurementId,Quantity,Unit,Resource URI,ResourceId,Location
2019-06-06,com.google.cloud/services/compute-engine/VmimageN2StandardRam,166970074857472,byte-seconds,https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central2-a/instances/my-instance,1775485842510981624,us-central2-a
2019-06-06,com.google.cloud/services/compute-engine/VmimageN2StandardRam,166970074857472,byte-seconds,https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central2-a/reservations/my-reservation,7.58809E+17,us-central2-a
2019-06-06,com.google.cloud/services/compute-engine/ReservationN2StandardRam,333940149714944,byte-seconds,https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central2-a/reservations/my-reservation,7.58809E+17,us-central2-a
...

Fehlerbehebung

Erfahren Sie, wie Sie Probleme mit der Nutzung von Reservierungen beheben.

Reservierungen nutzen

Vorbereitung

Console

gcloud

Go

Java

Node.js

Python

REST

Erforderliche Rollen

Erforderliche Berechtigungen

Reservierte VMs nutzen

VMs aus jeder übereinstimmenden Reservierung nutzen

Console

gcloud

Go

Java

Node.js

Python

REST

VMs aus einer bestimmten Reservierung nutzen

Eine bestimmte Reservierung für ein einzelnes Projekt verwenden

Console

gcloud

Go

Java

Node.js

Python

REST

Eine bestimmte freigegebene Reservierung nutzen

Console

gcloud

Go

Java

Python

REST

VMs erstellen, ohne Reservierungen zu nutzen

VM erstellen, die keine Reservierungen nutzt

Console

gcloud

Go

Java

Node.js

Python

REST

Instanzvorlage erstellen, die keine Reservierungen nutzt

Console

gcloud

Go

Java

Node.js

Python

REST

Testen, ob VM-Attribute mit einer Reservierung übereinstimmen

Reservierungsnutzung prüfen

Nutzungsberichte zu Reservierungen ansehen

Fehlerbehebung

Nächste Schritte