Crea una prenotazione condivisa

Questo documento spiega come creare prenotazioni condivise, ovvero prenotazioni condivise tra più progetti, e gestire i progetti della tua organizzazione che possono utilizzare le prenotazioni condivise.

Una prenotazione condivisa può essere utilizzata dal progetto che la ospita (progetto proprietario) e dai progetti con cui è condivisa (progetti consumer). Utilizza le prenotazioni condivise se la tua organizzazione ha più progetti che richiedono istanze di macchine virtuali (VM) con le stesse proprietà prenotate. Con le prenotazioni condivise puoi migliorare l'utilizzo delle tue prenotazioni e ridurre il numero di prenotazioni da creare e gestire. Per saperne di più sulle prenotazioni, consulta Prenotazioni di risorse di zona di Compute Engine.

Per altri metodi di creazione delle prenotazioni, consulta invece le seguenti pagine:

Per creare una prenotazione che può essere utilizzata solo da un singolo progetto, consulta Crea una prenotazione per un singolo progetto.
Per creare una prenotazione al momento dell'acquisto di un impegno basato sulle risorse, consulta Acquista impegni con prenotazioni collegate. Gli impegni offrono sconti, noti come sconti per impegno di utilizzo (CUD), sui costi delle risorse on demand in cambio dell'acquisto di un livello minimo di risorse o della spesa di un importo minimo.

Prima di iniziare

Consulta le best practice per le prenotazioni condivise.
Esamina i requisiti relativi alle quote e le limitazioni per le prenotazioni condivise.
Verifica che il progetto che utilizzi per creare prenotazioni condivise sia stato aggiunto alla lista consentita per il vincolo della policy dell'organizzazione Progetti proprietari di prenotazioni condivise (compute.sharedReservationsOwnerProjects) da un amministratore delle policy dell'organizzazione. Questa lista consentita è vuota per impostazione predefinita, pertanto non puoi creare prenotazioni condivise finché la tua organizzazione non concede questa autorizzazione a uno o più progetti. Per maggiori dettagli sulla visualizzazione e sulla modifica del vincolo delle policy dell'organizzazione, consulta Gestisci la creazione di prenotazioni condivise.
Se non l'hai ancora fatto, configura l'autenticazione. L'autenticazione verifica la tua identità per l'accesso ad API e servizi Google Cloud . Per eseguire codice o esempi da un ambiente di sviluppo locale, puoi autenticarti su 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 Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.
gcloud
1. Installa Google Cloud CLI. Dopo l'installazione, inizializza Google Cloud CLI eseguendo il comando seguente:
  gcloud init
  Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.
  
  Nota: se hai installato gcloud CLI in precedenza, assicurati di avere l'ultima versione eseguendo gcloud components update.
2. Set a default region and zone.
Terraform

Per utilizzare gli esempi di Terraform in questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.
Per saperne di più, consulta Set up authentication for a local development environment.
Go

Per utilizzare gli esempi di Go in questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.
Per saperne di più, consulta Set up authentication for a local development environment.
Java

Per utilizzare gli esempi di Java in questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.
Per saperne di più, consulta Set up authentication for a local development environment.
Node.js

Per utilizzare gli esempi di Node.js in questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.
Per saperne di più, consulta Set up authentication for a local development environment.
Python

Per utilizzare gli esempi di Python in questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.
Per saperne di più, consulta Set up authentication for a local development environment.
REST

Per utilizzare gli esempi di API REST in questa pagina in un ambiente di sviluppo locale, utilizzi le credenziali che fornisci a gcloud CLI.
Per saperne di più, consulta Autenticati per usare REST nella documentazione sull'autenticazione di Google Cloud .

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per creare prenotazioni condivise, chiedi all'amministratore di concederti i seguenti ruoli IAM:

Compute Admin (roles/compute.admin) sul progetto
Per visualizzare e modificare le policy dell'organizzazione: Organization Policy Administrator (roles/orgpolicy.policyAdmin) sull'organizzazione

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questi ruoli predefiniti contengono le autorizzazioni necessarie per creare prenotazioni condivise. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per creare prenotazioni condivise sono necessarie le seguenti autorizzazioni:

compute.reservations.create sul progetto
Per visualizzare le policy dell'organizzazione: orgpolicy.policy.get sull'organizzazione
Per modificare le policy dell'organizzazione: orgpolicy.policy.set sull'organizzazione
Per specificare un modello di istanza: compute.instanceTemplates.useReadOnly sul modello di istanza

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

Crea una prenotazione condivisa

Questa sezione spiega come creare prenotazioni condivise. Una prenotazione condivisa può essere modificata solo dal progetto proprietario, ma le risorse di una prenotazione condivisa possono essere utilizzate dal progetto proprietario o da qualsiasi progetto consumer.

Per utilizzare una prenotazione, una VM deve avere proprietà che corrispondono esattamente alla prenotazione. Per specificare le proprietà delle VM che vuoi prenotare, seleziona una delle seguenti sezioni di questo documento:

Suggerimento: Specifica un modello di istanza

Questa sezione spiega come utilizzare un modello di istanza per definire le proprietà di una prenotazione condivisa. Utilizzando un modello di istanza puoi definire in un unico posto le proprietà di una prenotazione e le VM che possono utilizzarla. Tuttavia, poiché i modelli sono specifici del progetto, non puoi usare lo stesso modello per creare VM che possono utilizzare la prenotazione al di fuori del progetto che ha creato la prenotazione. Devi creare modelli simili nei progetti con cui la prenotazione è condivisa o creare VM specificando direttamente le proprietà.
Specifica una VM esistente

Questa sezione spiega come utilizzare una VM esistente per definire le proprietà di una prenotazione. Usando le proprietà di una VM esistente puoi utilizzare la prenotazione creando VM con proprietà corrispondenti a quelle della VM di riferimento.
Specifica le proprietà direttamente

Questa sezione spiega come definire direttamente le proprietà di una prenotazione condivisa. Questo metodo richiede di assicurarti manualmente che le proprietà delle VM e delle prenotazioni corrispondano esattamente: eventuali proprietà non corrispondenti impediscono l'utilizzo.

