Creare una prenotazione per un singolo progetto

Questo documento spiega come creare una prenotazione per un singolo progetto, può essere utilizzato solo dalle istanze di macchine virtuali (VM) nello stesso progetto. A scopri di più sulle prenotazioni, consulta Prenotazioni delle risorse di zona 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 l'utilizzo a termine applicabili. Puoi anche creare e allegare una prenotazione a un impegno quando lo acquisti. Per saperne di più, consulta Collegare le prenotazioni agli impegni.

  • Per creare una prenotazione che possa essere utilizzata da più progetti, consulta Creare una prenotazione condivisa.

Prima di iniziare

  • Leggi lo requisiti e limitazioni per le prenotazioni.
  • Se non l'hai già 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 come segue.

    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
    2. Set a default region and zone.

      3. Terraform

      Per utilizzare gli esempi di Terraform in questa pagina in un ambiente dell'ambiente di sviluppo, installare e inizializzare gcloud CLI quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

      1. Install the Google Cloud CLI.

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

        gcloud init

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

        gcloud auth application-default login

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

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

      REST

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

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

        gcloud init

      Per ulteriori informazioni, vedi Esegui l'autenticazione per l'utilizzo di REST nella documentazione sull'autenticazione di Google Cloud.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per creare prenotazioni per singoli progetti, chiedi all'amministratore di concederti Ruolo IAM Amministratore computing (roles/compute.admin) nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per creare prenotazioni per un singolo progetto. Per vedere le autorizzazioni esatte obbligatorie, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per creare prenotazioni per un singolo progetto sono necessarie le seguenti autorizzazioni:

  • compute.reservations.create sul progetto
  • Per specificare un modello di istanza: compute.instanceTemplates.useReadOnly sul modello di istanza

Potresti anche riuscire a ottenere queste autorizzazioni con ruoli personalizzati altri ruoli predefiniti.

Crea una prenotazione per un singolo progetto

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. Utilizzando un modello di istanza, puoi definire le proprietà di una prenotazione e le VM che possono utilizzarla nello stesso posto.

  • Specifica una VM esistente

    Questa sezione spiega come utilizzare una VM esistente per definire le proprietà 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 un prenotazione. 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à che corrispondono. Se vuoi controllare il consumo delle prenotazioni, eseguine una o più dei seguenti:

Inoltre, puoi specificare criterio di posizionamento compatto quando crei una prenotazione per un singolo progetto. Un criterio di posizionamento compatto specifica che le VM devono essere posizionate il più vicino possibile tra loro per ridurre la latenza di rete.

Specifica un modello di istanza

Per evitare errori durante la creazione di una prenotazione specificando un modello di istanza, verifica quanto segue:

  • Crea la prenotazione nella stessa regione e zona delle risorse solo 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 del disco permanente, limita l'utilizzo del modello alle località in cui esistono queste risorse. Ad esempio, se il modello di istanza specifica un volume di Persistent Disk esistente nella zona us-central1-a, quindi puoi creare la tua prenotazione solo nella stessa zona. Per verificare se un del modello esistente specifica le risorse che associano il modello a un una regione o una zona specifica, visualizza i dettagli del modello di istanza e cercare riferimenti a risorse regionali o di zona al suo interno.

  • Se il modello di istanza specifica un criterio di posizionamento compatto, assicurati che il modello specifichi un tipo di macchina supportato per i criteri di posizionamento compatto. In caso contrario, la creazione della prenotazione non va a buon fine.

Per creare una prenotazione per un singolo progetto specificando un modello di istanza, seleziona una delle seguenti opzioni:

Console

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

    Vai a Prenotazioni

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

    Viene visualizzata la pagina Crea una prenotazione.

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

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

  5. Nella sezione Tipo di condivisione, seleziona Locale se non è già selezionato.

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

  7. Nella sezione Usa con istanza VM, seleziona una delle seguenti opzioni opzioni:

    • Per consentire alle VM corrispondenti di consumare automaticamente questa prenotazione, Seleziona Utilizza prenotazione automaticamente, se non è già selezionato selezionato.

    • Per utilizzare le risorse di questa prenotazione solo durante la creazione delle corrispondenze VM che scelgono specificamente come target questa prenotazione per nome, seleziona Seleziona una prenotazione specifica.

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

  9. Nella sezione Configurazione macchina:

    1. Per specificare le proprietà delle VM da un modello di istanza esistente, seleziona Utilizza modello di istanza.

    2. Nel campo Modello di istanza, seleziona il modello di istanza di tuo interesse. Se selezioni un modello di istanza regionale, puoi prenotare risorse solo all'interno della regione del modello di istanza.

  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 un'ora specifiche. L'eliminazione automatica delle prenotazioni può essere è utile per evitare addebiti inutili quando smetti di utilizzare prenotazione.

  11. Per creare la prenotazione, fai clic su Crea.

    Si apre la pagina Prenotazioni. Creazione della prenotazione per un singolo progetto l'operazione potrebbe richiedere fino a un minuto.

