Créer une réservation pour un seul projet

Ce document explique comment créer une réservation à projet unique qui ne peut être utilisée que par des instances de machine virtuelle (VM) dans le même projet. Pour en savoir plus, consultez la section Réservations de ressources zonales Compute Engine.

Pour découvrir d'autres méthodes de création de réservations, consultez les pages suivantes :

  • Si vous avez des engagements d'un ou de trois ans dans le projet en cours, vos ressources réservées reçoivent automatiquement les remises sur engagement d'utilisation applicables. Vous pouvez également créer et associer une réservation à un engagement lorsque vous souscrivez cet engagement. Pour en savoir plus, consultez la section Associer des réservations à des engagements.

  • Pour créer une réservation pouvant être utilisée par plusieurs projets, consultez la section Créer une réservation partagée.

Avant de commencer

  • Consultez les exigences et restrictions applicables aux réservations.
  • Si ce n'est pas déjà fait, configurez l'authentification. L'authentification est le processus permettant de valider votre identité pour accéder aux services et aux API Google Cloud. Pour exécuter du code ou des exemples depuis un environnement de développement local, vous pouvez vous authentifier auprès de Compute Engine en sélectionnant l'une des options suivantes:

    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

      Pour utiliser les exemples Terraform de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

      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.

      Pour en savoir plus, consultez Set up authentication for a local development environment.

      REST

      Pour utiliser les exemples d'API REST de cette page dans un environnement de développement local, vous devez utiliser les identifiants que vous fournissez à gcloud CLI.

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

        gcloud init

      Pour en savoir plus, consultez la section S'authentifier pour utiliser REST dans la documentation sur l'authentification Google Cloud.

Rôles requis

Pour obtenir les autorisations nécessaires pour créer des réservations à projet unique, demandez à votre administrateur de vous accorder le rôle IAM Administrateur Compute (roles/compute.admin) sur le projet. Pour en savoir plus sur l'attribution de rôles, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations.

Ce rôle prédéfini contient les autorisations requises pour créer des réservations à projet unique. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour créer des réservations à projet unique :

  • compute.reservations.create sur le projet
  • Pour spécifier un modèle d'instance : compute.instanceTemplates.useReadOnly sur le modèle d'instance

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis.

Créer une réservation à projet unique

Pour utiliser une réservation, une VM doit avoir des propriétés qui correspondent exactement à cette réservation. Pour spécifier les propriétés des VM que vous souhaitez réserver, accédez à l'une des sections suivantes de ce document :

  • Option recommandée : spécifier un modèle d'instance

    Cette section explique comment utiliser un modèle d'instance pour définir les propriétés d'une réservation. En utilisant un modèle d'instance, vous pouvez définir les propriétés d'une réservation et les VM pouvant utiliser la réservation au même endroit.

  • Spécifier une VM existante

    Cette section explique comment utiliser une VM existante pour définir les propriétés d'une réservation. En utilisant les propriétés d'une VM existante, vous pouvez utiliser la réservation en créant des VM dont les propriétés correspondent à la VM de référence.

  • Spécifier les propriétés directement

    Cette section explique comment définir directement les propriétés d'une réservation. Cette méthode nécessite de vous assurer manuellement que les propriétés de vos VM et de vos réservations correspondent exactement. Toute propriété non concordante empêche l'utilisation.

Par défaut, une réservation peut être automatiquement utilisée par toutes les VM dont les propriétés correspondent. Si vous souhaitez contrôler l'utilisation des réservations, effectuez une ou plusieurs des opérations suivantes :

En outre, vous pouvez spécifier une stratégie d'emplacement compacte lors de la création d'une réservation à projet unique. Une stratégie d'emplacement compact spécifie que les VM doivent être situées le plus près possible les unes des autres pour réduire la latence du réseau.

Spécifier un modèle d'instance