Per impostazione predefinita, una prenotazione può essere utilizzata automaticamente da qualsiasi VM con proprietà corrispondenti. Se vuoi controllare l'utilizzo delle prenotazioni, esegui una o più delle seguenti operazioni:

Crea una prenotazione che può essere utilizzata solo dalle VM di cui è un target specifico, come spiegato nelle sezioni successive di questo documento. Quindi configura le VM in modo che utilizzino la prenotazione specifica.
Configura le VM in modo che non utilizzino prenotazioni.

Specifica un modello di istanza

Prima di creare una prenotazione specificando un modello di istanza, assicurati di quanto segue:

Un modello di istanza contiene impostazioni specifiche del progetto, pertanto puoi accedere e utilizzare un modello di istanza solo all'interno dello stesso progetto. Se crei una prenotazione condivisa specificando un modello di istanza, non puoi utilizzare lo stesso modello per creare VM che possono utilizzare la prenotazione al di fuori del progetto che ha creato la prenotazione.
Crea la prenotazione nella stessa regione e nella stessa zona delle risorse all'interno del modello di istanza. Qualsiasi risorsa regionale o di zona specificata in un template di istanza, ad esempio un tipo di macchina o un volume Persistent Disk, limita l'utilizzo del template alle posizioni in cui esistono queste risorse. Ad esempio, se il template di istanza specifica un volume Persistent Disk esistente nella zona us-central1-a, puoi creare la prenotazione solo nella stessa zona. Per verificare se un modello esistente specifica risorse che lo legano a una determinata regione o zona, visualizza i dettagli relativi al modello di istanza e cerca al suo interno riferimenti a quelle risorse.

Per creare una prenotazione condivisa specificando un modello di istanza, seleziona una delle seguenti opzioni:

Console

Nella console Google Cloud , vai alla pagina Prenotazioni.

Vai a Prenotazioni
Fai clic su Crea prenotazione. Viene visualizzata la pagina Crea una prenotazione.
Nel campo Nome, inserisci un nome per la prenotazione.
Negli elenchi Regione e Zona, seleziona dove vuoi prenotare le risorse.
Nella sezione Tipo di condivisione, segui questi passaggi:
1. Per condividere una prenotazione con altri progetti, seleziona Condivisa.
2. Fai clic su Aggiungi progetti, quindi seleziona i progetti dell'organizzazione del progetto corrente con cui vuoi condividere la prenotazione. Puoi selezionare fino a 100 progetti consumer.
(Facoltativo) Per consentire job di addestramento personalizzato o job di previsione in Vertex AI di utilizzare una prenotazione di VM GPU, nella sezione Servizi Google Cloud, seleziona Condividi prenotazione.
Nella sezione Utilizza con un'istanza VM, seleziona una delle seguenti opzioni:
- Per consentire alle VM corrispondenti di utilizzare automaticamente questa prenotazione, seleziona Utilizza automaticamente la prenotazione.
- Per utilizzare le risorse di questa prenotazione solo quando crei VM corrispondenti che hanno come target specifico la prenotazione in base al nome, seleziona Seleziona una prenotazione specifica.
Nella sezione Dettagli risorsa:
- Nel campo Numero di istanze VM, inserisci il numero di VM che vuoi prenotare.
- Per specificare le configurazioni delle VM utilizzando un modello di istanza, seleziona Utilizza modello di istanza, quindi seleziona il modello di istanza nell'elenco visualizzato.
Nella sezione Eliminazione automatica, puoi attivare l'opzione di eliminazione automatica per consentire a Compute Engine di eliminare automaticamente la prenotazione in una data e ora specifica. L'eliminazione automatica delle prenotazioni può essere utile per evitare addebiti non necessari quando smetti di utilizzare la prenotazione.
Per creare la prenotazione, fai clic su Crea. Viene visualizzata la pagina Prenotazioni. La creazione della prenotazione può richiedere fino a un minuto. Per verificare quando Compute Engine termina la creazione, visualizza le prenotazioni.

gcloud

Per creare una prenotazione condivisa, utilizza il comando gcloud compute reservations create con i flag --share-setting=projects e --share-with.

Per creare una prenotazione condivisa specificando un modello di istanza e senza includere flag facoltativi, esegui questo comando:

gcloud compute reservations create RESERVATION_NAME \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --source-instance-template=INSTANCE_TEMPLATE_URL \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

Sostituisci quanto segue:

RESERVATION_NAME: il nome della prenotazione da creare.
PROJECT_ID: l'ID del progetto in cui vuoi prenotare le risorse e in cui esiste il modello di istanza.
CONSUMER_PROJECT_IDS: un elenco separato da virgole di ID dei progetti che possono utilizzare questa prenotazione, ad esempio project-1,project-2. Puoi includere fino a 100 progetti consumer. Questi progetti devono appartenere alla stessa organizzazione del progetto proprietario. Non includere il progetto proprietario. Per impostazione predefinita, è già autorizzato a utilizzare la prenotazione.
INSTANCE_TEMPLATE_URL: l'URL di un template di istanza esistente, che deve esistere nel tuo progetto. Specifica uno dei seguenti valori:
- Per un template di istanza regionale: projects/PROJECT_ID/regions/REGION/instanceTemplates/INSTANCE_TEMPLATE_NAME
- Per un template di istanza globale: INSTANCE_TEMPLATE_NAME
NUMBER_OF_VMS: il numero di VM da prenotare.
ZONE: la zona in cui prenotare le risorse.

Ad esempio, per creare una prenotazione specificando un modello di istanza globale nella zona us-central1-a, condividere la prenotazione con i progetti project-1 e project-2 e prenotare dieci VM che utilizzano ciascuna un tipo di macchina predefinita N2 con 4 vCPU, esegui questo comando:

gcloud compute reservations create my-reservation \
    --share-setting=projects \
    --share-with=project-1,project-2 \
    --source-instance-template=projects/example-project/global/example-instance-template \
    --vm-count=10 \
    --zone=us-central1-a

Facoltativamente, puoi eseguire una o più delle seguenti operazioni:

Per specificare che solo le VM che hanno come target specifico questa prenotazione possono utilizzarla, includi il flag --require-specific-reservation.

gcloud compute reservations create RESERVATION_NAME \
    --require-specific-reservation \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --source-instance-template=INSTANCE_TEMPLATE_URL \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

