Crea una prenotazione condivisa

Console

Segui i passaggi per la visualizzazione delle policy dell'organizzazione utilizzando il vincolo Progetti proprietari di prenotazioni condivise.

gcloud

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

1. Scarica la policy 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.

2. Utilizza un editor di testo per aprire il file policy.yaml e visualizzare il vincolo compute.sharedReservationsOwnerProjects. I progetti autorizzati a creare e modificare 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 nella tua organizzazione autorizzati a creare prenotazioni condivise.

3. (Facoltativo) Elimina il file policy.yaml.

   • Se utilizzi un terminale Linux o macOS, esegui questo comando:

     rm policy.yaml
     

   • Se utilizzi un terminale Windows, esegui questo comando:

     del policy.yaml
     

Console

Segui i passaggi per la personalizzazione delle policy per i vincoli di elenco utilizzando il vincolo Progetti proprietari di prenotazioni condivise.

gcloud

Per modificare i progetti ai 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 comando gcloud resource-manager org-policies allow. 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 a cui vuoi consentire di creare e modificare prenotazioni condivise.
  • ORGANIZATION_ID: l'ID organizzazione della tua organizzazione.

• Per concedere o revocare a più progetti le autorizzazioni per creare e modificare prenotazioni condivise, sostituisci il vincolo delle policy dell'organizzazione:

  1. Per scaricare la policy 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 ai quali vuoi consentire di creare e modificare prenotazioni condivise sotto allowedValues.

     • Per ogni progetto a cui vuoi concedere l'autorizzazione per creare e modificare prenotazioni condivise, aggiungi il progetto su una nuova riga sotto allowedValues.
     • Per ogni progetto a cui vuoi revocare l'autorizzazione per creare e modificare le prenotazioni condivise, elimina la riga corrispondente.

     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 ai quali vuoi concedere l'autorizzazione per creare e modificare prenotazioni condivise.

  3. Salva il file policy.yaml e chiudi l'editor di testo.

  4. Per aggiornare le policy 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, esegui questo comando:

       rm policy.yaml
       

     • Se utilizzi un terminale Windows, esegui questo comando:

       del policy.yaml
       

Console

1. Nella console Google Cloud , vai alla pagina Prenotazioni.

   Vai a Prenotazioni

   Viene visualizzata la pagina Prenotazioni.

2. Fai clic su add_box Crea prenotazione.

   Viene visualizzata la pagina Crea una prenotazione.

3. In Nome, inserisci un nome per la prenotazione.

4. Per Regione e Zona, seleziona dove vuoi prenotare le risorse.

5. Nella sezione Tipo di condivisione, segui questi passaggi:

   1. Per specificare una prenotazione condivisa, seleziona Condivisa.

   2. Fai clic su add Aggiungi progetti, quindi seleziona i progetti dell'organizzazione del progetto corrente con cui vuoi condividere la prenotazione. Puoi selezionare fino a 100 progetti consumer.

6. (Facoltativo) Per consentire l'utilizzo di una prenotazione di VM GPU da parte dei job di addestramento personalizzato o dei job di previsione in Vertex AI, nella sezione Servizi Google Cloud, seleziona Condividi prenotazione.

7. Nella sezione Utilizza con un'istanza VM, seleziona una delle seguenti opzioni:

   • Per consentire alle istanze VM corrispondenti di utilizzare automaticamente questa prenotazione, seleziona Usa automaticamente la prenotazione se non è già selezionata.

   • Per utilizzare le risorse di questa prenotazione solo durante la creazione di VM corrispondenti che hanno come target specifico questa prenotazione in base al nome, utilizza Seleziona una prenotazione specifica.

8. In Numero di istanze VM, inserisci il numero di VM che vuoi prenotare.

9. Nella sezione Configurazione macchina, seleziona Usa modello di istanza, quindi scegli il modello di istanza che preferisci. Se selezioni un modello di istanza regionale, puoi prenotare risorse solo nella stessa regione del modello.

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

11. 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 questo 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 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.

• LOCATION: la località 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 VM solo nella stessa regione del modello.