Pour éviter les erreurs lors de la création d'une réservation en spécifiant un modèle d'instance, vérifiez les points suivants:

  • Créez votre réservation dans la même région et la même zone que les ressources du modèle d'instance. Toutes les ressources régionales ou zonales spécifiées dans un modèle d'instance (telles qu'un type de machine ou un volume de disque persistant) limitent l'utilisation du modèle aux emplacements où ces ressources existent. Par exemple, si votre modèle d'instance spécifie un volume de disque persistant existant dans la zone us-central1-a, vous ne pouvez créer votre réservation que dans la même zone. Pour vérifier si un modèle existant spécifie des ressources qui l'associent à une région ou à une zone spécifique, affichez les détails du modèle d'instance et recherchez des références à des ressources régionales ou zonales qu'il contient.

  • Si le modèle d'instance spécifie une stratégie d'emplacement compact, assurez-vous qu'il spécifie également un type de machine compatible pour les stratégies d'emplacement compact. Sinon, la création de la réservation échoue.

Pour créer une réservation à projet unique en spécifiant un modèle d'instance, sélectionnez l'une des options suivantes:

Console

  1. Dans la console Google Cloud, accédez à la page Réservations.

    Accéder à la page "Réservations"

  2. Dans l'onglet Réservations à la demande (par défaut), cliquez sur Créer une réservation.

    La page Créer une réservation s'affiche.

  3. Dans le champ Name, saisissez le nom de votre réservation.

  4. Pour les champs Région et Zone, sélectionnez l'emplacement dans lequel vous souhaitez réserver des ressources.

  5. Dans la section Type de partage, sélectionnez Local si ce n'est pas déjà fait.

  6. Facultatif: Pour permettre à une réservation de VM avec GPU d'être utilisée par des tâches d'entraînement personnalisées ou des tâches de prédiction dans Vertex AI, sélectionnez Partager la réservation dans la section Services Google Cloud.

  7. Dans la section Utiliser avec une instance de VM, sélectionnez l'une des options suivantes :

    • Pour autoriser les VM correspondantes à utiliser automatiquement cette réservation, sélectionnez l'option Utiliser automatiquement une réservation si elle n'est pas déjà sélectionnée.

    • Pour n'utiliser les ressources de cette réservation que lors de la création de VM correspondantes qui ciblent spécifiquement cette réservation par son nom, cliquez sur Sélectionner une réservation spécifique.

  8. Pour Nombre d'instances de VM, saisissez le nombre de VM que vous souhaitez réserver.

  9. Dans la section Configuration de la machine, procédez comme suit :

    1. Pour spécifier les propriétés de vos VM à partir d'un modèle d'instance existant, sélectionnez Utiliser un modèle d'instance.

    2. Dans le champ Modèle d'instance, sélectionnez le modèle d'instance de votre choix. Si vous sélectionnez un modèle d'instance régional, vous ne pouvez réserver que des ressources dans la région du modèle d'instance.

  10. Dans la section Suppression automatique, vous pouvez activer l'option de suppression automatique pour permettre à Compute Engine de supprimer automatiquement la réservation à une date et une heure spécifiques. La suppression automatique des réservations peut vous permettre d'éviter des frais inutiles lorsque vous arrêtez de consommer la réservation.

  11. Pour créer la réservation, cliquez sur Créer.

    La page Réservations s'affiche. La création de la réservation pour un projet unique peut prendre jusqu'à une minute.

gcloud

Pour créer une réservation à projet unique, utilisez la commande gcloud compute reservations create.

Pour créer une réservation à projet unique en spécifiant un modèle d'instance et sans option facultative, exécutez la commande suivante:

gcloud compute reservations create RESERVATION_NAME \
    --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

Remplacez les éléments suivants :

  • RESERVATION_NAME : le nom de la réservation à créer.

  • PROJECT_ID : l'ID du projet dans lequel vous souhaitez réserver des ressources et où le modèle d'instance existe.

  • LOCATION : emplacement du modèle d'instance. Spécifiez une des valeurs suivantes :

    • Pour un modèle d'instance global : global

    • Pour un modèle d'instance régional : regions/REGION. Remplacez REGION par la région dans laquelle se trouve le modèle d'instance. Si vous sélectionnez un modèle d'instance régional, vous ne pouvez réserver que des ressources situées dans la même région que celle du modèle.

  • INSTANCE_TEMPLATE_NAME : nom d'un modèle d'instance existant. Si le modèle d'instance spécifie un type de machine A3 ou une stratégie d'emplacement compact, vous devez inclure l'option --require-specific-reservation. Cela indique que seules les VM qui ciblent spécifiquement cette réservation peuvent l'utiliser. Pour en savoir plus, consultez la section Consommer des VM d'une réservation spécifique.

  • NUMBER_OF_VMS : nombre de VM à réserver.

  • ZONE : la zone dans laquelle vous devez réserver des ressources.

Par exemple, pour créer une réservation pour dix VM dans la zone us-central1-a en spécifiant un modèle d'instance global, exécutez la commande suivante :

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

Vous pouvez éventuellement effectuer une ou plusieurs des opérations suivantes :

  • Pour spécifier que seules les VM qui ciblent spécifiquement cette réservation peuvent l'utiliser, incluez l'option --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

  • Pour permettre à une réservation de VM avec GPU d'être utilisée par des tâches d'entraînement personnalisées ou des tâches de prédiction dans Vertex AI, exécutez la commande gcloud beta compute reservations create avec l'option --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

  • Pour permettre à Compute Engine de supprimer automatiquement la réservation, sélectionnez l'une des méthodes suivantes :

    • Pour supprimer la réservation à une date et une heure spécifiques, utilisez la commande gcloud beta compute reservations create avec l'option --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

      Remplacez DELETE_AT_TIME par une date et une heure au format de code temporel RFC 3339 comme suit : none YYYY-MM-DDTHH:MM:SSOFFSET

      Remplacez les éléments suivants :

      • YYYY-MM-DD : date respectant la syntaxe année à 4 chiffres, mois à 2 chiffres et jour du mois à 2 chiffres, séparés par des traits d'union (-).

      • HH:MM:SS : heure respectant la syntaxe heures à 2 chiffres sur 24 heures, minutes à 2 chiffres et secondes à 2 chiffres, séparés par des signes deux-points (:).

      • OFFSET : fuseau horaire mis en forme en tant que décalage par rapport au temps universel coordonné (UTC). Par exemple, pour utiliser l'heure normale du Pacifique (PST), spécifiez -08:00. Sinon, pour n'utiliser aucun décalage, spécifiez Z.

    • Pour supprimer la réservation après une certaine durée, exécutez la commande gcloud beta compute reservations create avec l'option --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

      Remplacez DELETE_AFTER_DURATION par une durée en jours, heures, minutes ou secondes. Par exemple, spécifiez 30m pour 30 minutes ou 1d2h3m4s pour 1 jour, 2 heures, 3 minutes et 4 secondes.

Go 

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 Reservation 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()) {
      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();

      Operation response =
          reservationsClient.insertAsync(projectId, zone, reservation).get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        return null;
      }
      return reservationsClient.get(projectId, zone, reservationName);
    }
  }
}

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