Per consentire ai job di addestramento personalizzato o ai job di previsione in Vertex AI di utilizzare una prenotazione di VM GPU, includi il flag --reservation-sharing-policy impostato su ALLOW_ALL.

gcloud compute reservations create RESERVATION_NAME \
    --reservation-sharing-policy=ALLOW_ALL \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --source-instance-template=INSTANCE_TEMPLATE_URL \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

Per consentire a Compute Engine di eliminare automaticamente la prenotazione, seleziona uno dei seguenti metodi:

Anteprima — The --delete-at-time and --delete-after-duration flags

Questa funzionalità è soggetta ai "Termini delle Offerte pre-GA" nella sezione Termini di servizio generali dei Termini di servizio specifici. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per ulteriori informazioni, consulta le descrizioni delle fasi di lancio.
- Per eliminare la prenotazione in una data e ora specifica, utilizza il comando gcloud beta compute reservations create con il flag --delete-at-time.
```
gcloud beta compute reservations create RESERVATION_NAME \
    --delete-at-time=DELETE_AT_TIME \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --source-instance-template=INSTANCE_TEMPLATE_URL \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
  Sostituisci DELETE_AT_TIME con una data e ora formattata come timestamp RFC 3339, ovvero come segue:
```
YYYY-MM-DDTHH:MM:SSOFFSET
```
  Sostituisci quanto segue:
  - YYYY-MM-DD: una data formattata come anno a 4 cifre, mese a 2 cifre e giorno del mese a 2 cifre, separati da trattini (-).
  - HH:MM:SS: un orario formattato con l'ora a due cifre utilizzando il sistema a 24 ore, i minuti a due cifre e i secondi a due cifre, separati da due punti (:).
  - OFFSET: il fuso orario formattato come offset rispetto al Tempo Universale Coordinato (UTC). Ad esempio, per utilizzare il fuso orario standard della costa del Pacifico (PST), specifica -08:00. In alternativa, per non utilizzare alcun offset, specifica Z.
- Per eliminare la prenotazione dopo un periodo di tempo specifico, utilizza il comando gcloud beta compute reservations create con il flag --delete-after-duration.
```
gcloud beta compute reservations create RESERVATION_NAME \
    --delete-after-duration=DELETE_AFTER_DURATION \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --source-instance-template=INSTANCE_TEMPLATE_URL \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
  Sostituisci DELETE_AFTER_DURATION con una durata in giorni, ore, minuti o secondi. Ad esempio, specifica 30m per 30 minuti o 1d2h3m4s per 1 giorno, 2 ore, 3 minuti e 4 secondi.

Go

import (
	"context"
	"fmt"
	"io"

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

// Creates shared reservation from given template in particular zone
func createSharedReservation(w io.Writer, client ClientInterface, projectID, baseProjectId, zone, reservationName, sourceTemplate string) error {
	// client, err := compute.NewReservationsRESTClient(ctx)
	// projectID := "your_project_id". Destination of sharing.
	// baseProjectId := "your_project_id2". Project where the reservation will be created.
	// zone := "us-west3-a"
	// reservationName := "your_reservation_name"
	// sourceTemplate: existing template path. Following formats are allowed:
	//  	- projects/{project_id}/global/instanceTemplates/{template_name}
	//  	- projects/{project_id}/regions/{region}/instanceTemplates/{template_name}
	//  	- https://www.googleapis.com/compute/v1/projects/{project_id}/global/instanceTemplates/instanceTemplate
	//  	- https://www.googleapis.com/compute/v1/projects/{project_id}/regions/{region}/instanceTemplates/instanceTemplate

	ctx := context.Background()

	shareSettings := map[string]*computepb.ShareSettingsProjectConfig{
		projectID: {ProjectId: proto.String(projectID)},
	}

	req := &computepb.InsertReservationRequest{
		Project: baseProjectId,
		ReservationResource: &computepb.Reservation{
			Name: proto.String(reservationName),
			Zone: proto.String(zone),
			SpecificReservation: &computepb.AllocationSpecificSKUReservation{
				Count:                  proto.Int64(2),
				SourceInstanceTemplate: proto.String(sourceTemplate),
			},
			ShareSettings: &computepb.ShareSettings{
				ProjectMap: shareSettings,
				ShareType:  proto.String("SPECIFIC_PROJECTS"),
			},
		},
		Zone: zone,
	}

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

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

	fmt.Fprintf(w, "Reservation created\n")

	return nil
}

Java

import com.google.cloud.compute.v1.AllocationSpecificSKUReservation;
import com.google.cloud.compute.v1.InsertReservationRequest;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.Reservation;
import com.google.cloud.compute.v1.ReservationsClient;
import com.google.cloud.compute.v1.ShareSettings;
import com.google.cloud.compute.v1.ShareSettingsProjectConfig;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateSharedReservation {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // The ID of the project where you want to reserve resources
    // and where the instance template exists.
    // By default, no projects are allowed to create or modify shared reservations
    // in an organization. Add projects to the Shared Reservations Owner Projects
    // (compute.sharedReservationsOwnerProjects) organization policy constraint
    // to allow them to create and modify shared reservations.
    // For more information visit this page:
    // https://cloud.google.com/compute/docs/instances/reservations-shared#shared_reservation_constraint
    String projectId = "YOUR_PROJECT_ID";
    // Zone in which to reserve resources.
    String zone = "us-central1-a";
    // Name of the reservation to be created.
    String reservationName = "YOUR_RESERVATION_NAME";
    // The URI of the global instance template to be used for creating the reservation.
    String instanceTemplateUri = String.format(
        "projects/%s/global/instanceTemplates/%s", projectId, "YOUR_INSTANCE_TEMPLATE_NAME");
    // Number of instances for which capacity needs to be reserved.
    int vmCount = 3;

    createSharedReservation(projectId, zone, reservationName, instanceTemplateUri, vmCount);
  }

  // Creates a shared reservation with the given name in the given zone.
  public static Status createSharedReservation(
          String projectId, String zone,
          String reservationName, String instanceTemplateUri, int vmCount)
          throws ExecutionException, InterruptedException, TimeoutException, IOException {

    // 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 (ReservationsClient reservationsClient = ReservationsClient.create()) {
      ShareSettings shareSettings = ShareSettings.newBuilder()
              .setShareType(String.valueOf(ShareSettings.ShareType.SPECIFIC_PROJECTS))
              // The IDs of projects that can consume this reservation. You can include up to
              // 100 consumer projects. These projects must be in the same organization as
              // the owner project. Don't include the owner project.
              // By default, it is already allowed to consume the reservation.
              .putProjectMap("CONSUMER_PROJECT_1", ShareSettingsProjectConfig.newBuilder().build())
              .putProjectMap("CONSUMER_PROJECT_2", ShareSettingsProjectConfig.newBuilder().build())
              .build();

      Reservation reservationResource =
              Reservation.newBuilder()
                      .setName(reservationName)
                      .setZone(zone)
                      .setSpecificReservationRequired(true)
                      .setShareSettings(shareSettings)
                      .setSpecificReservation(
                              AllocationSpecificSKUReservation.newBuilder()
                                      .setCount(vmCount)
                                      .setSourceInstanceTemplate(instanceTemplateUri)
                                      .build())
                      .build();

      InsertReservationRequest request =
              InsertReservationRequest.newBuilder()
                      .setProject(projectId)
                      .setZone(zone)
                      .setReservationResource(reservationResource)
                      .build();

      Operation response = reservationsClient.insertAsync(request)
              .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        throw new Error("Reservation creation failed!!" + response);
      }
      return response.getStatus();
    }
  }
}

