Questa pagina è stata tradotta dall'API Cloud Translation.

Creare una prenotazione condivisa

Questo documento spiega come creare prenotazioni condivise, ovvero prenotazioni condivisi 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 del 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à riservate. Utilizzando le prenotazioni condivise, puoi migliorare l'utilizzo delle prenotazioni e ridurre il numero di prenotazioni da creare e gestire. Per scoprire di più sulle prenotazioni, consulta la pagina relativa alle prenotazioni di risorse di zona di Compute Engine.

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

Se nel progetto corrente sono presenti impegni di 1 o 3 anni, le risorse riservate ricevono automaticamente gli sconti per impegno di utilizzo (CUD) applicabili. Puoi anche creare e allegare una prenotazione a un impegno quando acquisti l'impegno. Per saperne di più, consulta Collegare le prenotazioni agli impegni.
Per creare una prenotazione che può essere utilizzata solo da un singolo progetto, consulta Creare una prenotazione per un singolo progetto.

Prima di iniziare

Esamina i requisiti e le limitazioni per le prenotazioni.
Esamina i requisiti relativi alle quote e le limitazioni per le prenotazioni condivise.
Assicurati che il progetto che utilizzi per creare prenotazioni condivise sia stato aggiunto alla lista consentita per il vincolo delle norme dell'organizzazione Progetti del proprietario con prenotazioni condivise (compute.sharedReservationsOwnerProjects) da un amministratore delle norme 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 ulteriori dettagli sulla visualizzazione e sulla modifica del vincolo dei criteri dell'organizzazione, consulta Consentire e limitare la creazione e la modifica delle prenotazioni condivisi dai progetti in questo documento.
Se non l'hai ancora fatto, configura l'autenticazione. L'autenticazione è la procedura mediante la quale la tua identità viene verificata per l'accesso alle API e ai 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. Install the Google Cloud CLI, then initialize it by running the following command:
  gcloud init
  Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
2. Set a default region and zone.

Ruoli obbligatori

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

Amministratore Compute (roles/compute.admin) nel progetto
Per visualizzare e modificare i criteri dell'organizzazione: Amministratore criteri organizzazione (roles/orgpolicy.policyAdmin) nell'organizzazione

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

Questi ruoli predefiniti contengono le autorizzazioni necessarie per creare prenotazioni condivise. Per visualizzare le autorizzazioni esatte richieste, espandi la sezione Autorizzazioni richieste:

Autorizzazioni obbligatorie

Per creare prenotazioni condivise sono necessarie le seguenti autorizzazioni:

compute.reservations.create sul progetto
Per visualizzare i criteri dell'organizzazione: orgpolicy.policy.get nell'organizzazione
Per modificare i criteri dell'organizzazione: orgpolicy.policy.set nell'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.

Best practice

Quando crei prenotazioni condivise, ti consigliamo di adottare le best practice riportate di seguito. Se li segui, puoi contribuire a ottimizzare la gestione e l'utilizzo delle prenotazioni condivise nella tua organizzazione.