Pour créer une réservation à projet unique, envoyez une requête POST à la méthode reservations.insert.

Pour créer une réservation à projet unique en spécifiant un modèle d'instance et sans option facultative, effectuez la requête POST suivante:

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

Remplacez les éléments suivants :

  • PROJECT_ID : l'ID du projet dans lequel vous souhaitez réserver des ressources et où le modèle d'instance existe.

  • ZONE : la zone dans laquelle vous devez réserver des ressources.

  • RESERVATION_NAME : le nom de la réservation à créer.

  • NUMBER_OF_VMS : nombre de VM à réserver.

  • LOCATION : emplacement du modèle d'instance. Spécifiez une des valeurs suivantes :

    • Pour un modèle d'instance global : global

    • Pour un modèle d'instance régional : regions/REGION. Remplacez REGION par la région dans laquelle se trouve le modèle d'instance. Si vous sélectionnez un modèle d'instance régional, vous ne pouvez réserver que des ressources situées dans la même région que celle du modèle.

  • INSTANCE_TEMPLATE_NAME : nom d'un modèle d'instance existant. Si le modèle d'instance spécifie un type de machine A3 ou une stratégie d'emplacement compact, vous devez inclure le champ specificReservationRequired dans le corps de la requête et le définir sur true. Cela indique que seules les VM qui ciblent spécifiquement cette réservation peuvent l'utiliser. Pour en savoir plus, consultez la section Consommer des VM d'une réservation spécifique.

Par exemple, pour créer une réservation pour dix VM dans la zone us-central1-a en spécifiant un modèle d'instance global, effectuez la requête POST suivante :

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