• INSTANCE_TEMPLATE_NAME: il nome di un modello di istanza esistente. Se il modello di istanza specifica un tipo di macchina A3 Mega, A3 High o A3 Edge, devi includere il flag --require-specific-reservation. Ciò indica che solo le VM che hanno come target specifico la prenotazione possono utilizzarla. Per saperne di più, consulta Utilizza VM di 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, 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=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 dei job di addestramento personalizzato o dei job di previsione in Vertex AI, 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=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:

  • 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=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
        --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=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.

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": "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 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.

• LOCATION: la località 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 VM solo nella stessa regione del modello.

• INSTANCE_TEMPLATE_NAME: il nome di un modello di istanza esistente. Se il modello di istanza specifica un tipo di macchina A3 Mega, A3 High o A3 Edge, 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 saperne di più, consulta Utilizza VM di una prenotazione specifica.

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

• Per consentire l'utilizzo di una prenotazione di VM GPU da parte dei job di addestramento personalizzato o dei job di previsione in Vertex AI, 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": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
    }
  }
  

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

  • Per eliminare la prenotazione in una data e ora specifica, invia 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": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
      }
    }
    

    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, invia 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": "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).

Console

1. Nella console Google Cloud , vai alla pagina Prenotazioni.

   Vai a Prenotazioni

2. Nella scheda Prenotazioni on demand (predefinita), fai clic su add_box Crea prenotazione.

3. Fai clic su add_box Crea prenotazione.

   Viene visualizzata la pagina Crea una prenotazione.

4. In Nome, inserisci un nome per la prenotazione.

5. Per Regione e Zona, seleziona dove vuoi prenotare le risorse.

6. Nella sezione Tipo di condivisione, segui questi passaggi:

   1. Per specificare una prenotazione condivisa, seleziona Condivisa.

   2. Fai clic su add Aggiungi progetti, quindi seleziona i progetti dell'organizzazione del progetto corrente con cui vuoi condividere la prenotazione. Puoi selezionare fino a 100 progetti consumer.

7. (Facoltativo) Per consentire l'utilizzo di una prenotazione di VM GPU da parte dei job di addestramento personalizzato o dei job di previsione in Vertex AI, nella sezione Servizi Google Cloud, seleziona Condividi prenotazione.

8. 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 durante la creazione di VM corrispondenti che hanno come target specifico questa prenotazione in base al nome, utilizza Seleziona una prenotazione specifica.

9. In Numero di istanze VM, inserisci il numero di VM che vuoi prenotare.

10. Nella sezione Configurazione macchina, seleziona Specifica il tipo di macchina, quindi 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, segui questi passaggi:

       1. Per espandere la sezione Piattaforma CPU e GPU, fai clic sulla freccia di espansione expand_more.

       2. (Facoltativo) Per specificare una piattaforma CPU minima, per Piattaforma CPU, seleziona un'opzione.

       3. (Facoltativo) Per collegare GPU alle VM N1, fai clic su add Aggiungi GPU. Quindi, 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 collegare dischi SSD locali a un tipo di macchina che non li include per impostazione predefinita, segui questi passaggi:

       1. In Numero di dischi, seleziona il numero di dischi SSD locali da collegare.

       2. Per Tipo di interfaccia, seleziona l'interfaccia del disco per i dischi SSD locali.

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

12. 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 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. Se specifichi un tipo di macchina A3 Mega, A3 High o A3 Edge, devi includere il flag --require-specific-reservation. Ciò indica che solo le VM che hanno come target specifico la prenotazione possono utilizzarla. Per saperne di più, consulta Utilizza VM di 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 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
  

• Per consentire l'utilizzo di una prenotazione di VM GPU da parte dei job di addestramento personalizzato o dei job di previsione in Vertex AI, includi il flag --reservation-sharing-policy impostato su ALLOW_ALL.

  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:

  • 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 specificare una prenotazione condivisa, 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. Se specifichi un tipo di macchina A3 Mega, A3 High o A3 Edge, 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.

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, 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",
    "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 l'utilizzo di una prenotazione di VM GPU da parte dei job di addestramento personalizzato o dei job di previsione in Vertex AI, 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:

  • Per eliminare la prenotazione in una data e ora specifica, invia 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, invia 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).