Impedire alle istanze di calcolo di utilizzare le prenotazioni

Questo documento spiega come impedire alle istanze Compute Engine di utilizzare le prenotazioni. Per scoprire di più sulle prenotazioni, consulta Prenotazioni di risorse di zona di Compute Engine.

Le prenotazioni consumate automaticamente consentono alle istanze con proprietà corrispondenti alle prenotazioni di utilizzarle automaticamente. Per evitare che le istanze utilizzino una prenotazione, esegui una delle seguenti operazioni:

  • Configura le istanze in modo che non consumino prenotazioni, come descritto in questo documento.

  • Crea o aggiorna istanze con proprietà che non corrispondono alla prenotazione.

Puoi evitare di utilizzare le prenotazioni quando vuoi utilizzare le tue istanze per attività come test, debug o implementazioni isolate.

Limitazioni

Puoi aggiornare un'istanza esistente in modo che non consumi le prenotazioni solo se l'istanza è configurata per utilizzare automaticamente le prenotazioni corrispondenti.

Prima di iniziare

  • Se non l'hai ancora fatto, configura l'autenticazione. L'autenticazione è il processo mediante il quale la tua identità viene verificata per l'accesso a servizi e API. Trusted Cloud by S3NS Per eseguire codice o esempi da un ambiente di sviluppo locale, puoi autenticarti in Compute Engine selezionando una delle seguenti opzioni:

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

    Console

    When you use the Trusted Cloud console to access Trusted Cloud by S3NS services and APIs, you don't need to set up authentication.

    gcloud

    1. After installing the Google Cloud CLI, sign in to the gcloud CLI with your federated identity and then initialize it by running the following command: 

      gcloud init
    2. Set a default region and zone.

      3. Vai

      Per utilizzare gli Go esempi in questa pagina in un ambiente di sviluppo locale, installa e inizializza l'interfaccia alla gcloud CLI, quindi configura le Credenziali predefinite dell'applicazione con le tue credenziali utente.

      1. Install the Google Cloud CLI.

      2. Configure the gcloud CLI to use your federated identity.

        For more information, see Sign in to the gcloud CLI with your federated identity.

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

        gcloud init

      4. Create local authentication credentials for your user account: 

        gcloud auth application-default login

        If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

        5. Per ulteriori informazioni, consulta Set up authentication for a local development environment.

      Java

      Per utilizzare gli Java esempi in questa pagina in un ambiente di sviluppo locale, installa e inizializza l'interfaccia alla gcloud CLI, quindi configura le Credenziali predefinite dell'applicazione con le tue credenziali utente.

      1. Install the Google Cloud CLI.

      2. Configure the gcloud CLI to use your federated identity.

        For more information, see Sign in to the gcloud CLI with your federated identity.

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

        gcloud init

      4. Create local authentication credentials for your user account: 

        gcloud auth application-default login

        If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

        5. Per ulteriori informazioni, consulta Set up authentication for a local development environment.

      Node.js

      Per utilizzare gli Node.js esempi in questa pagina in un ambiente di sviluppo locale, installa e inizializza l'interfaccia alla gcloud CLI, quindi configura le Credenziali predefinite dell'applicazione con le tue credenziali utente.

      1. Install the Google Cloud CLI.

      2. Configure the gcloud CLI to use your federated identity.

        For more information, see Sign in to the gcloud CLI with your federated identity.

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

        gcloud init

      4. Create local authentication credentials for your user account: 

        gcloud auth application-default login

        If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

        5. Per ulteriori informazioni, consulta Set up authentication for a local development environment.

      Python

      Per utilizzare gli Python esempi in questa pagina in un ambiente di sviluppo locale, installa e inizializza l'interfaccia alla gcloud CLI, quindi configura le Credenziali predefinite dell'applicazione con le tue credenziali utente.

      1. Install the Google Cloud CLI.

      2. Configure the gcloud CLI to use your federated identity.

        For more information, see Sign in to the gcloud CLI with your federated identity.

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

        gcloud init

      4. Create local authentication credentials for your user account: 

        gcloud auth application-default login

        If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

        5. Per ulteriori informazioni, consulta Set up authentication for a local development environment.

      REST

      Per utilizzare gli esempi dell'API REST in questa pagina in un ambiente di sviluppo locale, utilizza le credenziali fornite all'interfaccia alla gcloud CLI.

        After installing the Google Cloud CLI, sign in to the gcloud CLI with your federated identity and then initialize it by running the following command: 

        gcloud init

      Per ulteriori informazioni, consulta Eseguire l'autenticazione per l'utilizzo di REST nella Trusted Cloud documentazione sull'autenticazione.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per impedire a un'istanza Compute di utilizzare le prenotazioni, chiedi all'amministratore di concederti il ruolo IAM Amministratore istanze Compute (v1) (roles/compute.instanceAdmin.v1) nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per impedire a un'istanza di calcolo di utilizzare le prenotazioni. Per visualizzare le autorizzazioni esatte richieste, espandi la sezione Autorizzazioni richieste:

Autorizzazioni obbligatorie

Per impedire a un'istanza di calcolo di utilizzare le prenotazioni, sono necessarie le seguenti autorizzazioni:

  • Per creare le prenotazioni: compute.reservations.create nel progetto
  • Per creare istanze:
    • compute.instances.create sul progetto
    • Per utilizzare un'immagine personalizzata per creare la VM: compute.images.useReadOnly sull'immagine
    • Per utilizzare uno snapshot per creare la VM: compute.snapshots.useReadOnly nello snapshot
    • Per utilizzare un modello di istanza per creare la VM: compute.instanceTemplates.useReadOnly nel modello di istanza
    • Per assegnare una rete legacy alla VM: compute.networks.use nel progetto
    • Per specificare un indirizzo IP statico per la VM: compute.addresses.use nel progetto
    • Per assegnare un indirizzo IP esterno alla VM quando nel progetto viene utilizzata una rete precedente: compute.networks.useExternalIp
    • Per specificare una subnet per la VM: compute.subnetworks.use nel progetto o nella subnet scelta
    • Per assegnare un indirizzo IP esterno alla VM quando utilizzi una rete VPC: compute.subnetworks.useExternalIp nel progetto o nella subnet scelta
    • Per impostare i metadati dell'istanza VM per la VM: compute.instances.setMetadata nel progetto
    • Per impostare i tag per la VM: compute.instances.setTags sulla VM
    • Per impostare le etichette per la VM: compute.instances.setLabels sulla VM
    • Per impostare un account di servizio per l'utilizzo di: compute.instances.setServiceAccount sulla VM
    • Per creare un nuovo disco per la VM: compute.disks.create nel progetto
    • Per collegare un disco esistente in modalità di sola lettura o di lettura e scrittura: compute.disks.use sul disco
    • Per collegare un disco esistente in modalità di sola lettura: compute.disks.useReadOnly sul disco
  • Per creare modelli di istanze: compute.instanceTemplates.create sul progetto

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Evitare il consumo delle prenotazioni

Per impedire a un'istanza di calcolo di utilizzare le prenotazioni, imposta la proprietà affinità prenotazione (reservationAffinity) in modo che non le utilizzi. Questa proprietà controlla se un'istanza può utilizzare prenotazioni corrispondenti, una prenotazione specifica o nessuna prenotazione.

Per impedire a una o più istanze di utilizzare le prenotazioni, utilizza uno dei seguenti metodi:

Evitare il consumo in un'istanza esistente

Puoi aggiornare un'istanza in esecuzione in modo che non consumi più automaticamente le prenotazioni. Per applicare le modifiche, devi riavviare l'istanza, come descritto in questa sezione.

Per impedire a un'istanza esistente di utilizzare le prenotazioni, seleziona una delle seguenti opzioni:

gcloud

  1. Crea un file YAML vuoto.

  2. Per esportare le proprietà di un'istanza nel file YAML appena creato, utilizza il comando gcloud compute instances export:

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

    Sostituisci quanto segue:

    • INSTANCE_NAME: il nome dell'istanza.

    • YAML_FILE: il percorso del file YAML vuoto che hai creato nel passaggio precedente.

    • ZONE: la zona in cui esiste l'istanza.

  3. Nel file di configurazione YAML, imposta consumeReservationType su NO_RESERVATION:

    reservationAffinity:
  consumeReservationType: NO_RESERVATION

  4. Per aggiornare l'istanza e riavviarla, utilizza il comando gcloud compute instances update-from-file con il flag --most-disruptive-allowed-action impostato su RESTART:

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

    Sostituisci quanto segue:

    • INSTANCE_NAME: il nome dell'istanza.

    • YAML_FILE: il percorso del file YAML con i dati di configurazione modificati nel passaggio precedente.

    • ZONE: la zona in cui esiste l'istanza.