Vous pouvez éventuellement effectuer une ou plusieurs des opérations suivantes :

  • Pour spécifier que seules les VM qui ciblent spécifiquement cette réservation peuvent l'utiliser, incluez le champ specificReservationRequired dans le corps de la requête et définissez-le sur 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
}

  • Pour permettre à une réservation de VM GPU d'être utilisée par des tâches d'entraînement personnalisées ou des tâches de prédiction dans Vertex AI, envoyez une requête POST à la méthode beta.reservations.insert. Dans le corps de la requête, incluez le champ serviceShareType et définissez-le sur 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"
  }
}

  • Pour permettre à Compute Engine de supprimer automatiquement la réservation, sélectionnez l'une des méthodes suivantes :

    • Pour supprimer la réservation à une date et une heure spécifiques, envoyez une requête POST à la méthode beta.reservations.insert. Dans le corps de la requête, incluez le champ 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"
  }
}

      Remplacez DELETE_AT_TIME par une date et une heure au format de code temporel RFC 3339 comme suit :

      YYYY-MM-DDTHH:MM:SSOFFSET

      Remplacez les éléments suivants :

      • YYYY-MM-DD : date respectant la syntaxe année à 4 chiffres, mois à 2 chiffres et jour du mois à 2 chiffres, séparés par des traits d'union (-).

      • HH:MM:SS : heure respectant la syntaxe heures à 2 chiffres sur 24 heures, minutes à 2 chiffres et secondes à 2 chiffres, séparés par des signes deux-points (:).

      • OFFSET : fuseau horaire mis en forme en tant que décalage par rapport au temps universel coordonné (UTC). Par exemple, pour utiliser l'heure normale du Pacifique (PST), spécifiez -08:00. Sinon, pour n'utiliser aucun décalage, spécifiez Z.

    • Pour supprimer la réservation après une certaine durée, envoyez une requête POST à la méthode beta.reservations.insert. Dans le corps de la requête, incluez le champ 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"
  }
}

      Remplacez DELETE_AFTER_DURATION par une durée en secondes. Par exemple, spécifiez 86400 pour 86 400 secondes (1 jour).

Spécifier une VM existante

Vous ne pouvez créer une réservation que sur la base d'une VM existante, située dans la même zone que la VM.

Une fois la réservation créée, vous pouvez l'utiliser en créant des VM dont les propriétés correspondent à la VM de référence. Pour ce faire :

Pour créer une réservation à projet unique qui utilise les propriétés d'une VM existante, procédez comme suit:

  1. Dans la console Google Cloud, accédez à la page Réservations.

    Accéder à la page "Réservations"

  2. Cliquez sur Créer une réservation.

    La page Créer une réservation s'affiche.

  3. Dans le champ Name, saisissez le nom de votre réservation.

  4. Pour les champs Région et Zone, sélectionnez l'emplacement dans lequel vous souhaitez réserver des ressources.

  5. Dans la section Type de partage, cliquez sur Local si cette option n'est pas déjà sélectionnée.

  6. Dans la section Utiliser avec une instance de VM, sélectionnez l'une des options suivantes :

    • Pour autoriser les VM correspondantes à utiliser automatiquement cette réservation, sélectionnez l'option Utiliser automatiquement une réservation si elle n'est pas déjà sélectionnée.

    • Pour n'utiliser les ressources de cette réservation que lors de la création de VM correspondantes qui ciblent spécifiquement cette réservation par son nom, cliquez sur Sélectionner une réservation spécifique.

  7. Pour Nombre d'instances de VM, saisissez le nombre de VM que vous souhaitez réserver.

  8. Dans la section Configuration de la machine, procédez comme suit :

    1. Sélectionnez Utiliser une VM existante.

    2. Pour VM existante, sélectionnez la VM dont vous souhaitez utiliser les propriétés pour créer la réservation.

  9. Facultatif: pour spécifier une stratégie d'emplacement compact pour une réservation qui répond auxexigences, dans la section Stratégie d'emplacement de groupe, cliquez sur la liste Sélectionner ou créer une stratégie d'emplacement de groupe, puis effectuez l'une des opérations suivantes:

    • Pour créer une stratégie d'emplacement compact à spécifier dans cette réservation, procédez comme suit:

      1. Cliquez sur Créer une stratégie d'emplacement de groupe.

        Le volet Créer une stratégie de placement de groupe s'affiche.

      2. Dans Policy name (Nom de la règle), saisissez un nom pour votre règle.

      3. Cliquez sur Créer.

        La création de la stratégie d'emplacement compact peut prendre quelques secondes.

    • Sinon, sélectionnez une stratégie d'emplacement compact existante.

  10. Dans la section Suppression automatique, vous pouvez activer l'option de suppression automatique pour permettre à Compute Engine de supprimer automatiquement la réservation à une date et une heure spécifiques. La suppression automatique des réservations peut vous permettre d'éviter des frais inutiles lorsque vous arrêtez de consommer la réservation.

  11. Pour créer la réservation, cliquez sur Créer.

    La page Réservations s'affiche. La création de la réservation peut prendre jusqu'à une minute.