gcloud

Per creare una prenotazione per un singolo progetto, utilizza il comando gcloud compute reservations create.

Creare una prenotazione per un singolo progetto specificando un modello di istanza. e senza includere flag facoltativi, esegui questo comando:

gcloud compute reservations create RESERVATION_NAME \
    --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 per creare.

  • PROJECT_ID: l'ID del progetto in cui vuoi prenotare le risorse e in cui esiste il modello di istanza.

  • 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 l'istanza in cui si trova il modello. Se specifichi un modello di istanza regionale, puoi prenotare solo VM nella stessa regione della regione del modello.

  • INSTANCE_TEMPLATE_NAME: il nome di un modello istanza esistente. Se il modello di istanza specifica un tipo di macchina A3 o un criterio di posizionamento compatto, devi includere 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 per dieci VM nella zona us-central1-a specificando un modello di istanza globale, esegui questo comando:

gcloud compute reservations create my-reservation \
    --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 \
    --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
    --require-specific-reservation \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

  • Per consentire il consumo di una prenotazione di VM A2 o A3 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.

    gcloud beta compute reservations create RESERVATION_NAME \
    --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
    --reservation-sharing-policy=ALLOW_ALL \
    --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 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 \
    --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 nel formato di un timestamp RFC 3339, che deve essere il seguente: none YYYY-MM-DDTHH:MM:SSOFFSET

      Sostituisci quanto segue:

      • YYYY-MM-DD: una data formattata come quattro cifre anno, mese a due cifre e giorno del mese a due cifre, separati per 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 coordinato universale (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 determinato periodo di tempo, utilizza il metodo 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 \
    --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"

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

// Creates the reservation from given template in particular zone
func createReservation(w io.Writer, projectID, zone, reservationName, sourceTemplate string) error {
	// projectID := "your_project_id"
	// zone := "us-west3-a"
	// reservationName := "your_reservation_name"
	// template: 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()
	reservationsClient, err := compute.NewReservationsRESTClient(ctx)
	if err != nil {
		return err
	}
	defer reservationsClient.Close()

	req := &computepb.InsertReservationRequest{
		Project: projectID,
		ReservationResource: &computepb.Reservation{
			Name: proto.String(reservationName),
			Zone: proto.String(zone),
			SpecificReservation: &computepb.AllocationSpecificSKUReservation{
				Count:                  proto.Int64(2),
				SourceInstanceTemplate: proto.String(sourceTemplate),
			},
		},
		Zone: zone,
	}

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

	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 java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateReservationForInstanceTemplate {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the zone in which you want to create the reservation.
    String zone = "us-central1-a";
    // Name of the reservation you want to create.
    String reservationName = "YOUR_RESERVATION_NAME";
    // The number of virtual machines you want to create.
    int numberOfVms = 3;
    // The URI of the instance template with GLOBAL location
    // to be used for creating the reservation.
    String instanceTemplateUri =
        "projects/YOUR_PROJECT_ID/global/instanceTemplates/YOUR_INSTANCE_TEMPLATE_NAME";

    // The URI of the instance template with REGIONAL location
    // to be used for creating the reservation. For us-central1 region in this case.
    // String instanceTemplateUri =
    // "projects/YOUR_PROJECT_ID/regions/us-central1/instanceTemplates/YOUR_INSTANCE_TEMPLATE_NAME"

    createReservationForInstanceTemplate(
        projectId, reservationName, instanceTemplateUri, numberOfVms, zone);
  }

  // Creates a reservation in a project for the instance template.
  public static void createReservationForInstanceTemplate(
      String projectId, String reservationName, String instanceTemplateUri,
      int numberOfVms, String zone)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (ReservationsClient reservationsClient = ReservationsClient.create()) {

      // Create the reservation.
      Reservation reservation =
          Reservation.newBuilder()
              .setName(reservationName)
              .setZone(zone)
              .setSpecificReservation(
                  AllocationSpecificSKUReservation.newBuilder()
                      // Set the number of instances
                      .setCount(numberOfVms)
                      // Set the instance template to be used for creating the reservation.
                      .setSourceInstanceTemplate(instanceTemplateUri)
                      .build())
              .build();

      // Wait for the create reservation operation to complete.
      Operation response =
          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;

// Instantiate a reservationsClient
const reservationsClient = new computeLib.ReservationsClient();
// Instantiate a zoneOperationsClient
const zoneOperationsClient = new computeLib.ZoneOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The ID of the project where you want to 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.
// reservationName = 'reservation-01';
// The number of VMs to reserve.
const vmsNumber = 3;

/**
 * The name of an existing instance template.
 * TODO(developer): Uncomment and update instanceTemplateName before running the sample.
 */
// const instanceTemplateName = 'pernament-region-template-name';

/**
 * // The location of the instance template.
 * TODO(developer): Uncomment the `location` variable depending on which template you want to use.
 */

// The location for a regional instance template: regions/{region}. Replace region with the region where the instance template is located.
// If you specify a regional instance template, then you can only reserve VMs within the same region as the template's region.
// const location = `regions/${zone.slice(0, -2)}`;

// The location for a global instance template.
// const location = 'global';

async function callCreateComputeReservationInstanceTemplate() {
  // 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 a reservation.
  const reservation = new compute.Reservation({
    name: reservationName,
    specificReservation,
    // To specify that only VMs that specifically target this reservation can consume it,
    // set specificReservationRequired field to true.
    specificReservationRequired: true,
  });

  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.`);
}

await callCreateComputeReservationInstanceTemplate();

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_reservation_from_template(
    project_id: str, reservation_name: str, template: str
) -> compute_v1.Reservation:
    """
    Create a new reservation based on an existing template.

    Args:
        project_id: project ID or project number of the Cloud project you use.
        reservation_name: the name of new reservation.
        template: 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

    Returns:
        Reservation object that represents the new reservation.
    """

    reservations_client = compute_v1.ReservationsClient()
    request = compute_v1.InsertReservationRequest()
    request.project = project_id
    request.zone = "us-central1-a"

    specific_reservation = compute_v1.AllocationSpecificSKUReservation()
    specific_reservation.count = 1
    specific_reservation.source_instance_template = template

    reservation = compute_v1.Reservation()
    reservation.name = reservation_name
    reservation.specific_reservation = specific_reservation

    request.reservation_resource = reservation
    operation = reservations_client.insert(request)
    wait_for_extended_operation(operation, "Reservation creation")

    return reservations_client.get(
        project=project_id, zone="us-central1-a", reservation=reservation_name
    )

REST

Per creare una prenotazione per un singolo progetto, invia una richiesta POST al metodo reservations.insert.

Creare una prenotazione per un singolo progetto specificando un modello di istanza. e senza includere flag facoltativi, effettua la seguente richiesta POST:

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

{
  "name": "RESERVATION_NAME",
  "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 e dove è presente il modello di istanza.

  • ZONE: la zona in cui prenotare le risorse.

  • RESERVATION_NAME: il nome della prenotazione da creare.

  • 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 l'istanza in cui si trova il modello. Se specifichi un modello di istanza regionale, puoi prenotare solo VM nella stessa regione della regione del modello.

  • INSTANCE_TEMPLATE_NAME: il nome di un modello istanza esistente. Se il modello di istanza specifica un tipo di macchina A3 o un criterio di posizionamento compatto, devi includere il campo specificReservationRequired nel corpo della richiesta e impostarlo su true. Ciò indica che solo le VM che hanno come target questa prenotazione possono consumarla. Per ulteriori informazioni, vedi Utilizza 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, effettua la seguente richiesta POST:

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

{
  "name": "my-reservation",
  "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 scelgono specificamente come target questa prenotazione possono utilizzalo, includi il campo specificReservationRequired nella corpo della richiesta e impostare il campo su true.

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

{
  "name": "RESERVATION_NAME",
  "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 A2 o A3 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"
  },
  "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 un'ora specifiche, crea un POST richiesta alla Metodo beta.reservations.insert. Nel corpo della richiesta, includi il campo deleteAtTime.

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

{
  "deleteAtTime": "DELETE_AT_TIME",
  "name": "RESERVATION_NAME",
  "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 quattro cifre anno, mese a due cifre e giorno del mese a due cifre, separati per trattini (-).

      • HH:MM:SS: un'ora nel formato a due cifre utilizzando un orario di 24 ore, minuti a 2 cifre e secondi a 2 cifre, separate dai 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, invia una POST richiesta al metodo beta.reservations.insert. Nel corpo della richiesta, includi il campo deleteAfterDuration.

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

{
  "deleteAfterDuration": {
    "seconds": "DELETE_AFTER_DURATION"
  },
  "name": "RESERVATION_NAME",
  "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 solo in base a una VM esistente nella stessa zona di la VM.

Dopo aver creato la prenotazione, puoi utilizzarla creando VM con che corrispondono alla VM di riferimento. A tal fine, puoi eseguire una delle seguenti operazioni:

Per creare una prenotazione per un singolo progetto che utilizza le proprietà di una VM esistente:

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

    Vai a Prenotazioni

  2. Fai clic su 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, fai clic su Locale, se non è già selezionato.

  6. Nella sezione Usa con istanza VM, seleziona una delle seguenti opzioni opzioni:

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

    • Per utilizzare le risorse di questa prenotazione solo durante la creazione delle corrispondenze VM che scelgono specificamente come target questa prenotazione per nome, seleziona Seleziona una prenotazione specifica.

  7. In Numero di istanze VM, inserisci il numero di VM che vuoi di riserva.

  8. Nella sezione Configurazione macchina:

    1. Seleziona Utilizza VM esistente.

    2. In VM esistente, seleziona la VM che vuoi utilizzare per le proprietà. per creare la prenotazione.

  9. (Facoltativo) Per specificare un criterio di posizionamento compatto per una prenotazione che soddisfi i requisiti, nella sezione Criterio di posizionamento del gruppo, fai clic sull'elenco Seleziona o crea un criterio di posizionamento del gruppo e poi segui uno dei seguenti passaggi:

    • Per creare un criterio di posizionamento compatto da specificare in questa prenotazione, procedi nel seguente modo: le seguenti:

      1. Fai clic su Crea criterio di posizionamento del gruppo.

        Viene visualizzato il riquadro Crea un criterio di posizionamento del gruppo.

      2. In Nome della norma, inserisci un nome per la norma.

      3. Fai clic su Crea.

        La creazione del criterio di posizionamento compatto potrebbe richiedere alcuni secondi completato.

    • Altrimenti, seleziona un criterio di posizionamento compatto esistente.

  10. Nella sezione Eliminazione automatica, puoi attivare l'opzione di eliminazione automatica per consentire Compute Engine elimina automaticamente la prenotazione a livello di data e ora. Eliminare automaticamente le prenotazioni può essere utile per evitare addebiti inutili quando smetti di utilizzare la prenotazione.

  11. Per creare la prenotazione, fai clic su Crea.

    Viene visualizzata la pagina Prenotazioni. La creazione della prenotazione potrebbe richiedere fino a minuto per completare l'operazione.

Specifica direttamente le proprietà

Per creare una prenotazione per un singolo progetto specificando direttamente le proprietà, seleziona una delle seguenti opzioni:

Console

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

    Vai a Prenotazioni

  2. Nella scheda Prenotazioni on demand (impostazione predefinita), fai clic su 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, fai clic su Locale, se non è già selezionato. selezionato.

  6. (Facoltativo) Per consentire l'utilizzo di una prenotazione di VM A2 o A3 da parte di job di addestramento personalizzato o 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 VM corrispondenti di consumare automaticamente questa prenotazione, Seleziona Utilizza prenotazione automaticamente, se non è già selezionato selezionato.

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

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

  9. 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 un'opzione famiglia, serie e tipo di macchina.

    2. (Facoltativo) Per specificare una piattaforma CPU minima o collegare GPU a N1 VM:

      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. In Tipo di interfaccia, seleziona l'interfaccia per l'SSD locale i dischi permanenti.

    4. (Facoltativo) Per specificare un criterio di posizionamento compatto per una prenotazione che soddisfi i requisiti, fai clic sull'elenco Seleziona o crea un criterio di posizionamento del gruppo e poi svolgi una delle seguenti operazioni:

      • Per creare un criterio di posizionamento compatto da specificare in questo per effettuare una prenotazione, segui questi passaggi:

        1. Fai clic su Crea criterio di posizionamento del gruppo.

          Viene visualizzato il riquadro Crea un criterio di posizionamento del gruppo.

        2. In Nome della norma, inserisci un nome per la norma.

        3. Fai clic su Crea.

          La creazione del criterio di posizionamento compatto potrebbe richiedere alcuni secondi per completare l'operazione.

      • In caso contrario, seleziona un criterio di posizionamento compatto esistente.

  10. (Facoltativo) Per specificare un criterio di posizionamento compatto per una prenotazione che soddisfa i requisiti requirements, Nella sezione Criterio di posizionamento del gruppo, fai clic sull'icona Seleziona o crea un elenco di criteri di posizionamento del gruppo ed esegui una delle le seguenti:

    • Per creare un criterio di posizionamento compatto da specificare in questa prenotazione, segui questi passaggi:

      1. Fai clic su Crea criterio di posizionamento del gruppo.

        Viene visualizzato il riquadro Crea un criterio di posizionamento del gruppo.

      2. In Nome della norma, inserisci un nome per la norma.

      3. Fai clic su Crea.

        La creazione del criterio di posizionamento compatto potrebbe richiedere alcuni secondi per completare l'operazione.

    • In caso contrario, seleziona un criterio di posizionamento compatto esistente.

  11. Nella sezione Eliminazione automatica, puoi attivare l'opzione di eliminazione automatica per lascia che Compute Engine elimini automaticamente la prenotazione una data e un'ora specifiche. L'eliminazione automatica delle prenotazioni può essere è utile per evitare addebiti inutili quando smetti di utilizzare prenotazione.

  12. Per creare la prenotazione, fai clic su Crea.

    Si apre la pagina Prenotazioni. Creazione della prenotazione per un singolo progetto l'operazione potrebbe richiedere fino a un minuto.

gcloud

Per creare una prenotazione per un singolo progetto, utilizza il Comando gcloud compute reservations create.

Per creare una prenotazione per un singolo progetto specificando direttamente le proprietà e senza includere flag facoltativi, esegui questo comando:

gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

Sostituisci quanto segue:

  • RESERVATION_NAME: il nome della prenotazione per 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.

  • 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 ognuna con un tipo di macchina predefinita N2 con 4 vCPU, seguente comando:

gcloud compute reservations create my-reservation \
    --machine-type=n2-standard-4 \
    --vm-count=10 \
    --zone=us-central1-a

Facoltativamente, 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 \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

    Sostituisci quanto segue:

  • 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, 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 \
    --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 disco SCSI: scsi

    Assicurati che il tipo di macchina specificato per le VM prenotate supporta le interfacce del disco scelte. In caso contrario, la creazione della prenotazione non andrà a buon fine. Per ulteriori informazioni, scopri come scegli 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" \
    --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 scelgono specificamente come target questa prenotazione possono consumarlo, includere --require-specific-reservation flag.

    gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --require-specific-reservation \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

  • Per specificare un criterio di posizionamento compatto per una latenza di rete inferiore tra le VM, includi il flag --resource-policies=policy.

    gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --resource-policies=policy=COMPACT_PLACEMENT_POLICY_NAME \
    --require-specific-reservation \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

    Sostituisci COMPACT_PLACEMENT_POLICY_NAME con il nome di un criterio di posizionamento compatto esistente. Inoltre, per evitare errori quando crei una prenotazione per un singolo progetto che specifica un criterio di posizionamento compatto, assicurati di specificare quanto segue:

    • Un tipo di macchina supportato e il numero massimo di VM per i criteri di posizionamento compatto.

    • Una zona all'interno della regione in cui è individuarlo.

    • Il flag --require-specific-reservation. Ciò indica che solo le VM che hanno come target specifico la prenotazione possono utilizzarla.

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

    gcloud beta compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --reservation-sharing-policy=ALLOW_ALL \
    --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 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 \
    --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 quattro cifre anno, mese a due cifre e giorno del mese a due cifre, separati per 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 determinato periodo di tempo, utilizza il metodo 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 \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

      Sostituisci DELETE_AFTER_DURATION con una durata tra 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"

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

// Creates the reservation with accelerated image
func createBaseReservation(w io.Writer, projectID, zone, reservationName string) error {
	// projectID := "your_project_id"
	// zone := "us-west3-a"
	// reservationName := "your_reservation_name"

	ctx := context.Background()
	reservationsClient, err := compute.NewReservationsRESTClient(ctx)
	if err != nil {
		return err
	}
	defer reservationsClient.Close()

	// Creating reservation based on direct properties
	req := &computepb.InsertReservationRequest{
		Project: projectID,
		ReservationResource: &computepb.Reservation{
			Name: proto.String(reservationName),
			Zone: proto.String(zone),
			SpecificReservation: &computepb.AllocationSpecificSKUReservation{
				Count: proto.Int64(2),
				// Properties, which allows customising instances
				InstanceProperties: &computepb.AllocationSpecificSKUAllocationReservedInstanceProperties{
					// Attaching GPUs to the reserved VMs
					// Read more: https://cloud.google.com/compute/docs/gpus#n1-gpus
					GuestAccelerators: []*computepb.AcceleratorConfig{
						{
							AcceleratorCount: proto.Int32(1),
							AcceleratorType:  proto.String("nvidia-tesla-t4"),
						},
					},
					// Including local SSD disks
					LocalSsds: []*computepb.AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk{
						{
							DiskSizeGb: proto.Int64(375),
							Interface:  proto.String("NVME"),
						},
					},
					MachineType: proto.String("n1-standard-2"),
					// Specifying minimum CPU platform
					// Read more: https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform
					MinCpuPlatform: proto.String("Intel Skylake"),
				},
			},
		},
		Zone: zone,
	}

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

	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 

public class CreateReservation {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the zone in which you want to create the disk.
    String zone = "us-central1-a";
    // Name of the reservation you want to create.
    String reservationName = "YOUR_RESERVATION_NAME";
    // Number of instances in the reservation.
    int numberOfVms = 3;

    createReservation(projectId, reservationName, numberOfVms, zone);
  }

  // Creates reservation with optional flags
  public static void createReservation(
      String projectId, String reservationName, int numberOfVms, String zone)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (ReservationsClient reservationsClient = ReservationsClient.create()) {

      // Create the reservation with optional properties:
      // Machine type of the instances in the reservation.
      String machineType = "n1-standard-2";
      // Number of accelerators to be attached to the instances in the reservation.
      int numberOfAccelerators = 1;
      // Accelerator type to be attached to the instances in the reservation.
      String acceleratorType = "nvidia-tesla-t4";
      // Minimum CPU platform to be attached to the instances in the reservation.
      String minCpuPlatform = "Intel Skylake";
      // Local SSD size in GB to be attached to the instances in the reservation.
      int localSsdSize = 375;
      // Local SSD interfaces to be attached to the instances in the reservation.
      String localSsdInterface1 = "NVME";
      String localSsdInterface2 = "SCSI";
      boolean specificReservationRequired = true;

      Reservation reservation =
          Reservation.newBuilder()
              .setName(reservationName)
              .setZone(zone)
              .setSpecificReservationRequired(specificReservationRequired)
              .setSpecificReservation(
                  AllocationSpecificSKUReservation.newBuilder()
                      // Set the number of instances
                      .setCount(numberOfVms)
                      // Set instance properties
                      .setInstanceProperties(
                          AllocationSpecificSKUAllocationReservedInstanceProperties.newBuilder()
                              .setMachineType(machineType)
                              .setMinCpuPlatform(minCpuPlatform)
                              .addGuestAccelerators(
                                  AcceleratorConfig.newBuilder()
                                      .setAcceleratorCount(numberOfAccelerators)
                                      .setAcceleratorType(acceleratorType)
                                      .build())
                              .addLocalSsds(
                            AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk
                                      .newBuilder()
                                      .setDiskSizeGb(localSsdSize)
                                      .setInterface(localSsdInterface1)
                                      .build())
                              .addLocalSsds(
                            AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk
                                      .newBuilder()
                                      .setDiskSizeGb(localSsdSize)
                                      .setInterface(localSsdInterface2)
                                      .build())
                              .build())
                      .build())
              .build();

      // Wait for the create reservation operation to complete.
      Operation response =
          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;

// Instantiate a reservationsClient
const reservationsClient = new computeLib.ReservationsClient();
// Instantiate a zoneOperationsClient
const zoneOperationsClient = new computeLib.ZoneOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The ID of the project where you want to reserve resources.
const projectId = await reservationsClient.getProjectId();
// The zone in which to reserve resources.
const zone = 'us-central1-a';
// The name of the reservation to create.
// reservationName = 'reservation-01';
// The number of VMs to reserve.
const vmsNumber = 3;
// Machine type to use for each VM.
const machineType = 'n1-standard-4';

async function callCreateComputeReservationFromProperties() {
  // Create specific reservation for 3 VMs that each use an N1 predefined machine type with 4 vCPUs.
  const specificReservation = new compute.AllocationSpecificSKUReservation({
    count: vmsNumber,
    instanceProperties: {
      machineType,
      // To have the reserved VMs use a specific minimum CPU platform instead of the zone's default CPU platform.
      minCpuPlatform: 'Intel Skylake',
      // If you want to attach GPUs to your reserved N1 VMs, update and uncomment guestAccelerators if needed.
      // guestAccelerators: [
      //   {
      //     // The number of GPUs to add per reserved VM.
      //     acceleratorCount: 1,
      //     // Supported GPU model for N1 VMs. Ensure that your chosen GPU model is available in the zone,
      //     // where you want to reserve resources.
      //     acceleratorType: 'nvidia-tesla-t4',
      //   },
      // ],
      // If you want to add local SSD disks to each reserved VM, update and uncomment localSsds if needed.
      // You can specify up to 24 Local SSD disks. Each Local SSD disk is 375 GB.
      // localSsds: [
      //   {
      //     diskSizeGb: 375,
      //     // The type of interface you want each Local SSD disk to use. Specify one of the following values: NVME or SCSI.
      //     // Make sure that the machine type you specify for the reserved VMs supports the chosen disk interfaces.
      //     interface: 'NVME',
      //   },
      // ],
    },
  });

  // Create a reservation.
  const reservation = new compute.Reservation({
    name: reservationName,
    zone,
    specificReservation,
    // To specify that only VMs that specifically target this reservation can consume it,
    // set specificReservationRequired field to true.
    specificReservationRequired: true,
  });

  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.`);
}

await callCreateComputeReservationFromProperties();

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_reservation(
    project_id: str,
    zone: str = "us-central1-a",
    reservation_name="your-reservation-name",
) -> 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.
    Returns:
        Reservation object that represents the new reservation.
    """

    instance_properties = compute_v1.AllocationSpecificSKUAllocationReservedInstanceProperties(
        machine_type="n1-standard-1",
        # Optional. Specifies the minimum CPU platform for the VM instance.
        min_cpu_platform="Intel Ivy Bridge",
        # Optional. Specifies amount of local ssd to reserve with each instance.
        local_ssds=[
            compute_v1.AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk(
                disk_size_gb=375, interface="NVME"
            ),
            compute_v1.AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk(
                disk_size_gb=375, interface="SCSI"
            ),
        ],
        # Optional. Specifies the GPUs allocated to each instance.
        # guest_accelerators=[
        #     compute_v1.AcceleratorConfig(
        #         accelerator_count=1, accelerator_type="nvidia-tesla-t4"
        #     )
        # ],
    )

    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,
        ),
        specific_reservation_required=True,
    )

    # 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
    )

    print("Name: ", reservation.name)
    print("STATUS: ", reservation.status)
    print(reservation.specific_reservation)
    # Example response:
    # Name:  your-reservation-name
    # STATUS:  READY
    # count: 3
    # instance_properties {
    #   machine_type: "n1-standard-1"
    #   local_ssds {
    #     disk_size_gb: 375
    #     interface: "NVME"
    #   }
    # ...

    return reservation

Terraform

Per creare una prenotazione per un singolo progetto, utilizza la google_compute_reservation risorsa Terraform.

Ad esempio, per creare una prenotazione per un singolo progetto per una con 2 vCPU, utilizza la risorsa seguente:


resource "google_compute_reservation" "default" {
  name = "gce-reservation-local"
  zone = "us-central1-a"

  /**
   * To specify a single-project reservation, omit the share_settings block
   * (default) or set the share_type field to LOCAL.
   */
  share_settings {
    share_type = "LOCAL"
  }

  specific_reservation {
    count = 1
    instance_properties {
      machine_type = "n2-standard-2"
    }
  }

  /**
   * To let VMs with affinity for any reservation consume this reservation, omit
   * the specific_reservation_required field (default) or set it to false.
   */
  specific_reservation_required = false
}

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

REST

Per creare una prenotazione per un singolo progetto, invia una richiesta POST al metodo reservations.insert.

Per creare una prenotazione per un singolo progetto specificando direttamente le proprietà e senza includere campi facoltativi, imposta i seguenti POST richiesta:

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

{
  "name": "RESERVATION_NAME",
  "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.

  • 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 Le VM che hanno come target specifico la prenotazione possono consumarla. Per maggiori informazioni, consulta Utilizzare le VM da una prenotazione specifica.

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, effettua la seguente richiesta POST:

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

{
  "name": "my-reservation",
  "specificReservation": {
    "count": "10",
    "instanceProperties": {
      "machineType": "n2-standard-4",
    }
  }
}

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

  • Per collegare le GPU alle VM N1 prenotate, includi guestAccelerators nel corpo della richiesta.

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

{
  "name": "RESERVATION_NAME",
  "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 riservata.

    • 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 per ogni VM prenotata, includi il campo localSsds nel corpo della richiesta. Puoi specificare fino a 24 dischi SSD locali. Ogni disco SSD locale 375 GB.

    Ad esempio, per specificare due dischi SSD locali durante la creazione di una prenotazione, effettua una richiesta nel seguente modo:

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

{
  "name": "RESERVATION_NAME",
  "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 desiderato Disco SSD locale da utilizzare. Specifica uno dei seguenti valori:

    • Interfacce dei dischi NVME: NVME

    • Interfacce disco SCSI: SCSI

    Assicurati che il tipo di macchina specificato per le VM prenotate supporta le interfacce del disco scelte. In caso contrario, la creazione della prenotazione non riesce. Per ulteriori informazioni, scopri come scegli 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.

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

{
  "name": "RESERVATION_NAME",
  "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 nella zona in cui ti trovi sia disponibile una piattaforma CPU prenotare risorse, visualizza le piattaforme CPU disponibili per zona.

  • Per specificare un criterio di posizionamento compatto per ridurre la latenza di rete tra le VM prenotate, includi resourcePolicies nel corpo della richiesta.

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

{
  "name": "RESERVATION_NAME",
  "resourcePolicies": {
    "policy" : "projects/example-project/regions/REGION/resourcePolicies/COMPACT_PLACEMENT_POLICY_NAME"
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  },
  "specificReservationRequired": true
}

    Sostituisci quanto segue:

    • REGION: la regione in cui si trova il criterio di posizionamento compatto. Puoi creare la prenotazione solo all'interno della regione del criterio di posizionamento.

    • COMPACT_PLACEMENT_POLICY_NAME: il nome di un criterio di posizionamento compatto esistente.

    Inoltre, per evitare errori durante la creazione di una prenotazione per un singolo progetto che specifica un criterio di posizionamento compatto, assicurati di specificare seguenti:

    • R tipo di macchina supportato per i criteri di posizionamento compatto.

    • Il campo specificReservationRequired impostato su true. Ciò indica che solo le VM che hanno come target specifico questa prenotazione possono utilizzarla.

  • Per specificare che solo le VM che scelgono specificamente come target questa prenotazione possono utilizzalo, includi il campo specificReservationRequired nella corpo della richiesta e impostare il campo su true.

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

{
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  },
  "specificReservationRequired": true
}

  • Per consentire l'utilizzo di una prenotazione di VM A2 o A3 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"
  },
  "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 un'ora specifiche, effettua una POST richiesta alla Metodo beta.reservations.insert. Nel corpo della richiesta, includi il campo deleteAtTime.

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

{
  "deleteAtTime": "DELETE_AT_TIME",
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}

      Sostituisci DELETE_AT_TIME con una data e un'ora formattato come Timestamp RFC 3339, che indica deve essere:

      YYYY-MM-DDTHH:MM:SSOFFSET

      Sostituisci quanto segue:

      • YYYY-MM-DD: una data formattata come quattro cifre anno, mese a due cifre e giorno del mese a due cifre, separati per 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 coordinato universale (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, invia una POST richiesta al metodo beta.reservations.insert. Nel corpo della richiesta, includi il campo deleteAfterDuration.

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

{
  "deleteAfterDuration": {
    "seconds": "DELETE_AFTER_DURATION"
  },
  "name": "RESERVATION_NAME",
  "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 relativi alla creazione delle prenotazioni.

Passaggi successivi