Node.js

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

/**
 * TODO(developer): Uncomment reservationsClient and zoneOperationsClient before running the sample.
 */
// Instantiate a reservationsClient
// reservationsClient = new computeLib.ReservationsClient();
// Instantiate a zoneOperationsClient
// zoneOperationsClient = new computeLib.ZoneOperationsClient();

/**
 * TODO(developer): Update these variables before running the sample.
 */
// The ID of the project where you want to reserve resources and where the instance template exists.
const projectId = await reservationsClient.getProjectId();
// The zone in which to reserve resources.
const zone = 'us-central1-a';
// The name of the reservation to create.
const reservationName = 'reservation-01';
// The number of VMs to reserve.
const vmsNumber = 3;
// The name of an existing instance template.
const instanceTemplateName = 'global-instance-template-name';
// The location of the instance template.
const location = 'global';

async function callCreateComputeSharedReservation() {
  // Create reservation for 3 VMs in zone us-central1-a by specifying a instance template.
  const specificReservation = new compute.AllocationSpecificSKUReservation({
    count: vmsNumber,
    sourceInstanceTemplate: `projects/${projectId}/${location}/instanceTemplates/${instanceTemplateName}`,
  });

  // Create share settings. Share reservation with one customer project.
  const shareSettings = new compute.ShareSettings({
    shareType: 'SPECIFIC_PROJECTS',
    projectMap: {
      // The IDs of projects that can consume this reservation. You can include up to 100 consumer projects.
      // These projects must be in the same organization as the owner project.
      // Don't include the owner project. By default, it is already allowed to consume the reservation.
      consumer_project_id: {
        projectId: 'consumer_project_id',
      },
    },
  });

  // Create a reservation.
  const reservation = new compute.Reservation({
    name: reservationName,
    specificReservation,
    specificReservationRequired: true,
    shareSettings,
  });

  const [response] = await reservationsClient.insert({
    project: projectId,
    reservationResource: reservation,
    zone,
  });

  let operation = response.latestResponse;

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

  console.log(`Reservation: ${reservationName} created.`);
  return response;
}

return await callCreateComputeSharedReservation();

Python

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


def create_compute_shared_reservation(
    project_id: str,
    zone: str = "us-central1-a",
    reservation_name="your-reservation-name",
    shared_project_id: str = "shared-project-id",
) -> compute_v1.Reservation:
    """Creates a compute reservation in GCP.
    Args:
        project_id (str): The ID of the Google Cloud project.
        zone (str): The zone to create the reservation.
        reservation_name (str): The name of the reservation to create.
        shared_project_id (str): The ID of the project that the reservation is shared with.
    Returns:
        Reservation object that represents the new reservation.
    """

    instance_properties = compute_v1.AllocationSpecificSKUAllocationReservedInstanceProperties(
        machine_type="n1-standard-1",
        # Optional. Specifies amount of local ssd to reserve with each instance.
        local_ssds=[
            compute_v1.AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk(
                disk_size_gb=375, interface="NVME"
            ),
        ],
    )

    reservation = compute_v1.Reservation(
        name=reservation_name,
        specific_reservation=compute_v1.AllocationSpecificSKUReservation(
            count=3,  # Number of resources that are allocated.
            # If you use source_instance_template, you must exclude the instance_properties field.
            # It can be a full or partial URL.
            # source_instance_template="projects/[PROJECT_ID]/global/instanceTemplates/my-instance-template",
            instance_properties=instance_properties,
        ),
        share_settings=compute_v1.ShareSettings(
            share_type="SPECIFIC_PROJECTS",
            project_map={
                shared_project_id: compute_v1.ShareSettingsProjectConfig(
                    project_id=shared_project_id
                )
            },
        ),
    )

    # Create a client
    client = compute_v1.ReservationsClient()

    operation = client.insert(
        project=project_id,
        zone=zone,
        reservation_resource=reservation,
    )
    wait_for_extended_operation(operation, "Reservation creation")

    reservation = client.get(
        project=project_id, zone=zone, reservation=reservation_name
    )
    shared_project = next(iter(reservation.share_settings.project_map.values()))

    print("Name: ", reservation.name)
    print("STATUS: ", reservation.status)
    print("SHARED PROJECT: ", shared_project)
    # Example response:
    # Name:  your-reservation-name
    # STATUS:  READY
    # SHARED PROJECT:  project_id: "123456789012"

    return reservation

REST

Per creare una prenotazione condivisa, invia una richiesta POST al metodo reservations.insert. Nel corpo della richiesta, includi quanto segue:

Il campo projectMap.
Il campo shareType impostato su SPECIFIC_PROJECTS.

Ad esempio, per creare una prenotazione condivisa specificando un modello di istanza senza includere campi facoltativi e condividerla con due progetti consumer, invia la seguente richiesta POST:

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

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "INSTANCE_TEMPLATE_URL"
  }
}