Spécifier les propriétés directement

Pour créer une réservation pour un projet unique en spécifiant directement les propriétés, sélectionnez l'une des options suivantes:

Console

  1. Dans la console Google Cloud, accédez à la page Réservations.

    Accéder à la page "Réservations"

  2. Dans l'onglet Réservations à la demande (par défaut), cliquez sur Créer une réservation.

    La page Créer une réservation s'affiche.

  3. Dans le champ Name, saisissez le nom de votre réservation.

  4. Pour les champs Région et Zone, sélectionnez l'emplacement dans lequel vous souhaitez réserver des ressources.

  5. Dans la section Type de partage, cliquez sur Local si ce n'est pas déjà fait.

  6. Facultatif: Pour permettre à une réservation de VM avec GPU d'être utilisée par des tâches d'entraînement personnalisées ou des tâches de prédiction dans Vertex AI, sélectionnez Partager la réservation dans la section Services Google Cloud.

  7. Dans la section Utiliser avec une instance de VM, sélectionnez l'une des options suivantes :

    • Pour autoriser les VM correspondantes à utiliser automatiquement cette réservation, sélectionnez l'option Utiliser automatiquement une réservation si elle n'est pas déjà sélectionnée.

    • Pour n'utiliser les ressources de cette réservation que lors de la création de VM correspondantes qui ciblent spécifiquement cette réservation par son nom, cliquez sur Sélectionner une réservation spécifique.

  8. Pour Nombre d'instances de VM, saisissez le nombre de VM que vous souhaitez réserver.

  9. Dans la section Configuration de la machine, sélectionnez Spécifier un type de machine, puis spécifiez les éléments suivants :

    1. Dans les champs Famille de machines, Série et Type de machine, sélectionnez une famille de machines, une série et un type de machine.

    2. Facultatif : pour spécifier une configuration minimale de plate-forme de processeur ou associer des GPU à des VM N1, procédez comme suit :

      1. Développez la section Plate-forme du CPU et GPU en cliquant sur la flèche de développement .

      2. Facultatif: pour spécifier une plate-forme de processeur minimale, sélectionnez une option sous Plate-forme de processeur.

      3. Facultatif : pour associer des GPU à des VM N1, cliquez sur Ajouter un GPU. Ensuite, pour Type de GPU et Nombre de GPU, sélectionnez le type et le nombre de GPU à associer à chaque VM N1.

    3. Facultatif : pour ajouter des disques SSD locaux, procédez comme suit :

      1. Pour Nombre de disques, sélectionnez le nombre de disques SSD locaux pour chaque VM.

      2. Pour Type d'interface, sélectionnez l'interface des disques SSD locaux.

    4. Facultatif: pour spécifier une stratégie d'emplacement compact pour une réservation qui répond auxexigences, cliquez sur la liste Sélectionner ou créer une stratégie d'emplacement de groupe, puis effectuez l'une des opérations suivantes:

      • Pour créer une stratégie d'emplacement compact à spécifier dans cette réservation, procédez comme suit :

        1. Cliquez sur Créer une stratégie d'emplacement de groupe.

          Le volet Créer une stratégie de placement de groupe s'affiche.

        2. Dans Policy name (Nom de la règle), saisissez un nom pour votre règle.

        3. Cliquez sur Créer.

          La création de la stratégie d'emplacement compact peut prendre quelques secondes.

      • Sinon, sélectionnez une stratégie d'emplacement compact existante.

  10. Facultatif: pour spécifier une stratégie d'emplacement compact pour une réservation qui répond auxexigences, dans la section Stratégie d'emplacement de groupe, cliquez sur la liste Sélectionner ou créer une stratégie d'emplacement de groupe, puis effectuez l'une des opérations suivantes:

    • Pour créer une stratégie d'emplacement compact à spécifier dans cette réservation, procédez comme suit:

      1. Cliquez sur Créer une stratégie d'emplacement de groupe.

        Le volet Créer une stratégie de placement de groupe s'affiche.

      2. Dans Policy name (Nom de la règle), saisissez un nom pour votre règle.

      3. Cliquez sur Créer.

        La création de la stratégie d'emplacement compact peut prendre quelques secondes.

    • Sinon, sélectionnez une stratégie d'emplacement compact existante.

  11. Dans la section Suppression automatique, vous pouvez activer l'option de suppression automatique pour permettre à Compute Engine de supprimer automatiquement la réservation à une date et une heure spécifiques. La suppression automatique des réservations peut vous permettre d'éviter des frais inutiles lorsque vous arrêtez de consommer la réservation.

  12. Pour créer la réservation, cliquez sur Créer.

    La page Réservations s'affiche. La création de la réservation pour un projet unique peut prendre jusqu'à une minute.

