Verhindern, dass Compute-Instanzen Reservierungen nutzen

---

In diesem Dokument wird beschrieben, wie Sie verhindern, dass Compute Engine-Instanzen Reservierungen verbrauchen. Informationen zu Reservierungen finden Sie unter Zonale Reservierungen von Compute Engine-Ressourcen.

Bei automatisch konsumierten Reservierungen können Instanzen mit Attributen, die mit den Reservierungen übereinstimmen, diese automatisch nutzen. Führen Sie einen der folgenden Schritte aus, um zu verhindern, dass Instanzen eine Reservierung nutzen:

• Konfigurieren Sie Instanzen so, dass sie keine Reservierungen verbrauchen, wie in diesem Dokument beschrieben.

• Instanzen mit Attributen erstellen oder aktualisieren, die nicht mit der Reservierung übereinstimmen.

Sie können vermeiden, Reservierungen zu nutzen, wenn Sie Ihre Instanzen für Aufgaben wie Tests, Debugging oder isolierte Bereitstellungen verwenden möchten.

Beschränkungen

Sie können eine vorhandene Instanz nur dann so aktualisieren, dass sie keine Reservierungen mehr nutzt, wenn die Instanz so konfiguriert ist, dass sie automatisch übereinstimmende Reservierungen nutzt.

Hinweise

• 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.

  Go

  Wenn Sie die Go Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. If you're using a local shell, then create local authentication credentials for your user account:

     gcloud auth application-default login

     You don't need to do this if you're using Cloud Shell.

  Weitere Informationen unter Set up authentication for a local development environment.

  Java

  Wenn Sie die Java Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. If you're using a local shell, then create local authentication credentials for your user account:

     gcloud auth application-default login

     You don't need to do this if you're using Cloud Shell.

  Weitere Informationen unter Set up authentication for a local development environment.

  Node.js

  Wenn Sie die Node.js Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. If you're using a local shell, then create local authentication credentials for your user account:

     gcloud auth application-default login

     You don't need to do this if you're using Cloud Shell.

  Weitere Informationen unter Set up authentication for a local development environment.

  Python

  Wenn Sie die Python Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. If you're using a local shell, then create local authentication credentials for your user account:

     gcloud auth application-default login

     You don't need to do this if you're using Cloud Shell.

  Weitere Informationen unter Set up authentication for a local development environment.

  REST

  Verwenden Sie die von der gcloud CLI bereitgestellten Anmeldedaten, um die REST API-Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung zu verwenden.

  Install the Google Cloud CLI, then initialize it by running the following command:

  gcloud init

  Weitere Informationen finden Sie unter Für die Verwendung von REST authentifizieren in der Dokumentation zur Google Cloud-Authentifizierung.

Erforderliche Rollen

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

Diese vordefinierte Rolle enthält die Berechtigungen, die erforderlich sind, um zu verhindern, dass eine Compute-Instanz Reservierungen in Anspruch nimmt. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um zu verhindern, dass eine Compute-Instanz Reservierungen in Anspruch nimmt:

• Zum Erstellen von Reservierungen: compute.reservations.create für das Projekt
• So erstellen Sie Instanzen:
  • 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.

Nutzung von Reservierungen verhindern

Wenn Sie verhindern möchten, dass eine Compute-Instanz Reservierungen nutzt, legen Sie das Attribut „reservationAffinity“ (reservationAffinity) so fest, dass keine Reservierungen genutzt werden. Mit dieser Eigenschaft wird festgelegt, ob eine Instanz übereinstimmende Reservierungen, eine bestimmte Reservierung oder keine Reservierungen nutzen kann.

Wenn Sie verhindern möchten, dass eine oder mehrere Instanzen Reservierungen nutzen, können Sie eine der folgenden Methoden verwenden:

• Verbrauch in einer vorhandenen Instanz verhindern

• Nutzung beim Erstellen einer Instanz verhindern

• Nutzung beim Erstellen mehrerer Instanzen verhindern

• Nutzung beim Erstellen einer Instanzvorlage verhindern

Verbrauch in einer bestehenden Instanz verhindern

Sie können eine laufende Instanz so aktualisieren, dass sie keine Reservierungen mehr automatisch in Anspruch nimmt. Sie müssen die Instanz neu starten, damit die Änderungen wirksam werden, wie in diesem Abschnitt beschrieben.