Chiedi al progetto del proprietario di creare la prenotazione condivisa, ma di non utilizzarla.
- Per distribuire le spese tra i progetti, è consigliabile far consumare una prenotazione condivisa solo ai progetti consumer. Il progetto del proprietario deve essere utilizzato solo per creare la prenotazione condivisa.
- Quando crei una prenotazione condivisa, il progetto proprietario deve avere una quota sufficiente per le risorse totali da prenotare. Dopo aver creato la prenotazione, il progetto proprietario deve avere una quota per le risorse riservate che vuole consumare. Per saperne di più, consulta Requisiti aggiuntivi per le quote per le prenotazioni condivise.
Riduci al minimo il numero di progetti nella tua organizzazione a cui consenti di creare prenotazioni condivise. Puoi controllarlo tramite il vincolo della policy dell'organizzazione Progetti del proprietario con prenotazioni condivise (compute.sharedReservationsOwnerProjects).
- Puoi elencare solo le prenotazioni create da ciascun progetto. Ciò significa che le prenotazioni condivise sono elencate solo nel progetto del proprietario. Non puoi elencare le prenotazioni condivise con ogni progetto o elencare tutte le prenotazioni condivise in ogni organizzazione. Pertanto, avere solo alcuni progetti del proprietario semplifica il monitoraggio e la gestione delle prenotazioni condivise.
- Limita la condivisione di una prenotazione condivisa solo ad alcuni progetti per gestire più facilmente la quota delle risorse riservate.
- Per scoprire di più, consulta Consentire e limitare la creazione e la modifica delle prenotazioni condivise da parte dei progetti.
Riduci al minimo il numero di prenotazioni condivise separate con proprietà VM identiche.
- Un'organizzazione può avere fino a 100 prenotazioni condivise per ogni combinazione unica di proprietà delle VM. Di conseguenza, ridurre al minimo il numero di prenotazioni condivise con proprietà VM identiche che crei contribuisce ad attenuare questo limite.
- Avere meno prenotazioni condivise migliora la gestione.
Condividi le prenotazioni solo tra progetti con lo stesso account di fatturazione Cloud.
- Limita ogni prenotazione condivisa in modo che sia condivisa solo con i progetti consumer che hanno lo stesso account di fatturazione Cloud del progetto proprietario. In questo modo è più facile capire se una prenotazione è stata utilizzata e come è stata fatturata.
- Se hai attivato la condivisione dei CUD e hai l'idoneità a ricevere CUD a livello di account di fatturazione Cloud, per massimizzare i CUD ricevuti per le prenotazioni consumate, limita le prenotazioni condivise all'account di fatturazione Cloud dell'impegno. In questo modo, puoi mantenere una fatturazione coerente nei progetti che creano e utilizzano prenotazioni condivise.
Per le richieste di prenotazione future, esamina attentamente il numero totale di VM richieste.
- Se stai creando una richiesta di prenotazione futura, assicurati di richiedere un conteggio totale di VM che tenga conto di quanto segue:
  - Tutte le VM riservate corrispondenti esistenti già alla data futura.
  - Tutte le VM non riservate corrispondenti esistenti già alla data futura.
  - Eventuali prenotazioni on demand inutilizzate corrispondenti esistenti già alla data futura.
  - L'aumento dell'utilizzo che vuoi prenotare per la data futura.
  Ad esempio, supponiamo che tu abbia bisogno di altre 10 VM alla data futura e che tu abbia già le seguenti risorse alla data futura:
  - 40 VM prenotate corrispondenti
  - 50 VM non riservate corrispondenti
  o
  - 40 VM prenotate corrispondenti
  - 50 prenotazioni on demand non utilizzate corrispondenti
  Poiché il tuo utilizzo esistente alla data futura corrisponde già a 90 VM e prenotazioni corrispondenti e hai bisogno di altre dieci VM, devi specificare un conteggio totale di 100 nella richiesta di prenotazione futura.
  
  Nota: se crei altre prenotazioni on demand dopo aver inviato la richiesta di prenotazione futura e prima della data futura, queste vengono conteggiate nel conteggio totale.
  
  Se dopo la data futura aggiungi altre prenotazioni on demand, queste vengono aggiunte al conteggio totale precedente. Ad esempio, se dopo la data futura prenoti altre dieci VM, avrai 110 prenotazioni.
  
  Per ulteriori informazioni, consulta Conteggio e provisioning delle risorse riservate.

Consentire e limitare la creazione e la modifica delle prenotazioni condivise da parte dei progetti

Per impostazione predefinita, nessun progetto è autorizzato a creare o modificare prenotazioni condivise in un'organizzazione. Aggiungi progetti al vincolo delle norme dell'organizzazione Progetti del proprietario con prenotazioni condivise (compute.sharedReservationsOwnerProjects) per consentire loro di creare e modificare le prenotazioni condivise. Per ulteriori informazioni sui vincoli delle norme dell'organizzazione, consulta la pagina Introduzione al servizio Norme dell'organizzazione.

Per visualizzare e modificare il vincolo dei criteri dell'organizzazione Progetti del proprietario con prenotazioni condivise (compute.sharedReservationsOwnerProjects):

Visualizza il vincolo delle norme dell'organizzazione per le prenotazioni condivise

Per vedere quali progetti sono autorizzati a creare e modificare le prenotazioni condivise, utilizza la console Google Cloud o gcloud CLI.

Console

Segui i passaggi per la visualizzazione dei criteri dell'organizzazione utilizzando il vincolo Progetti del proprietario con prenotazioni condivise.

gcloud

Per sapere quali progetti il vincolo compute.sharedReservationsOwnerProjects consente di creare e modificare le prenotazioni condivise:

Scarica il criterio per la tua organizzazione come file denominato policy.yaml utilizzando il comando gcloud resource-manager org-policies describe:
```
gcloud resource-manager org-policies describe compute.sharedReservationsOwnerProjects --organization=ORGANIZATION_ID > policy.yaml
```
Sostituisci ORGANIZATION_ID con l'ID organizzazione della tua organizzazione.
Utilizza un editor di testo per aprire il file policy.yaml e visualizzare il vincolo compute.sharedReservationsOwnerProjects. I progetti autorizzati a creare e modificare le prenotazioni condivise sono elencati sotto allowedValues:
```
...
constraint: constraints/compute.sharedReservationsOwnerProjects
listPolicy:
  allowedValues:
  - projects/PROJECT_NUMBER_1
  - projects/PROJECT_NUMBER_2
  - projects/PROJECT_NUMBER_3
...
```
dove PROJECT_NUMBER_1, PROJECT_NUMBER_2 e PROJECT_NUMBER_3 sono i numeri di progetto degli unici progetti della tua organizzazione autorizzati a creare prenotazioni condivise.
(Facoltativo) Elimina il file policy.yaml.
- Se utilizzi un terminale Linux o macOS, utilizza il seguente comando:
```
rm policy.yaml
```
- Se utilizzi un terminale Windows, utilizza il seguente comando:
```
del policy.yaml
```

Modificare il vincolo dei criteri dell'organizzazione per le prenotazioni condivise

Per modificare i progetti che possono creare e modificare le prenotazioni condivise, utilizza la console Google Cloud o gcloud CLI.

Console

Segui i passaggi per la personalizzazione dei criteri per i vincoli degli elenchi utilizzando il vincolo Progetti dei proprietari di prenotazioni condivise.

gcloud

Per modificare i progetti per i quali il vincolo compute.sharedReservationsOwnerProjects consente di creare e modificare le prenotazioni condivise, utilizza uno dei seguenti metodi:

Per concedere a un singolo progetto l'autorizzazione per creare e modificare le prenotazioni condivise, utilizza il gcloud resource-manager org-policies allowcomando. Puoi ripetere questo comando per ogni progetto a cui vuoi concedere questa autorizzazione.
```
gcloud resource-manager org-policies allow compute.sharedReservationsOwnerProjects projects/PROJECT_NUMBER \
    --organization=ORGANIZATION_ID
```
Sostituisci quanto segue:
- PROJECT_NUMBER: il numero di progetto (non l'ID progetto) di un progetto della tua organizzazione per cui vuoi consentire la creazione e la modifica delle prenotazioni condivise.
- ORGANIZATION_ID: il ID organizzazione della tua organizzazione.
Per concedere o revocare le autorizzazioni per più progetti per creare e modificare le prenotazioni condivise, sostituisci il vincolo delle norme dell'organizzazione:
1. Per scaricare il criterio per la tua organizzazione come file denominato policy.yaml, utilizza il comando gcloud resource-manager org-policies describe:
```
gcloud resource-manager org-policies describe compute.sharedReservationsOwnerProjects --organization=ORGANIZATION_ID > policy.yaml
```
  Sostituisci ORGANIZATION_ID con l'ID organizzazione della tua organizzazione.
2. Utilizza un editor di testo per modificare il file policy.yaml in modo che il vincolo compute.sharedReservationsOwnerProjects elenchi tutti i progetti per i quali vuoi che sia consentito creare e modificare prenotazioni condivise sotto il relativo allowedValues.
  - Per ogni progetto a cui vuoi concedere l'autorizzazione a creare e modificare le prenotazioni condivise, aggiungi il progetto in una nuova riga sotto allowedValues.
  - Per ogni progetto per cui vuoi revocare l'autorizzazione a creare e modificare le prenotazioni condivise, elimina la riga relativa al progetto.
  Al termine, assicurati che il file policy.yaml abbia un aspetto simile al seguente:
```
...
constraint: constraints/compute.sharedReservationsOwnerProjects
listPolicy:
  allowedValues:
  - projects/PROJECT_NUMBER_1
  - projects/PROJECT_NUMBER_2
  - projects/PROJECT_NUMBER_3
...
```
  dove PROJECT_NUMBER_1, PROJECT_NUMBER_2 e PROJECT_NUMBER_3 sono i numeri di progetto (non gli ID progetto) di tutti i progetti della tua organizzazione per i quali vuoi avere l'autorizzazione a creare e modificare le prenotazioni condivise.
3. Salva il file policy.yaml e chiudi l'editor di testo.
4. Per aggiornare i criteri per la tua organizzazione con le modifiche, utilizza il comando gcloud resource-manager org-policies set-policy:
```
gcloud resource-manager org-policies set-policy --organization=ORGANIZATION_ID policy.yaml
```
  Sostituisci ORGANIZATION_ID con l'ID organizzazione della tua organizzazione.
5. (Facoltativo) Elimina il file policy.yaml.
  - Se utilizzi un terminale Linux o macOS, utilizza il seguente comando:
```
rm policy.yaml
```
  - Se utilizzi un terminale Windows, utilizza il seguente comando:
```
del policy.yaml
```

Potresti dover attendere qualche minuto prima che la modifica venga applicata.

Creare 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 a quella prenotazione. Per specificare le proprietà delle VM che vuoi prenotare, seleziona una delle seguenti sezioni di questo documento:

Consigliato: 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 le proprietà di una prenotazione e le VM che possono utilizzare la prenotazione nello stesso posto. Tuttavia, poiché i modelli sono specifici del progetto, non puoi utilizzare lo stesso modello per creare VM che possono utilizzare la prenotazione al di fuori del progetto che ha creato la prenotazione. Per i progetti con cui la prenotazione è condivisa, devi creare modelli simili in questi progetti 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. Utilizzando le proprietà di una VM esistente, puoi utilizzare la prenotazione creando VM con proprietà corrispondenti a quelle della VM di riferimento.
Specificare 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 il consumo.

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

Crea una prenotazione che può essere utilizzata solo dalle VM che la scelgono come target specifico, come spiegato nelle sezioni seguenti di questo documento. Poi, configura le VM in modo che utilizzino la prenotazione specifica.
Configura le VM che non possono utilizzare 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 modello di istanza, ad esempio un tipo di macchina o un volume Persistent Disk, limita l'utilizzo del modello alle località in cui esistono queste risorse. Ad esempio, se il modello 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 regione o zona specifica, visualizza i dettagli del modello di istanza e cerca i riferimenti alle risorse regionali o zonali al suo interno.

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

Viene visualizzata la pagina Prenotazioni.
Fai clic su Crea prenotazione.

Viene visualizzata la pagina Crea una prenotazione.
In Nome, inserisci un nome per la prenotazione.
Per Regione e Zona, seleziona dove vuoi prenotare le risorse.
Nella sezione Tipo di condivisione:
1. Per specificare una prenotazione condivisa, seleziona Condivisa.
2. Fai clic su Aggiungi progetti e poi seleziona i progetti dell'organizzazione del progetto corrente con cui vuoi condividere la prenotazione. Puoi selezionare fino a 100 progetti per consumatori.
(Facoltativo) Per consentire l'utilizzo di una prenotazione di VM GPU da parte di job di addestramento personalizzato o job di previsione in Vertex AI, nella sezione Servizi Google Cloud, selezionare Condividi prenotazione.
Nella sezione Utilizza con un'istanza VM, seleziona una delle seguenti opzioni:
- Per consentire alle istanze VM corrispondenti di utilizzare automaticamente questa prenotazione, seleziona Utilizza automaticamente la prenotazione se non è già selezionata.
- Per utilizzare le risorse di questa prenotazione solo quando crei VM corrispondenti che scelgono come target specifico questa prenotazione per nome, seleziona Seleziona una prenotazione specifica.
  
  Nota: se il modello di istanza specifica un tipo di macchina A3, devi selezionare Seleziona una prenotazione specifica. In caso contrario, potresti riscontrare errori.
In Numero di istanze VM, inserisci il numero di VM da prenotare.
Nella sezione Configurazione macchina, seleziona Utilizza modello di istanza e poi il modello di istanza che preferisci. Se selezioni un modello di istanza regionale, puoi prenotare risorse solo nella stessa regione del modello.
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 un'ora specifiche. 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 condivisa potrebbe richiedere fino a un minuto.

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 il seguente comando:

gcloud compute reservations create RESERVATION_NAME \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
    --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 per consumatori. Questi progetti devono trovarsi nella stessa organizzazione del progetto proprietario. Non includere il progetto del proprietario. Per impostazione predefinita, è già consentito consumare la prenotazione.
LOCATION: la posizione del modello di istanza. Specifica uno dei seguenti valori:
- Per un modello di istanza globale: global.
- Per un modello di istanza regionale: regions/REGION. Sostituisci REGION con la regione in cui si trova il modello dell'istanza. Se specifichi un modello di istanza regionale, puoi prenotare le VM solo nella stessa regione del modello.
INSTANCE_TEMPLATE_NAME: il nome di un modello istanza esistente. Se il modello di istanza specifica un tipo di macchina A3, devi includere il flag --require-specific-reservation. Ciò indica che solo le VM che hanno come target specifico la prenotazione possono utilizzarla. Per ulteriori informazioni, consulta la pagina Utilizzare le VM da una prenotazione specifica.
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, condividi la prenotazione con i progetti project-1 e project-2 e prenota dieci VM che utilizzano ciascuna un tipo di macchina N2 predefinito con 4 vCPU, esegui il seguente 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

Se vuoi, puoi eseguire una o più delle seguenti operazioni:

Per specificare che solo le VM che hanno come target specifico questa prenotazione possono consumarla, 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=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

Per consentire l'utilizzo di una prenotazione di VM GPU da parte di job di addestramento personalizzato o job di previsione in Vertex AI, utilizza il comando gcloud beta compute reservations create con il flag --reservation-sharing-policy=ALLOW_ALL.

Anteprima - The --reservation-sharing-policy flag

Questa funzionalità è soggetta ai "Termini delle Offerte pre-GA" nella sezione Termini generali del servizio dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.
```
gcloud beta compute reservations create RESERVATION_NAME \
    --reservation-sharing-policy=ALLOW_ALL \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
    --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 generali del servizio dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.
- Per eliminare la prenotazione in una data e in un'ora specifiche, 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=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
  Sostituisci DELETE_AT_TIME con una data e un'ora formattate come timestamp RFC 3339, che deve essere 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'ora formattata come ora a due cifre con un'ora in formato 24 ore, minuti a due cifre e secondi a due cifre, separati da due punti (:).
  - OFFSET: il fuso orario formattato come offset di Tempo Universale Coordinato (UTC). Ad esempio, per utilizzare il fuso orario PST (Pacific Standard Time), specifica-08:00. In alternativa, per non utilizzare alcun offset, specifica Z.
- Per eliminare la prenotazione dopo una durata specifica, 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=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
    --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.

Vai

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.Operation;
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 {
  private final ReservationsClient reservationsClient;

  // Constructor to inject the ReservationsClient
  public CreateSharedReservation(ReservationsClient reservationsClient) {
    this.reservationsClient = reservationsClient;
  }

  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 the reservation resides.
    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/YOUR_INSTANCE_TEMPLATE_NAME", projectId);
    // Number of instances for which capacity needs to be reserved.
    int vmCount = 3;
    // In your main method, create ReservationsClient
    ReservationsClient client = ReservationsClient.create();
    // Create an instance of your class, passing in the client
    CreateSharedReservation creator = new CreateSharedReservation(client);

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

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

    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_ID_1", ShareSettingsProjectConfig.newBuilder().build())
        .putProjectMap("CONSUMER_PROJECT_ID_2", ShareSettingsProjectConfig.newBuilder().build())
        .build();

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

    // Wait for the create reservation operation to complete.
    Operation response =
        this.reservationsClient.insertAsync(projectId, zone, reservation).get(3, TimeUnit.MINUTES);

    if (response.hasError()) {
      System.out.println("Reservation creation failed!" + response);
      return;
    }
    System.out.println("Reservation created. Operation Status: " + 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": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
  }
}

Sostituisci quanto segue:

PROJECT_ID: l'ID del progetto in cui vuoi prenotare le risorse e in cui esiste il modello 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 trovarsi nella stessa organizzazione del progetto del proprietario. Non includere il progetto del proprietario. Per impostazione predefinita, è già consentito utilizzare la prenotazione.
NUMBER_OF_VMS: il numero di VM da prenotare.
LOCATION: la posizione del modello di istanza. Specifica uno dei seguenti valori:
- Per un modello di istanza globale: global.
- Per un modello di istanza regionale: regions/REGION. Sostituisci REGION con la regione in cui si trova il modello dell'istanza. Se specifichi un modello di istanza regionale, puoi prenotare le VM solo nella stessa regione del modello.
INSTANCE_TEMPLATE_NAME: il nome di un modello istanza esistente. Se il modello di istanza specifica un tipo di macchina A3, devi includere il campo specificReservationRequired nel corpo della richiesta e impostarlo su true. Ciò indica che solo le VM che hanno come target specifico questa prenotazione possono utilizzarla. Per ulteriori informazioni, consulta Utilizzare le VM da una prenotazione specifica.

Ad esempio, per creare una prenotazione per dieci VM nella zona us-central1-a specificando un modello di istanza globale e condividerla con i progetti project-1 e project-2, effettua 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": "projects/example-project/global/instanceTemplates/example-instance-template"
  }
}

Se vuoi, puoi eseguire una o più delle seguenti operazioni:

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

Ad esempio, per creare una prenotazione specifica specificando un modello di istanza e condividerla con due progetti consumer, effettua una richiesta come segue:

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": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
  },
  "specificReservationRequired": true
}

Per consentire l'utilizzo di una prenotazione di VM GPU da parte di job di addestramento personalizzato o job di previsione in Vertex AI, invia una richiesta POST al metodo beta.reservations.insert. Nel corpo della richiesta, includi il campo serviceShareType e impostalo su ALLOW_ALL.

POST https://compute.googleapis.com/compute/beta/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": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
  }
}

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 generali del servizio dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.
- Per eliminare la prenotazione in una data e un'ora specifiche, 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, eliminarla automaticamente in una data e un'ora specifiche e condividerla con due progetti consumer, effettua una richiesta come segue:
```
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": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
  }
}
```
  Sostituisci DELETE_AT_TIME con una data e un'ora formattate come timestamp RFC 3339, che deve essere 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'ora formattata come ora a due cifre con un'ora in formato 24 ore, minuti a due cifre e secondi a due cifre, separati da due punti (:).
  - OFFSET: il fuso orario formattato come offset di Tempo Universale Coordinato (UTC). Ad esempio, per utilizzare il fuso orario PST (Pacific Standard Time), specifica-08:00. In alternativa, per non utilizzare alcun offset, specifica Z.
- Per eliminare la prenotazione dopo un periodo di tempo specifico, invia una POST richiesta al metodo beta.reservations.insert. Nel corpo della richiesta, includi il campo deleteAfterDuration.
  
  Ad esempio, per creare una prenotazione specificando un modello di istanza, eliminarla automaticamente dopo una durata specifica e condividerla con due progetti consumer, effettua una richiesta come segue:
```
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": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
  }
}
```
  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 solo in base a una VM esistente 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. A tal fine, puoi eseguire una delle seguenti operazioni:

Crea e utilizza un modello di istanza come segue:
1. Crea un modello di istanza basato sulla VM di riferimento senza sostituire le proprietà della VM di riferimento.
  
  Nota: non puoi creare un modello di istanza basato sulla VM di riferimento al di fuori del progetto della VM. Per i progetti con cui la prenotazione è condivisa, devi creare modelli di istanze simili in questi progetti.
2. Crea le VM utilizzando il modello appena creato effettuando una o entrambe le operazioni riportate di seguito:
  - Creare una singola VM
  - Crea un gruppo di istanze gestite a livello di zona
Crea una VM con proprietà che corrispondono esattamente alla VM di riferimento come segue:
- Nel progetto del 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 utilizzi le proprietà di una VM esistente:

Nella console Google Cloud, vai alla pagina Prenotazioni.

Vai a Prenotazioni
Nella scheda Prenotazioni on demand (predefinita), fai clic su Crea prenotazione.

Viene visualizzata la pagina Crea una prenotazione.
In Nome, inserisci un nome per la prenotazione.
Per Regione e Zona, seleziona dove vuoi prenotare le risorse.
Nella sezione Tipo di condivisione:
1. Per specificare una prenotazione condivisa, seleziona Condivisa.
2. Fai clic su Aggiungi progetti e poi seleziona i progetti dell'organizzazione del progetto corrente con cui vuoi condividere la prenotazione. Puoi selezionare fino a 100 progetti consumer.
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 se non è già selezionata.
- Per utilizzare le risorse di questa prenotazione solo quando crei VM corrispondenti che scelgono come target specifico questa prenotazione per nome, seleziona Seleziona una prenotazione specifica.
  
  Nota: se la VM di riferimento specifica un tipo di macchina A3, devi selezionare Seleziona una prenotazione specifica. In caso contrario, non potrai creare la prenotazione.
In Numero di istanze VM, inserisci il numero di VM da prenotare.
Nella sezione Configurazione macchina:
1. Seleziona Usa VM esistente.
2. Per VM esistente, seleziona la VM le cui proprietà vuoi utilizzare per creare la prenotazione.
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 un'ora specifiche. 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 potrebbe richiedere fino a un minuto.

Specificare 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
Nella scheda Prenotazioni on demand (predefinita), fai clic su Crea prenotazione.
Fai clic su Crea prenotazione.

Viene visualizzata la pagina Crea una prenotazione.
In Nome, inserisci un nome per la prenotazione.
Per Regione e Zona, seleziona dove vuoi prenotare le risorse.
Nella sezione Tipo di condivisione:
1. Per specificare una prenotazione condivisa, seleziona Condivisa.
2. Fai clic su Aggiungi progetti e poi seleziona i progetti dell'organizzazione del progetto corrente con cui vuoi condividere la prenotazione. Puoi selezionare fino a 100 progetti per consumatori.
(Facoltativo) Per consentire l'utilizzo di una prenotazione di VM GPU da parte di job di addestramento personalizzato o job di previsione in Vertex AI, nella sezione Servizi Google Cloud, selezionare 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 (valore predefinito).
- Per utilizzare le risorse di questa prenotazione solo quando crei VM corrispondenti che scelgono come target specifico questa prenotazione per nome, seleziona Seleziona una prenotazione specifica.
  
  Nota: se vuoi specificare un tipo di macchina A3 nella prenotazione, devi selezionare Seleziona una prenotazione specifica. In caso contrario, potresti riscontrare errori.
In Numero di istanze VM, inserisci il numero di VM da prenotare.
Nella sezione Configurazione macchina, seleziona Specifica il tipo di macchina e poi specifica quanto segue:
1. Per Famiglia di macchine, Serie e Tipo di macchina, seleziona una famiglia, una serie e un tipo di macchina.
2. (Facoltativo) Per specificare una piattaforma CPU minima o collegare GPU alle VM N1:
  1. Per espandere la sezione Piattaforma CPU e GPU, fai clic sulla freccia di espansione .
  2. (Facoltativo) Per specificare una piattaforma CPU minima, per Piattaforma CPU, seleziona un'opzione.
  3. (Facoltativo) Per collegare le GPU alle VM N1, fai clic su Aggiungi GPU. Poi, per Tipo di GPU e Numero di GPU, seleziona il tipo e il numero di GPU da collegare a ogni VM N1.
3. (Facoltativo) Per aggiungere unità SSD locali, procedi nel seguente modo:
  1. In Numero di dischi, seleziona il numero di dischi SSD locali per ogni VM.
  2. Per Tipo di interfaccia, seleziona l'interfaccia per i dischi SSD locali.
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 un'ora specifiche. 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 condivisa potrebbe richiedere fino a un minuto.

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 eventuali flag facoltativi, esegui il seguente 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. Se specifichi un tipo di macchina A3, devi includere il flag --require-specific-reservation. Ciò indica che solo le VM che hanno come target specifico la prenotazione possono utilizzarla. Per ulteriori informazioni, consulta la pagina Utilizzare le VM da una prenotazione specifica.
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 per consumatori. Questi progetti devono trovarsi nella stessa organizzazione del progetto proprietario. Non includere il progetto del proprietario. Per impostazione predefinita, è già consentito consumare 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 N2 predefinito con 4 vCPU e condividerla con i progetti project-1 e project-2, esegui il seguente 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

Se vuoi, puoi eseguire una o più delle seguenti operazioni:

Per collegare le GPU alle VM N1 riservate, 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 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 aggiungere uno o più dischi SSD locali a ogni VM riservata, includi uno o più flag --local-ssd. Puoi specificare fino a 24 dischi SSD locali. Ogni disco SSD locale ha una dimensione di 375 GB.

Ad esempio, per specificare due dischi SSD locali durante la creazione di una prenotazione condivisa, includi due flag --local-ssd come segue:
```
gcloud compute reservations create RESERVATION_NAME \
    --local-ssd=size=375,interface=INTERFACE_1 \
    --local-ssd=size=375,interface=INTERFACE_2 \
    --machine-type=MACHINE_TYPE \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