REST

  1. Per visualizzare le proprietà di un'istanza esistente, invia una richiesta GET al metodo instances.get:

    GET https://compute.s3nsapis.fr/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME

    Sostituisci quanto segue:

    • PROJECT_ID: l'ID del progetto in cui hai creato l'istanza.

    • ZONE: la zona in cui esiste l'istanza.

    • INSTANCE_NAME: il nome dell'istanza.

  2. Memorizza l'output della richiesta GET in un file o in un editor di testo. Modifica l'output copiato per cambiare il campo consumeReservationType in NO_RESERVATION:

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

  3. Per aggiornare l'istanza e riavviarla, effettua una richiesta PUT al metodo instances.update. Nella richiesta:

    • Nell'URL della richiesta, includi il parametro di query mostDisruptiveAllowedAction impostato su RESTART.

    • Per il corpo della richiesta, utilizza l'output della richiesta GET che hai modificato in un passaggio precedente.

    La richiesta è simile al seguente esempio:

    PUT https://compute.s3nsapis.fr/compute/v1/projects/example-project/zones/us-central-1/instances/instance-01?mostDisruptiveAllowedAction=RESTART

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

Per ulteriori informazioni sull'aggiornamento di un'istanza, consulta Aggiornare le proprietà delle istanze.

Impedire il consumo durante la creazione di un'istanza

Per creare un'istanza di calcolo che non può utilizzare le prenotazioni, seleziona una delle seguenti opzioni:

Console

  1. Nella console Trusted Cloud , vai alla pagina Crea un'istanza.

    Vai a Crea un'istanza

  2. Nel campo Nome, inserisci un nome per l'istanza.

  3. Negli elenchi Regione e Zona, seleziona la regione e la zona in cui creare l'istanza.

  4. Specifica il tipo di macchina da utilizzare per l'istanza.

  5. Nel menu di navigazione, fai clic su Avanzate.

  6. Nella sezione Prenotazioni, seleziona Non utilizzare una prenotazione.

  7. Fai clic su Crea.

gcloud

Per creare un'istanza che non può utilizzare le prenotazioni, utilizza il comando gcloud compute instances create con il flag --reservation-affinity impostato su none:

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

Sostituisci quanto segue:

  • INSTANCE_NAME: il nome dell'istanza.

  • MACHINE_TYPE: il tipo di macchina da utilizzare per l'istanza.

  • ZONE: la zona in cui creare l'istanza.

Vai

Per creare un'istanza che non può utilizzare le prenotazioni, utilizza il seguente esempio di codice:

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,
		Inst&anceResource: 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.Net&workInterface{
				{
					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

Per creare un'istanza che non può utilizzare le prenotazioni, utilizza il seguente esempio di codice:

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)
       <   .setInstanceResou>rce(instanceResource)
          .build();

      OperationFutureOperation, 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

Per creare un'istanza che non può utilizzare le prenotazioni, utilizza il seguente esempio di codice:

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

Per creare un'istanza che non può utilizzare le prenotazioni, utilizza il seguente esempio di codice:

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

Per creare un'istanza che non può utilizzare le prenotazioni, invia una richiesta POST al metodo instances.insert. Nel corpo della richiesta, includi il campo consumeReservationType impostato su NO_RESERVATION:

POST https://compute.s3nsapis.fr/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"
  }
}

Sostituisci quanto segue:

  • PROJECT_ID: l'ID del progetto in cui vuoi creare l'istanza.

  • ZONE: la zona in cui creare l'istanza.

  • INSTANCE_NAME: il nome dell'istanza.

  • MACHINE_TYPE: il tipo di macchina da utilizzare per l'istanza.

  • IMAGE_PROJECT: il progetto immagine che contiene l'immagine del sistema operativo, ad esempio debian-cloud. Per saperne di più sui progetti di immagini supportati, consulta Immagini pubbliche.

  • IMAGE: specifica una delle seguenti opzioni:

    • Una versione specifica dell'immagine del sistema operativo, ad esempio debian-12-bookworm-v20240617.

    • Una famiglia di immagini, che deve essere formattata come family/IMAGE_FAMILY. Questo specifica l'immagine del sistema operativo più recente e non ritirata. Ad esempio, se specifichi family/debian-12, viene utilizzata la versione più recente della famiglia di immagini Debian 12. Per saperne di più sull'utilizzo delle famiglie di immagini, consulta le best practice per le famiglie di immagini.