Wenn Sie verhindern möchten, dass eine vorhandene Instanz Reservierungen in Anspruch nimmt, wählen Sie eine der folgenden Optionen aus:

gcloud

1. Erstellen Sie eine leere YAML-Datei.

2. Verwenden Sie den Befehl gcloud compute instances export, um die Eigenschaften einer Instanz in die gerade erstellte YAML-Datei zu exportieren:

   gcloud compute instances export INSTANCE_NAME \
       --destination=YAML_FILE \
       --zone=ZONE
   

   Ersetzen Sie Folgendes:

   • INSTANCE_NAME: der Name der Instanz.

   • YAML_FILE: Pfad zur leeren YAML-Datei, die Sie im vorherigen Schritt erstellt haben.

   • ZONE: Die Zone, in der sich die Instanz befindet.

3. Legen Sie in der YAML-Konfigurationsdatei consumeReservationType auf NO_RESERVATION fest:

   reservationAffinity:
     consumeReservationType: NO_RESERVATION
   

4. Verwenden Sie zum Aktualisieren und Neustarten der Instanz den Befehl gcloud compute instances update-from-file, wobei das Flag --most-disruptive-allowed-action auf RESTART gesetzt ist:

   gcloud compute instances update-from-file INSTANCE_NAME \
       --most-disruptive-allowed-action=RESTART \
       --source=YAML_FILE \
       --zone=ZONE
   

   Ersetzen Sie Folgendes:

   • INSTANCE_NAME: der Name der Instanz.

   • YAML_FILE: Pfad zur YAML-Datei mit den Konfigurationsdaten, die Sie im vorherigen Schritt geändert haben.

   • ZONE: Die Zone, in der sich die Instanz befindet.

REST

1. Wenn Sie die Eigenschaften einer vorhandenen Instanz aufrufen möchten, senden Sie eine GET-Anfrage an die instances.get-Methode:

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

   Ersetzen Sie Folgendes:

   • PROJECT_ID: die ID des Projekts, in dem Sie die Instanz erstellt haben.

   • ZONE: Die Zone, in der sich die Instanz befindet.

   • INSTANCE_NAME: der Name der Instanz.

2. Speichern Sie die Ausgabe der GET-Anfrage in einer Datei oder einem Texteditor. Ändern Sie die kopierte Ausgabe so, dass das Feld consumeReservationType in NO_RESERVATION geändert wird:

   {
     ...
     "reservationAffinity": {
       "consumeReservationType": "NO_RESERVATION"
     },
     ...
   }
   

3. Wenn Sie die Instanz aktualisieren und neu starten möchten, senden Sie eine PUT-Anfrage an die Methode instances.update. Gehen Sie in der Anfrage so vor:

   • Fügen Sie in der Anfrage-URL den Abfrageparameter mostDisruptiveAllowedAction ein, wobei dieser auf RESTART gesetzt ist.

   • Verwenden Sie für den Anfragetext die Ausgabe der GET-Anfrage, die Sie in einem vorherigen Schritt bearbeitet haben.

   Die Anfrage sieht etwa so aus:

   PUT https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central-1/instances/instance-01?mostDisruptiveAllowedAction=RESTART
   
   {
     ...
     "reservationAffinity": {
       "consumeReservationType": "NO_RESERVATION"
     },
     ...
   }
   

Weitere Informationen zum Aktualisieren einer Instanz finden Sie unter Instanzattribute aktualisieren.

Verbrauch beim Erstellen einer Instanz verhindern

Wenn Sie eine Compute-Instanz erstellen möchten, die keine Reservierungen verbrauchen kann, wählen Sie eine der folgenden Optionen aus:

Console

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

   Zur Seite „Instanz erstellen“

2. Geben Sie im Feld Name einen Namen für die Instanz ein.

3. Wählen Sie in den Listen Region und Zone die Region und Zone aus, in der die Instanz erstellt werden soll.

4. Geben Sie den Maschinentyp an, der für die Instanz verwendet werden soll.

5. Klicken Sie im Navigationsmenü auf Erweitert.

6. Wählen Sie im Abschnitt Reservierungen die Option Keine Reservierung verwenden aus.

7. Klicken Sie auf Erstellen.

gcloud

Wenn Sie eine Instanz erstellen möchten, die keine Reservierungen nutzen kann, verwenden Sie den Befehl gcloud compute instances create mit dem Flag --reservation-affinity, das auf none festgelegt ist:

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

Ersetzen Sie Folgendes:

• INSTANCE_NAME: der Name der Instanz.

• MACHINE_TYPE: der für die Instanz zu verwendende Maschinentyp.

• ZONE: Zone, in der die Instanz erstellt werden soll.

Go

Verwenden Sie das folgende Codebeispiel, um eine Instanz zu erstellen, die keine Reservierungen nutzen kann:

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

Verwenden Sie das folgende Codebeispiel, um eine Instanz zu erstellen, die keine Reservierungen nutzen kann:

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

Verwenden Sie das folgende Codebeispiel, um eine Instanz zu erstellen, die keine Reservierungen nutzen kann:

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

Verwenden Sie das folgende Codebeispiel, um eine Instanz zu erstellen, die keine Reservierungen nutzen kann:

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 Instanz erstellen möchten, die keine Reservierungen nutzen kann, 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": "INSTANCE_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 Folgendes:

• PROJECT_ID: die ID des Projekts, in dem Sie die Instanz erstellen möchten.

• ZONE: Zone, in der die Instanz erstellt werden soll.

• INSTANCE_NAME: der Name der Instanz.

• MACHINE_TYPE: der für die Instanz 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. Diese gibt das neueste nicht verworfene Betriebssystem-Image an. 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 Instanz finden Sie unter Compute Engine-Instanz erstellen und starten.

Verbrauch beim Erstellen mehrerer Instanzen verhindern

Wählen Sie eine der folgenden Optionen aus, um Compute-Instanzen im Bulk zu erstellen, die keine Reservierungen verbrauchen können:

gcloud

Wenn Sie mehrere Instanzen erstellen möchten, die keine Reservierungen verbrauchen können, verwenden Sie den Befehl gcloud compute instances bulk create mit dem Flag --reservation-affinity, das auf none gesetzt ist.

Wenn Sie beispielsweise Instanzen im Bulk in einer einzelnen Zone erstellen und ein Namensmuster angeben möchten, führen Sie den folgenden Befehl aus:

gcloud compute instances bulk create \
    --count=COUNT \
    --machine-type=MACHINE_TYPE \
    --name-pattern="NAME_PATTERN" \
    --reservation-affinity=none \
    --zone=ZONE

Ersetzen Sie Folgendes:

• COUNT: Die Anzahl der zu erstellenden Instanzen.

• MACHINE_TYPE: der für die Instanzen zu verwendende Maschinentyp.