Sostituisci INTERFACE_1 e INTERFACE_2 con il tipo di interfaccia che vuoi che ogni disco SSD locale utilizzi. Specifica uno dei seguenti valori:
- Interfacce dei dischi NVME: nvme
- Interfacce dei dischi SCSI: scsi
Assicurati che il tipo di macchina specificato per le VM riservate supporti le interfacce dei dischi scelte. In caso contrario, la creazione della prenotazione non andrà a buon fine. Per ulteriori informazioni, scopri come scegliere un'interfaccia del disco.
Per fare in modo che le VM riservate utilizzino una specifica piattaforma CPU minima instead of the zone's default CPU platform, include the --min-cpu-platform flag.
```
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 consumarla, 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

Per consentire l'utilizzo di una prenotazione di VM GPU da parte di job di addestramento personalizzato o job di previsione in Vertex AI, utilizza il comando gcloud beta compute reservations create con il flag --reservation-sharing-policy=ALLOW_ALL.

Anteprima - The --reservation-sharing-policy flag

Questa funzionalità è soggetta ai "Termini delle Offerte pre-GA" nella sezione Termini generali del servizio dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.
```
gcloud beta 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 generali del servizio dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.
- Per eliminare la prenotazione in una data e in un'ora specifiche, 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 un'ora formattate come timestamp RFC 3339, che deve essere 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'ora formattata come ora a due cifre con un'ora in formato 24 ore, minuti a due cifre e secondi a due cifre, separati da due punti (:).
  - OFFSET: il fuso orario formattato come offset di Tempo Universale Coordinato (UTC). Ad esempio, per utilizzare il fuso orario PST (Pacific Standard Time), specifica-08:00. In alternativa, per non utilizzare alcun offset, specifica Z.