gcloud

Pour créer une réservation à projet unique, utilisez la commande gcloud compute reservations create.

Pour créer une réservation à projet unique en spécifiant directement les propriétés, sans inclure d'options facultatives, exécutez la commande suivante:

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

Remplacez les éléments suivants :

  • RESERVATION_NAME : le nom de la réservation à créer.

  • MACHINE_TYPE : un type de machine à utiliser pour chaque VM. Si vous spécifiez un type de machine A3, vous devez inclure l'option --require-specific-reservation. Cela indique que seules les VM qui ciblent spécifiquement cette réservation peuvent l'utiliser. Pour en savoir plus, consultez la section Consommer des VM d'une réservation spécifique.

  • NUMBER_OF_VMS : nombre de VM à réserver.

  • ZONE : la zone dans laquelle vous devez réserver des ressources.

Par exemple, pour créer une réservation dans la zone us-central1-a pour dix VM utilisant chacune un type de machine prédéfini N2 avec 4 processeurs virtuels, exécutez la commande suivante :

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

Vous pouvez éventuellement effectuer une ou plusieurs des opérations suivantes :

  • Pour associer des GPU à vos VM N1 réservées, incluez l'option --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

    Remplacez les éléments suivants :

  • Pour ajouter un ou plusieurs disques SSD locaux à chaque VM réservée, incluez une ou plusieurs options --local-ssd. Vous pouvez spécifier jusqu'à 24 disques SSD locaux. La capacité de chaque disque SSD local est de 375 Go.

    Par exemple, pour spécifier deux disques SSD locaux lors de la création d'une réservation, incluez deux options --local-ssd comme suit:

    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

    Remplacez INTERFACE_1 et INTERFACE_2 par le type d'interface que chaque disque SSD local doit utiliser. Spécifiez une des valeurs suivantes :

    • Interfaces de disque NVME : nvme

    • Interfaces de disque SCSI : scsi

    Assurez-vous que le type de machine que vous spécifiez pour les VM réservées est compatible avec les interfaces de disque choisies. Sinon, la création de la réservation échoue. Pour en savoir plus, découvrez comment choisir une interface de disque.

  • Pour que les VM réservées utilisent une plate-forme CPU minimale spécifique au lieu de la plate-forme CPU par défaut de la zone, incluez l'option --min-cpu-platform.

    gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --min-cpu-platform="MIN_CPU_PLATFORM" \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

    Remplacez MIN_CPU_PLATFORM par une plate-forme CPU minimale. Pour vous assurer qu'une plate-forme CPU est disponible dans la zone où vous réservez des ressources, affichez les plates-formes CPU disponibles par zone.

  • Pour spécifier que seules les VM qui ciblent spécifiquement cette réservation peuvent l'utiliser, incluez l'option --require-specific-reservation.

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

  • Pour spécifier une stratégie d'emplacement compacte afin de réduire la latence du réseau entre les VM, incluez l'option --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

    Remplacez COMPACT_PLACEMENT_POLICY_NAME par le nom d'une d'emplacement compact. En outre, pour éviter les erreurs lors de la création d'une réservation à projet unique qui spécifie une stratégie d'emplacement compact, veillez à spécifier les éléments suivants :

    • Un type de machine compatible et un nombre maximal de VM pour les stratégies d'emplacement compact.

    • Zone dans la région où se trouve la stratégie d'emplacement compact.

    • L'option --require-specific-reservation Cela indique que seules les VM qui ciblent spécifiquement cette réservation peuvent l'utiliser.

  • Pour permettre à une réservation de VM avec GPU d'être utilisée par des tâches d'entraînement personnalisées ou des tâches de prédiction dans Vertex AI, exécutez la commande gcloud beta compute reservations create avec l'option --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

  • Pour permettre à Compute Engine de supprimer automatiquement la réservation, sélectionnez l'une des méthodes suivantes :

    • Pour supprimer la réservation à une date et une heure spécifiques, utilisez la commande gcloud beta compute reservations create avec l'option --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

      Remplacez DELETE_AT_TIME par une date et une heure au format de code temporel RFC 3339 comme suit :

      YYYY-MM-DDTHH:MM:SSOFFSET

      Remplacez les éléments suivants :

      • YYYY-MM-DD : date respectant la syntaxe année à 4 chiffres, mois à 2 chiffres et jour du mois à 2 chiffres, séparés par des traits d'union (-).

      • HH:MM:SS : heure respectant la syntaxe heures à 2 chiffres sur 24 heures, minutes à 2 chiffres et secondes à 2 chiffres, séparés par des signes deux-points (:).

      • OFFSET : fuseau horaire mis en forme en tant que décalage par rapport au temps universel coordonné (UTC). Par exemple, pour utiliser l'heure normale du Pacifique (PST), spécifiez -08:00. Sinon, pour n'utiliser aucun décalage, spécifiez Z.

    • Pour supprimer la réservation après une certaine durée, exécutez la commande gcloud beta compute reservations create avec l'option --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

      Remplacez DELETE_AFTER_DURATION par une durée en jours, heures, minutes ou secondes. Par exemple, spécifiez 30m pour 30 minutes ou 1d2h3m4s pour 1 jour, 2 heures, 3 minutes et 4 secondes.