Per ulteriori informazioni sulla creazione di un'istanza, consulta Creare e avviare un'istanza Compute Engine.

Evitare il consumo durante la creazione di un modello di istanza

Dopo aver creato un modello di istanza che configura le istanze in modo che non consumino prenotazioni, puoi utilizzarlo per:

Per creare un modello di istanza che configuri le istanze in modo che non consumino prenotazioni, seleziona una delle seguenti opzioni:

Console

  1. Nella console Trusted Cloud , vai alla pagina Crea un modello di istanza.

    Vai a Crea un modello di istanza

  2. Nel campo Nome, inserisci un nome per il modello di istanza.

  3. Nella sezione Località, specifica se vuoi creare un modello di istanze regionale (predefinito) o globale.

  4. Nella sezione Configurazione macchina, specifica il tipo di macchina da utilizzare per le istanze create utilizzando il modello.

  5. Espandi la sezione Opzioni avanzate e segui questi passaggi:

    1. Espandi la sezione Gestione.

    2. Nella sezione Prenotazioni, seleziona Non utilizzare una prenotazione.

  6. Fai clic su Crea.

gcloud

Per creare un modello di istanza che configuri le istanze in modo che non consumino prenotazioni, utilizza il comando gcloud compute instances-templates create con il flag --reservation-affinity impostato su none.

Per creare un modello di istanza regionale che configuri le istanze in modo che non consumino prenotazioni, esegui il seguente comando. Se vuoi creare un modello di istanza globale, utilizza lo stesso comando senza il flag --instance-template-region.

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

Sostituisci quanto segue:

  • INSTANCE_TEMPLATE_NAME: il nome del modello di istanza.

  • REGION: la regione in cui creare il modello di istanza.

  • MACHINE_TYPE: il tipo di macchina da utilizzare per le istanze create utilizzando il modello di istanza.

Vai

Per creare un modello di istanza che configuri le istanze in modo che non consumino prenotazioni, utilizza il seguente esempio di codice:

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("NewI&nstanceTemplatesRESTClient: %w", err)
	}
	defer instanceTemplatesClient.Close()

	req &:= computepb.InsertInstanceTemplateRequest{
		Project: projectID,
		InstanceTemp&lateResource: 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&quot;),
								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

Per creare un modello di istanza che configuri le istanze in modo che non consumino prenotazioni, utilizza il seguente esempio di codice:

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(&quot;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

Per creare un modello di istanza che configuri le istanze in modo che non consumino prenotazioni, utilizza il seguente esempio di codice:

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

Per creare un modello di istanza che configuri le istanze in modo che non consumino prenotazioni, utilizza il seguente esempio di codice:

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(
    proje>ct_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

Per creare un modello di istanza che configuri le istanze in modo che non consumino prenotazioni, effettua una richiesta POST con uno dei seguenti metodi:

Nel corpo della richiesta, includi il campo consumeReservationType e impostalo su NO_RESERVATION.

Ad esempio, per creare un modello di istanza regionale e specificare di non consumare le prenotazioni, effettua una richiesta come segue:

POST https://compute.s3nsapis.fr/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"
    }
  }
}

Sostituisci quanto segue:

  • PROJECT_ID: l'ID del progetto in cui creare il modello di istanza.

  • INSTANCE_TEMPLATE_NAME: il nome del modello di istanza.

  • MACHINE_TYPE: il tipo di macchina da utilizzare per le istanze create utilizzando il modello di istanza.

  • IMAGE_PROJECT: il progetto immagine che contiene l'immagine del sistema operativo, ad esempio debian-cloud. Per saperne di più sui progetti di immagini supportati, consulta Immagini pubbliche.

  • IMAGE: specifica una delle seguenti opzioni:

    • Una versione specifica dell'immagine del sistema operativo, ad esempio debian-12-bookworm-v20240617.

    • Una famiglia di immagini, che deve essere formattata come family/IMAGE_FAMILY. Questo specifica l'immagine del sistema operativo più recente e non ritirata. Ad esempio, se specifichi family/debian-12, viene utilizzata la versione più recente della famiglia di immagini Debian 12. Per saperne di più sull'utilizzo delle famiglie di immagini, consulta le best practice per le famiglie di immagini.

Per saperne di più sulla creazione di modelli di istanze, consulta Creare modelli di istanze.

Passaggi successivi