- Per eliminare la prenotazione dopo una durata specifica, 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 google_compute_reservation risorsa Terraform. Per specificare una prenotazione condivisa, definisci il blocco share_settings:

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

Per scoprire 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, effettua 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 trovarsi nella stessa organizzazione del progetto del proprietario. Non includere il progetto del proprietario. Per impostazione predefinita, è già consentito utilizzare la prenotazione.
NUMBER_OF_VMS: il numero di VM da prenotare.
MACHINE_TYPE: un tipo di macchina da utilizzare per ogni VM. Se specifichi un tipo di macchina A3, devi includere il campo specificReservationRequired nel corpo della richiesta e impostarlo su true. Ciò indica che solo le VM che hanno come target specifico la prenotazione possono utilizzarla.

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",
    }
  }
}

Se vuoi, puoi eseguire una o più delle seguenti operazioni:

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

Ad esempio, per creare una prenotazione condivisa con due progetti consumer e collegare le GPU a qualsiasi VM N1 prenotata, effettua una richiesta come segue:

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 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 aggiungere uno o più dischi SSD locali a ogni VM prenotata, includi il campo localSsds nel corpo della richiesta. Puoi specificare fino a 24 dischi SSD locali. Ogni disco SSD locale ha una dimensione di 375 GB.

Ad esempio, per creare una prenotazione condivisa specificando due dischi SSD locali e due progetti consumer, effettua una richiesta come segue:

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_1"
        },
        {
          "diskSizeGb": "375",
          "interface": "INTERFACE_2"
        }
      ],
      "machineType": "MACHINE_TYPE"
    }
  }
}