Go 

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 

import com.google.cloud.compute.v1.AcceleratorConfig;
import com.google.cloud.compute.v1.AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk;
import com.google.cloud.compute.v1.AllocationSpecificSKUAllocationReservedInstanceProperties;
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 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 Reservation createReservation(
      String projectId, String reservationName, int numberOfVms, String zone)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // 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;
    // 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()) {
      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();

      Operation response =
          reservationsClient.insertAsync(projectId, zone, reservation).get(7, TimeUnit.MINUTES);

      if (response.hasError()) {
        return null;
      }
      return reservationsClient.get(projectId, zone, reservationName);
    }
  }
}

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

    # 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

Pour créer une réservation à projet unique, utilisez la ressource Terraform google_compute_reservation.

Par exemple, pour créer une réservation à un seul projet pour un type de machine prédéfini N2 avec deux processeurs virtuels, utilisez la ressource suivante:


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
}

Pour en savoir plus sur l'utilisation de Terraform, consultez la page Utiliser Terraform avec Google Cloud.

REST

Pour créer une réservation à projet unique, envoyez une requête POST à la méthode reservations.insert.

Pour créer une réservation à projet unique en spécifiant directement les propriétés, sans inclure de champs facultatifs, effectuez la requête POST suivante:

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

Remplacez les éléments suivants :

  • PROJECT_ID : ID du projet dans lequel vous souhaitez réserver des ressources.

  • ZONE : la zone dans laquelle vous devez réserver des ressources.

  • RESERVATION_NAME : le nom de la réservation à créer.

  • NUMBER_OF_VMS : nombre de VM à réserver.

  • MACHINE_TYPE : un type de machine à utiliser pour chaque VM. Si vous spécifiez un type de machine A3, vous devez inclure le champ specificReservationRequired dans le corps de la requête et le définir sur true. Cela indique que seules les VM qui ciblent spécifiquement cette réservation peuvent l'utiliser. Pour en savoir plus, consultez la section Consommer des VM d'une réservation spécifique.

Par exemple, pour créer une réservation dans la zone us-central1-a pour dix VM utilisant chacune un type de machine prédéfini N2 avec 4 processeurs virtuels, effectuez la requête POST suivante :

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