• NAME_PATTERN ist das Namensmuster für die Instanzen. Verwenden Sie eine Abfolge von Hash-Zeichen (#), um eine Zahlenfolge in einem Instanznamen zu ersetzen. Wenn Sie z. B. instance-# für das Namensmuster verwenden, werden Instanzen mit den Namen instance-1, instance-2 usw. bis zu der durch COUNT angegebenen Anzahl von Instanzen erzeugt.

• ZONE: Zone, in der Instanzen im Bulk erstellt werden sollen.

REST

Wenn Sie Instanzen im Bulk erstellen möchten, die keine Reservierungen verbrauchen können, senden Sie eine POST-Anfrage an die Methode instances.bulkInsert. Geben Sie im Anfragetext das Feld consumeReservationType an, das auf NO_RESERVATION gesetzt ist.

Wenn Sie beispielsweise Instanzen im Bulk in einer einzelnen Zone erstellen und ein Namensmuster angeben möchten, stellen Sie eine Anfrage wie hier beschrieben:

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

{
  "count": COUNT,
  "namePattern": "NAME_PATTERN",
  "instanceProperties": {
    "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 Folgendes:

• PROJECT_ID: Die ID des Projekts, in dem Instanzen im Bulk-Verfahren erstellt werden sollen.

• ZONE: Zone, in der Instanzen im Bulk erstellt werden sollen.

• COUNT: Die Anzahl der zu erstellenden Instanzen.

• NAME_PATTERN ist das Namensmuster für die Instanzen. Verwenden Sie eine Abfolge von Hash-Zeichen (#), um eine Zahlenfolge in einem Instanznamen zu ersetzen. Wenn Sie z. B. instance-# für das Namensmuster verwenden, werden Instanzen mit den Namen instance-1, instance-2 usw. bis zu der durch COUNT angegebenen Anzahl von Instanzen erzeugt.

• MACHINE_TYPE: der für die Instanzen 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. Diese gibt das neueste nicht verworfene Betriebssystem-Image an. 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 mehrerer Instanzen finden Sie unter VMs im Bulk erstellen.

Verbrauch beim Erstellen einer Instanzvorlage verhindern

Nachdem Sie eine Instanzvorlage erstellt haben, mit der Instanzen so konfiguriert werden, dass sie keine Reservierungen verbrauchen, können Sie mit der Vorlage Folgendes tun:

• So verhindern Sie, dass die Compute-Instanzen in einer verwalteten Instanzgruppe (MIG) Reservierungen verbrauchen:

  • MIG erstellen

  • Neue Instanzkonfigurationen in einer MIG anwenden

• Instanz erstellen, die keine Reservierungen nutzt

Wählen Sie eine der folgenden Optionen aus, um eine Instanzvorlage zu erstellen, mit der Instanzen so konfiguriert werden, dass sie keine Reservierungen verbrauchen:

Console

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

   Zur Seite "Instanzvorlage erstellen".

2. Geben Sie im Feld Name einen Namen für die Instanzvorlage ein.

3. Geben Sie im Bereich Speicherort an, ob Sie eine regionale (Standardeinstellung) oder globale Instanzvorlage erstellen möchten.

4. Geben Sie im Abschnitt Maschinenkonfiguration den Maschinentyp an, der für die mit der Vorlage erstellten Instanzen verwendet werden soll.

5. Maximieren Sie den Abschnitt Erweiterte Optionen und gehen Sie dann so vor:

   1. Maximieren Sie den Bereich Verwaltung.

   2. Wählen Sie im Abschnitt Reservierungen die Option Keine Reservierung verwenden aus.

6. Klicken Sie auf Erstellen.

gcloud

Verwenden Sie den Befehl gcloud compute instances-templates create mit dem Flag --reservation-affinity auf none, um eine Instanzvorlage zu erstellen, bei der Instanzen keine Reservierungen verbrauchen.

Führen Sie den folgenden Befehl aus, um eine regionale Instanzvorlage zu erstellen, mit der Instanzen so konfiguriert werden, dass sie keine Reservierungen verbrauchen. Wenn Sie eine globale Instanzvorlage erstellen möchten, verwenden Sie denselben Befehl ohne das Flag --instance-template-region.

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

Ersetzen Sie Folgendes:

• INSTANCE_TEMPLATE_NAME ist der Name der Instanzvorlage.

• REGION: Region, in der die Instanzvorlage erstellt werden soll.

• MACHINE_TYPE: Der Maschinentyp, der für die mit der Instanzvorlage erstellten Instanzen verwendet werden soll.

Go

Verwenden Sie das folgende Codebeispiel, um eine Instanzvorlage zu erstellen, mit der Instanzen so konfiguriert werden, dass sie keine Reservierungen verbrauchen:

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

Verwenden Sie das folgende Codebeispiel, um eine Instanzvorlage zu erstellen, mit der Instanzen so konfiguriert werden, dass sie keine Reservierungen verbrauchen:

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

Verwenden Sie das folgende Codebeispiel, um eine Instanzvorlage zu erstellen, mit der Instanzen so konfiguriert werden, dass sie keine Reservierungen verbrauchen:

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

Verwenden Sie das folgende Codebeispiel, um eine Instanzvorlage zu erstellen, mit der Instanzen so konfiguriert werden, dass sie keine Reservierungen verbrauchen:

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 Instanzen so konfiguriert werden, dass sie keine Reservierungen verbrauchen, senden Sie eine POST-Anfrage an eine der folgenden Methoden:

• Um eine globale Instanzvorlage zu erstellen: instanceTemplates.insert-Methode.

• Um eine regionale Instanzvorlage zu erstellen: regionInstanceTemplates.insert-Methode.

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

Wenn Sie beispielsweise eine regionale Instanzvorlage erstellen und angeben möchten, dass keine Reservierungen verbraucht werden sollen, stellen Sie eine Anfrage so:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/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 Folgendes:

• PROJECT_ID: die ID des Projekts, in dem die Instanzvorlage erstellt werden soll.

• INSTANCE_TEMPLATE_NAME ist der Name der Instanzvorlage.

• MACHINE_TYPE: Der Maschinentyp, der für die mit der Instanzvorlage erstellten Instanzen verwendet werden soll.

• 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. Diese gibt das neueste nicht verworfene Betriebssystem-Image an. 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.

Nächste Schritte

• Reservierungen ändern

• Reservierungen löschen