Sostituisci quanto segue:

PROJECT_ID: l'ID del progetto in cui vuoi prenotare le risorse e in cui esiste il template di istanza.
ZONE: la zona in cui prenotare le risorse.
RESERVATION_NAME: il nome della prenotazione da creare.
CONSUMER_PROJECT_ID_1 e CONSUMER_PROJECT_ID_2: gli ID dei progetti che possono utilizzare questa prenotazione. Puoi includere fino a 100 progetti consumer. Questi progetti devono appartenere alla stessa organizzazione del progetto proprietario. Non includere il progetto proprietario. Per impostazione predefinita, è già autorizzato a utilizzare la prenotazione.
NUMBER_OF_VMS: il numero di VM da prenotare.
INSTANCE_TEMPLATE_URL: l'URL di un template di istanza esistente, che deve esistere nel tuo progetto. Specifica uno dei seguenti valori:
- Per un template di istanza regionale: projects/PROJECT_ID/regions/REGION/instanceTemplates/INSTANCE_TEMPLATE_NAME
- Per un template di istanza globale: INSTANCE_TEMPLATE_NAME

Ad esempio, per creare una prenotazione per dieci VM nella zona us-central1-a specificando un modello di istanze globale e condividerla con i progetti project-1 e project-2, invia la seguente richiesta POST:

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

{
  "name": "my-reservation",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "project-1": {
        "projectId": "project-1"
      },
      "project-2": {
        "projectId": "project-2"
      }
    }
  },
  "specificReservation": {
    "count": "10",
    "sourceInstanceTemplate": "example-instance-template"
  }
}

Facoltativamente, puoi eseguire una o più delle seguenti operazioni:

Per specificare che solo le VM che hanno come target specifico questa prenotazione possono utilizzarla, includi il campo specificReservationRequired nel corpo della richiesta e impostalo su true.

Ad esempio, per creare una prenotazione specifica indicando un modello di istanza e condividerla con due progetti consumer, invia la seguente richiesta:

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

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "INSTANCE_TEMPLATE_URL"
  },
  "specificReservationRequired": true
}

Per consentire ai job di addestramento personalizzato o ai job di previsione in Vertex AI di utilizzare una prenotazione di VM GPU, includi il campo serviceShareType e impostalo su ALLOW_ALL.

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

{
  "name": "RESERVATION_NAME",
  "reservationSharingPolicy": {
    "serviceShareType": "ALLOW_ALL"
  },
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "INSTANCE_TEMPLATE_URL"
  }
}

Per consentire a Compute Engine di eliminare automaticamente la prenotazione, seleziona uno dei seguenti metodi:

Anteprima — The deleteAtTime and deleteAfterDuration fields

Questa funzionalità è soggetta ai "Termini delle Offerte pre-GA" nella sezione Termini di servizio generali dei Termini di servizio specifici. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per ulteriori informazioni, consulta le descrizioni delle fasi di lancio.
- Per eliminare la prenotazione in una data e ora specifica, effettua una richiesta POST al metodo beta.reservations.insert. Nel corpo della richiesta, includi il campo deleteAtTime.
  
  Ad esempio, per creare una prenotazione specificando un modello di istanza, eliminare automaticamente la prenotazione a una data e ora specifica e condividerla con due progetti consumer, invia la seguente richiesta:
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAtTime": "DELETE_AT_TIME",
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "INSTANCE_TEMPLATE_URL"
  }
}
```
  Sostituisci DELETE_AT_TIME con una data e ora formattata come timestamp RFC 3339, ovvero come segue:
```
YYYY-MM-DDTHH:MM:SSOFFSET
```
  Sostituisci quanto segue:
  - YYYY-MM-DD: una data formattata come anno a 4 cifre, mese a 2 cifre e giorno del mese a 2 cifre, separati da trattini (-).
  - HH:MM:SS: un orario formattato con l'ora a due cifre utilizzando il sistema a 24 ore, i minuti a due cifre e i secondi a due cifre, separati da due punti (:).
  - OFFSET: il fuso orario formattato come offset rispetto al Tempo Universale Coordinato (UTC). Ad esempio, per utilizzare il fuso orario standard della costa del Pacifico (PST), specifica -08:00. In alternativa, per non utilizzare alcun offset, specifica Z.
- Per eliminare la prenotazione dopo un periodo di tempo specifico, effettua una richiesta POST al metodo beta.reservations.insert. Nel corpo della richiesta, includi il campo deleteAfterDuration.
  
  Ad esempio, per creare una prenotazione specificando un modello di istanza, eliminare la prenotazione dopo un periodo di tempo specifico e condividerla con due progetti consumer, invia la seguente richiesta:
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAfterDuration": {
    "seconds": "DELETE_AFTER_DURATION"
  },
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "INSTANCE_TEMPLATE_URL"
  }
}
```
  Sostituisci DELETE_AFTER_DURATION con una durata in secondi. Ad esempio, specifica 86400 per 86.400 secondi (1 giorno).

Specifica una VM esistente

Puoi creare una prenotazione condivisa in base a una VM esistente solo nello stesso progetto e nella stessa zona della VM.

Dopo aver creato la prenotazione, puoi utilizzarla creando VM con proprietà corrispondenti a quelle della VM di riferimento. Puoi farlo eseguendo una di queste operazioni:

Crea e utilizza un template di istanza come segue:
1. Crea un template di istanza basato sulla VM di riferimento senza sostituire le sue proprietà.
  
  Nota: non puoi creare un template di istanza basato sulla VM di riferimento al di fuori del progetto della VM. Nei progetti con cui è stata condivisa la prenotazione devi creare modelli di istanze simili.
2. Crea le VM utilizzando il template appena creato effettuando una o entrambe le operazioni riportate di seguito:
  - Crea una singola VM
  - Crea un gruppo di istanze gestite (MIG) a livello di zona
Crea una VM con proprietà che corrispondono esattamente alla VM di riferimento come segue:
- Nel progetto proprietario, crea una VM basata sulla VM di riferimento senza modificare le proprietà della VM che stai creando.
- Nei progetti consumer, crea una VM assicurandoti manualmente che le sue proprietà corrispondano a quelle della VM di riferimento.

Per creare una prenotazione condivisa che utilizza le proprietà di una VM esistente, segui questi passaggi:

Nella console Google Cloud , vai alla pagina Prenotazioni.

Vai a Prenotazioni
Fai clic su Crea prenotazione. Viene visualizzata la pagina Crea una prenotazione.
Nel campo Nome, inserisci un nome per la prenotazione.
Negli elenchi Regione e Zona, seleziona dove vuoi prenotare le risorse.
Nella sezione Tipo di condivisione, segui questi passaggi:
1. Per condividere una prenotazione con altri progetti, seleziona Condivisa.
2. Fai clic su Aggiungi progetti, quindi seleziona i progetti dell'organizzazione del progetto corrente con cui vuoi condividere la prenotazione. Puoi selezionare fino a 100 progetti consumer.
(Facoltativo) Per consentire job di addestramento personalizzato o job di previsione in Vertex AI di utilizzare una prenotazione di VM GPU, nella sezione Servizi Google Cloud, seleziona Condividi prenotazione.
Nella sezione Utilizza con un'istanza VM, seleziona una delle seguenti opzioni:
- Per consentire alle VM corrispondenti di utilizzare automaticamente questa prenotazione, seleziona Usa automaticamente la prenotazione.
- Per utilizzare le risorse di questa prenotazione solo quando crei VM corrispondenti che hanno come target specifico la prenotazione in base al nome, seleziona Seleziona una prenotazione specifica.
Nella sezione Dettagli risorsa:
- Nel campo Numero di istanze VM, inserisci il numero di VM che vuoi prenotare.
- Per specificare le configurazioni delle VM utilizzando una VM di riferimento, seleziona Usa VM esistente e poi seleziona la VM nell'elenco visualizzato.
Nella sezione Eliminazione automatica, puoi attivare l'opzione di eliminazione automatica per consentire a Compute Engine di eliminare automaticamente la prenotazione in una data e ora specifica. L'eliminazione automatica delle prenotazioni può essere utile per evitare addebiti non necessari quando smetti di utilizzare la prenotazione.
Per creare la prenotazione, fai clic su Crea. Viene visualizzata la pagina Prenotazioni. La creazione della prenotazione può richiedere fino a un minuto. Per verificare quando Compute Engine termina la creazione, visualizza le prenotazioni.

Specifica le proprietà direttamente

Per creare una prenotazione condivisa specificando direttamente le proprietà, seleziona una delle seguenti opzioni:

Console

Nella console Google Cloud , vai alla pagina Prenotazioni.

Vai a Prenotazioni
Fai clic su Crea prenotazione. Viene visualizzata la pagina Crea una prenotazione.
Nel campo Nome, inserisci un nome per la prenotazione.
Negli elenchi Regione e Zona, seleziona dove vuoi prenotare le risorse.
Nella sezione Tipo di condivisione, segui questi passaggi:
1. Per condividere una prenotazione con altri progetti, seleziona Condivisa.
2. Fai clic su Aggiungi progetti, quindi seleziona i progetti dell'organizzazione del progetto corrente con cui vuoi condividere la prenotazione. Puoi selezionare fino a 100 progetti consumer.
(Facoltativo) Per consentire job di addestramento personalizzato o job di previsione in Vertex AI di utilizzare una prenotazione di VM GPU, nella sezione Servizi Google Cloud, seleziona Condividi prenotazione.
Nella sezione Utilizza con un'istanza VM, seleziona una delle seguenti opzioni:
- Per consentire alle VM corrispondenti di utilizzare automaticamente questa prenotazione, seleziona Utilizza automaticamente la prenotazione.
- Per utilizzare le risorse di questa prenotazione solo quando crei VM corrispondenti che hanno come target specifico la prenotazione in base al nome, seleziona Seleziona una prenotazione specifica.
Nella sezione Dettagli risorsa:
- Nel campo Numero di istanze VM, inserisci il numero di VM che vuoi prenotare.
- Specifica la serie e il tipo di macchina che vuoi prenotare.
Nella sezione Eliminazione automatica, puoi attivare l'opzione di eliminazione automatica per consentire a Compute Engine di eliminare automaticamente la prenotazione in una data e ora specifica. L'eliminazione automatica delle prenotazioni può essere utile per evitare addebiti non necessari quando smetti di utilizzare la prenotazione.
Per creare la prenotazione, fai clic su Crea. Viene visualizzata la pagina Prenotazioni. La creazione della prenotazione può richiedere fino a un minuto. Per verificare quando Compute Engine termina la creazione, visualizza le prenotazioni.

gcloud

Per creare una prenotazione condivisa, utilizza il comando gcloud compute reservations create con i flag --share-setting=projects e --share-with.

Per creare una prenotazione condivisa specificando le proprietà direttamente e senza includere flag facoltativi, esegui questo comando:

gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

Sostituisci quanto segue:

RESERVATION_NAME: il nome della prenotazione da creare.
MACHINE_TYPE: un tipo di macchina da utilizzare per ogni VM.
CONSUMER_PROJECT_IDS: un elenco separato da virgole di ID dei progetti che possono utilizzare questa prenotazione, ad esempio project-1,project-2. Puoi includere fino a 100 progetti consumer. Questi progetti devono appartenere alla stessa organizzazione del progetto proprietario. Non includere il progetto proprietario. Per impostazione predefinita, è già autorizzato a utilizzare la prenotazione.
NUMBER_OF_VMS: il numero di VM da prenotare.
ZONE: la zona in cui prenotare le risorse.

Ad esempio, per creare una prenotazione nella zona us-central1-a per dieci VM che utilizzano ciascuna un tipo di macchina predefinita N2 con 4 vCPU e condividerla con i progetti project-1 e project-2, esegui questo comando:

gcloud compute reservations create my-reservation \
    --machine-type=n2-standard-4 \
    --share-setting=projects \
    --share-with=project-1,project-2 \
    --vm-count=10 \
    --zone=us-central1-a

Facoltativamente, puoi eseguire una o più delle seguenti operazioni:

Per collegare GPU alle VM N1 prenotate, includi il flag --accelerator.
```
gcloud compute reservations create RESERVATION_NAME \
    --accelerator=count=NUMBER_OF_ACCELERATORS,type=ACCELERATOR_TYPE
    --machine-type=MACHINE_TYPE \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
Sostituisci quanto segue:
- NUMBER_OF_ACCELERATORS: il numero di GPU da aggiungere per VM prenotata.
- ACCELERATOR_TYPE: un modello di GPU supportato per le VM N1. Assicurati che il modello di GPU scelto sia disponibile nella zona in cui vuoi prenotare le risorse. In caso contrario, la creazione della prenotazione non andrà a buon fine.
Per collegare dischi SSD locali a un tipo di macchina che non li include per impostazione predefinita, includi il flag --local-ssd. Puoi collegare solo dischi SSD locali da 375 GB.
```
gcloud compute reservations create RESERVATION_NAME \
    --local-ssd=count=NUMBER_OF_LOCAL_SSD_DISKS,size=375,interface=INTERFACE_TYPE \
    --machine-type=MACHINE_TYPE \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
Sostituisci quanto segue:
- NUMBER_OF_LOCAL_SSD_DISKS: il numero di dischi SSD locali da collegare.
- INTERFACE_TYPE: il tipo di interfaccia disco che verrà utilizzato da ogni disco SSD locale e che è supportato dal tipo di macchina specificato. Specifica uno dei seguenti valori:
  - Per l'interfaccia disco NVME: nvme
  - Per l'interfaccia disco SCSI: scsi
Per fare in modo che le VM prenotate utilizzino una specifica piattaforma CPU minima anziché la piattaforma CPU predefinita della zona, includi il flag --min-cpu-platform.
```
gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --min-cpu-platform="MIN_CPU_PLATFORM" \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
Sostituisci MIN_CPU_PLATFORM con una piattaforma CPU minima. Per assicurarti che una piattaforma CPU sia disponibile nella zona in cui stai prenotando le risorse, visualizza le piattaforme CPU disponibili per zona.

Per specificare che solo le VM che hanno come target specifico questa prenotazione possono utilizzarla, includi il flag --require-specific-reservation.

gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --require-specific-reservation \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --reservation-sharing-policy=ALLOW_ALL \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

Per consentire a Compute Engine di eliminare automaticamente la prenotazione, seleziona uno dei seguenti metodi:

Anteprima — The --delete-at-time and --delete-after-duration flags

Questa funzionalità è soggetta ai "Termini delle Offerte pre-GA" nella sezione Termini di servizio generali dei Termini di servizio specifici. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per ulteriori informazioni, consulta le descrizioni delle fasi di lancio.
- Per eliminare la prenotazione in una data e ora specifica, utilizza il comando gcloud beta compute reservations create con il flag --delete-at-time.
```
gcloud beta compute reservations create RESERVATION_NAME \
    --delete-at-time=DELETE_AT_TIME \
    --machine-type=MACHINE_TYPE \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
  Sostituisci DELETE_AT_TIME con una data e ora formattata come timestamp RFC 3339, ovvero come segue:
```
YYYY-MM-DDTHH:MM:SSOFFSET
```
  Sostituisci quanto segue:
  - YYYY-MM-DD: una data formattata come anno a 4 cifre, mese a 2 cifre e giorno del mese a 2 cifre, separati da trattini (-).
  - HH:MM:SS: un orario formattato con l'ora a due cifre utilizzando il sistema a 24 ore, i minuti a due cifre e i secondi a due cifre, separati da due punti (:).
  - OFFSET: il fuso orario formattato come offset rispetto al Tempo Universale Coordinato (UTC). Ad esempio, per utilizzare il fuso orario standard della costa del Pacifico (PST), specifica -08:00. In alternativa, per non utilizzare alcun offset, specifica Z.