Vous pouvez éventuellement effectuer une ou plusieurs des opérations suivantes :

  • Pour associer des GPU à vos VM N1 réservées, incluez le champ guestAccelerators dans le corps de la requête.

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

    Remplacez les éléments suivants :

  • Pour ajouter un ou plusieurs disques SSD locaux à chaque VM réservée, incluez le champ localSsds dans le corps de la requête. Vous pouvez spécifier jusqu'à 24 disques SSD locaux. La capacité de chaque disque SSD local est de 375 Go.

    Par exemple, pour spécifier deux disques SSD locaux lors de la création d'une réservation, envoyez une requête comme suit:

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

    Remplacez INTERFACE_1 et INTERFACE_2 par le type d'interface que chaque disque SSD local doit utiliser. Spécifiez une des valeurs suivantes :

    • Interfaces de disque NVME : NVME

    • Interfaces de disque SCSI : SCSI

    Assurez-vous que le type de machine que vous spécifiez pour les VM réservées est compatible avec les interfaces de disque choisies. Sinon, la création de la réservation échoue. Pour en savoir plus, découvrez comment choisir une interface de disque.

  • Pour que les VM réservées utilisent une plate-forme CPU minimale spécifique au lieu de la plate-forme CPU par défaut de la zone, incluez le champ minCpuPlatform dans le corps de la requête.

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

    Remplacez MIN_CPU_PLATFORM par une plate-forme CPU minimale. Pour vous assurer qu'une plate-forme CPU est disponible dans la zone où vous réservez des ressources, affichez les plates-formes CPU disponibles par zone.

  • Pour spécifier une stratégie d'emplacement compacte afin de réduire la latence du réseau entre vos VM réservées, incluez le champ resourcePolicies dans le corps de la requête.

    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
}

    Remplacez les éléments suivants :

    • REGION : région où se trouve la stratégie d'emplacement compact. Vous ne pouvez créer la réservation que dans la région de la stratégie d'emplacement.

    • COMPACT_PLACEMENT_POLICY_NAME : nom d'une stratégie d'emplacement de concentration existante.

    En outre, pour éviter les erreurs lors de la création d'une réservation à projet unique qui spécifie une stratégie d'emplacement compact, veillez à spécifier les éléments suivants :

    • Un type de machine compatible pour les stratégies d'emplacement compact.

    • Le champ specificReservationRequired défini sur true. Cela indique que seules les VM qui ciblent spécifiquement cette réservation peuvent l'utiliser.

  • Pour spécifier que seules les VM qui ciblent spécifiquement cette réservation peuvent l'utiliser, incluez le champ specificReservationRequired dans le corps de la requête et définissez-le sur 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
}

  • Pour permettre à une réservation de VM GPU d'être utilisée par des tâches d'entraînement personnalisées ou des tâches de prédiction dans Vertex AI, envoyez une requête POST à la méthode beta.reservations.insert. Dans le corps de la requête, incluez le champ serviceShareType et définissez-le sur 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"
    }
  }
}

  • Pour permettre à Compute Engine de supprimer automatiquement la réservation, sélectionnez l'une des méthodes suivantes :

    • Pour supprimer la réservation à une date et une heure spécifiques, envoyez une requête POST à la méthode beta.reservations.insert. Dans le corps de la requête, incluez le champ 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"
    }
  }
}

      Remplacez DELETE_AT_TIME par une date et une heure au format de code temporel RFC 3339 comme suit :

      YYYY-MM-DDTHH:MM:SSOFFSET

      Remplacez les éléments suivants :

      • YYYY-MM-DD : date respectant la syntaxe année à 4 chiffres, mois à 2 chiffres et jour du mois à 2 chiffres, séparés par des traits d'union (-).

      • HH:MM:SS : heure respectant la syntaxe heures à 2 chiffres sur 24 heures, minutes à 2 chiffres et secondes à 2 chiffres, séparés par des signes deux-points (:).

      • OFFSET : fuseau horaire mis en forme en tant que décalage par rapport au temps universel coordonné (UTC). Par exemple, pour utiliser l'heure normale du Pacifique (PST), spécifiez -08:00. Sinon, pour n'utiliser aucun décalage, spécifiez Z.

    • Pour supprimer la réservation après une certaine durée, envoyez une requête POST à la méthode beta.reservations.insert. Dans le corps de la requête, incluez le champ 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"
    }
  }
}

      Remplacez DELETE_AFTER_DURATION par une durée en secondes. Par exemple, spécifiez 86400 pour 86 400 secondes (1 jour).

Dépannage

Découvrez comment résoudre les problèmes de création de réservations.

Étapes suivantes