Sostituisci INTERFACE_1 e INTERFACE_2 con il tipo di interfaccia che vuoi che ogni disco SSD locale utilizzi. Specifica uno dei seguenti valori:

Interfacce dei dischi NVME: NVME
Interfacce dei dischi SCSI: SCSI

Assicurati che il tipo di macchina specificato per le VM riservate supporti le interfacce dei dischi scelte. In caso contrario, la creazione della prenotazione non andrà a buon fine. Per ulteriori informazioni, scopri come scegliere un'interfaccia del disco.

Per fare in modo che le VM riservate 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, effettua una richiesta come segue:

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, effettua una richiesta come segue:

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
}

POST https://compute.googleapis.com/compute/beta/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 generali del servizio dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.
- Per eliminare la prenotazione in una data e un'ora specifiche, 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 un'ora per eliminarla e condividerla con due progetti consumer, effettua una richiesta come segue:
```
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 un'ora formattate come timestamp RFC 3339, che deve essere 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'ora formattata come ora a due cifre con un'ora in formato 24 ore, minuti a due cifre e secondi a due cifre, separati da due punti (:).
  - OFFSET: il fuso orario formattato come offset di Tempo Universale Coordinato (UTC). Ad esempio, per utilizzare il fuso orario PST (Pacific Standard Time), specifica-08:00. In alternativa, per non utilizzare alcun offset, specifica Z.
- Per eliminare la prenotazione dopo un periodo di tempo specifico, invia una POST richiesta al metodo beta.reservations.insert. Nel corpo della richiesta, includi il campo deleteAfterDuration.
  
  Ad esempio, per creare una prenotazione che Compute Engine elimina dopo una durata specifica e condividerla con due progetti consumer, effettua una richiesta come segue:
```
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 il consumo delle prenotazioni.