- Per eliminare la prenotazione dopo un periodo di tempo specifico, utilizza il comando gcloud beta compute reservations create con il flag --delete-after-duration.
```
gcloud beta compute reservations create RESERVATION_NAME \
    --delete-after-duration=DELETE_AFTER_DURATION \
    --machine-type=MACHINE_TYPE \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
  Sostituisci DELETE_AFTER_DURATION con una durata in giorni, ore, minuti o secondi. Ad esempio, specifica 30m per 30 minuti o 1d2h3m4s per 1 giorno, 2 ore, 3 minuti e 4 secondi.

Terraform

Per creare una prenotazione, utilizza la risorsa Terraform google_compute_reservation. Per condividere una prenotazione con altri progetti, definisci il blocco share_settings:

Imposta il campo share_type su SPECIFIC_PROJECTS.
Nel blocco project_map, specifica gli ID progetto dei progetti con cui vuoi condividere questa prenotazione.

Per saperne di più su come utilizzare Terraform, consulta Utilizzo di Terraform con Google Cloud.

REST

Per creare una prenotazione condivisa, invia una richiesta POST al metodo reservations.insert. Nel corpo della richiesta, includi quanto segue:

Il campo projectMap.
Il campo shareType impostato su SPECIFIC_PROJECTS.

Ad esempio, per creare una prenotazione condivisa senza includere campi facoltativi e condividerla con due progetti consumer, invia la seguente richiesta POST:

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

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}

Sostituisci quanto segue:

PROJECT_ID: l'ID del progetto in cui vuoi prenotare le risorse.
ZONE: la zona in cui prenotare le risorse.
RESERVATION_NAME: il nome della prenotazione da creare.
CONSUMER_PROJECT_ID_1 e CONSUMER_PROJECT_ID_2: gli ID dei progetti che possono utilizzare questa prenotazione. Puoi includere fino a 100 progetti consumer. Questi progetti devono appartenere alla stessa organizzazione del progetto proprietario. Non includere il progetto proprietario. Per impostazione predefinita, è già autorizzato a utilizzare la prenotazione.
NUMBER_OF_VMS: il numero di VM da prenotare.
MACHINE_TYPE: un tipo di macchina da utilizzare per ogni VM.

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

{
  "name": "my-reservation",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "project-1": {
        "projectId": "project-1"
      },
      "project-2": {
        "projectId": "project-2"
      }
    }
  },
  "specificReservation": {
    "count": "10",
    "instanceProperties": {
      "machineType": "n2-standard-4",
    }
  }
}

Facoltativamente, puoi eseguire una o più delle seguenti operazioni:

Per collegare GPU alle VM N1 prenotate, includi il campo guestAccelerators nel corpo della richiesta.

Ad esempio, per creare una prenotazione condivisa con due progetti consumer e collegare GPU a qualsiasi VM N1 prenotata, invia la seguente richiesta:

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

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "guestAccelerators": [
        {
          "acceleratorCount": NUMBER_OF_ACCELERATORS,
          "acceleratorType": "ACCELERATOR_TYPE"
        }
      ],
      "machineType": "MACHINE_TYPE"
    }
  }
}

Sostituisci quanto segue:

NUMBER_OF_ACCELERATORS: il numero di GPU da aggiungere per VM prenotata.
ACCELERATOR_TYPE: un modello di GPU supportato per le VM N1. Assicurati che il modello di GPU scelto sia disponibile nella zona in cui vuoi prenotare le risorse. In caso contrario, la creazione della prenotazione non andrà a buon fine.

Per collegare i dischi SSD locali a un tipo di macchina che non li include per impostazione predefinita, includi il campo localSsds nel corpo della richiesta. Puoi collegare solo dischi SSD locali da 375 GB.

Ad esempio, per collegare due dischi SSD locali al tipo di macchina che vuoi prenotare specificando due progetti consumer, invia la seguente richiesta:

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

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "localSsds": [
        {
          "diskSizeGb": "375",
          "interface": "INTERFACE_TYPE"
        },
        {
          "diskSizeGb": "375",
          "interface": "INTERFACE_TYPE"
        }
      ],
      "machineType": "MACHINE_TYPE"
    }
  }
}

Sostituisci INTERFACE_TYPE con il tipo di interfaccia disco che verrà utilizzato da ogni disco SSD locale e che è supportato dal tipo di macchina specificato. Specifica uno dei seguenti valori:

Per l'interfaccia disco NVME: NVME
Per l'interfaccia disco SCSI: SCSI

Per fare in modo che le VM prenotate utilizzino una piattaforma CPU minima specifica anziché la piattaforma CPU predefinita della zona, includi il campo minCpuPlatform nel corpo della richiesta.

Ad esempio, per creare una prenotazione condivisa specificando una piattaforma CPU minima e due progetti consumer, invia la seguente richiesta:

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

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE",
      "minCpuPlatform": "MIN_CPU_PLATFORM"
    }
  }
}

Sostituisci MIN_CPU_PLATFORM con una piattaforma CPU minima. Per assicurarti che una piattaforma CPU sia disponibile nella zona in cui stai prenotando le risorse, visualizza le piattaforme CPU disponibili per zona.

Per specificare che solo le VM che hanno come target specifico questa prenotazione possono utilizzarla, includi il campo specificReservationRequired nel corpo della richiesta e impostalo su true.

Ad esempio, per creare una prenotazione specifica e condividerla con due progetti consumer, invia la seguente richiesta:

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

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  },
  "specificReservationRequired": true
}

Per consentire ai job di addestramento personalizzato o ai job di previsione in Vertex AI di utilizzare una prenotazione di VM GPU, includi il campo serviceShareType e impostalo su ALLOW_ALL.

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

{
  "name": "RESERVATION_NAME",
  "reservationSharingPolicy": {
    "serviceShareType": "ALLOW_ALL"
  },
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}

Per consentire a Compute Engine di eliminare automaticamente la prenotazione, seleziona uno dei seguenti metodi:

Anteprima — The deleteAtTime and deleteAfterDuration fields

Questa funzionalità è soggetta ai "Termini delle Offerte pre-GA" nella sezione Termini di servizio generali dei Termini di servizio specifici. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per ulteriori informazioni, consulta le descrizioni delle fasi di lancio.
- Per eliminare la prenotazione in una data e ora specifica, effettua una richiesta POST al metodo beta.reservations.insert. Nel corpo della richiesta, includi il campo deleteAtTime.
  
  Ad esempio, per creare una prenotazione specificando una data e ora di eliminazione e condividerla con due progetti consumer, invia la seguente richiesta:
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAtTime": "DELETE_AT_TIME",
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}
```
  Sostituisci DELETE_AT_TIME con una data e ora formattata come timestamp RFC 3339, ovvero come segue:
```
YYYY-MM-DDTHH:MM:SSOFFSET
```
  Sostituisci quanto segue:
  - YYYY-MM-DD: una data formattata come anno a 4 cifre, mese a 2 cifre e giorno del mese a 2 cifre, separati da trattini (-).
  - HH:MM:SS: un orario formattato con l'ora a due cifre utilizzando il sistema a 24 ore, i minuti a due cifre e i secondi a due cifre, separati da due punti (:).
  - OFFSET: il fuso orario formattato come offset rispetto al Tempo Universale Coordinato (UTC). Ad esempio, per utilizzare il fuso orario standard della costa del Pacifico (PST), specifica -08:00. In alternativa, per non utilizzare alcun offset, specifica Z.
- Per eliminare la prenotazione dopo un periodo di tempo specifico, effettua una richiesta POST al metodo beta.reservations.insert. Nel corpo della richiesta, includi il campo deleteAfterDuration.
  
  Ad esempio, per creare una prenotazione che Compute Engine elimina dopo un periodo di tempo specifico e condividerla con due progetti consumer, invia la seguente richiesta:
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAfterDuration": {
    "seconds": "DELETE_AFTER_DURATION"
  },
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}
```
  Sostituisci DELETE_AFTER_DURATION con una durata in secondi. Ad esempio, specifica 86400 per 86.400 secondi (1 giorno).

Risoluzione dei problemi

Scopri come risolvere i problemi di creazione delle prenotazioni.

Passaggi successivi

Scopri come visualizzare le prenotazioni.
Scopri come collegare le prenotazioni agli impegni.
Scopri come utilizzare le prenotazioni.
Scopri come monitorare l'utilizzo delle prenotazioni.

Crea una prenotazione condivisa Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Prima di iniziare

Console

gcloud

Terraform

Go

Java

Node.js

Python

REST

Ruoli obbligatori

Autorizzazioni obbligatorie

Crea una prenotazione condivisa

Specifica un modello di istanza

Console

gcloud

Go

Java

Node.js

Python

REST

Specifica una VM esistente

Specifica le proprietà direttamente

Console

gcloud

Terraform

REST

Risoluzione dei problemi

Passaggi successivi

Crea una prenotazione condivisa