Cette page a été traduite par l'API Cloud Translation.

Utiliser des réservations

Ce document explique comment utiliser Compute Engine pour effectuer les tâches suivantes :

Consommer des instances de machines virtuelles (VM) réservées
Vérifier la consommation des réservations
Afficher les rapports d'utilisation des réservations

Pour en savoir plus sur la consommation des réservations dans d'autres produits Google Cloud utilisant des VM, consultez la documentation sur les réservations pour les produits suivants :

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
  Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
2. Set a default region and zone.

Rôles requis

Pour obtenir les autorisations nécessaires à l'utilisation de réservations, demandez à votre administrateur de vous attribuer le rôle IAM Administrateur d'instances Compute (v1) (roles/compute.instanceAdmin.v1) 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 utiliser des réservations. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour utiliser des réservations :

Pour créer des réservations : compute.reservations.create sur le projet
Pour créer des machines virtuelles :
- compute.instances.create sur le projet
- Pour créer la VM à l'aide d'une image personnalisée : compute.images.useReadOnly sur l'image
- Pour créer la VM à l'aide d'un instantané : compute.snapshots.useReadOnly sur l'instantané
- Pour créer la VM à l'aide d'un modèle d'instance : compute.instanceTemplates.useReadOnly sur le modèle d'instance
- Pour attribuer un ancien réseau à la VM : compute.networks.use sur le projet
- Pour spécifier une adresse IP statique pour la VM : compute.addresses.use sur le projet
- Pour attribuer une adresse IP externe à la VM, en cas d'utilisation d'un ancien réseau : compute.networks.useExternalIp sur le projet
- Pour spécifier un sous-réseau pour la VM : compute.subnetworks.use sur le projet ou sur le sous-réseau choisi
- Pour attribuer une adresse IP externe à la VM, en cas d'utilisation d'un réseau VPC : compute.subnetworks.useExternalIp sur le projet ou sur le sous-réseau choisi
- Pour définir les métadonnées d'instance de VM pour la VM : compute.instances.setMetadata sur le projet
- Pour définir des tags pour la VM : compute.instances.setTags sur la VM
- Pour définir des libellés pour la VM : compute.instances.setLabels sur la VM
- Pour définir un compte de service à utiliser avec la VM : compute.instances.setServiceAccount sur la VM
- Pour créer un disque pour la VM : compute.disks.create sur le projet
- Pour associer un disque existant en mode lecture seule ou en mode lecture-écriture : compute.disks.use sur le disque
- Pour associer un disque existant en mode lecture seule : compute.disks.useReadOnly sur le disque
Pour créer des modèles d'instance : compute.instanceTemplates.create sur le projet

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

Utiliser des VM réservées

Lorsque vous créez une instance de machine virtuelle (VM), la VM ne commence à consommer une réservation que si les propriétés de la VM et de la réservation correspondent. De plus, vous devez définir la propriété d'affinité de réservation de la VM sur l'une des options suivantes :

Utiliser toute réservation correspondante : la VM peut utiliser automatiquement toute réservation avec les propriétés correspondantes (par défaut).

Cette option est utile si vous créez et supprimez un grand nombre de VM et que vous souhaitez utiliser les réservations autant que possible. Dans ce scénario, une VM peut être créée, que ses propriétés correspondent à une réservation ou non. Si c'est le cas, la VM commence à consommer la réservation en fonction de son ordre de consommation.
Utiliser une réservation spécifique : la VM ne peut consommer qu'une réservation spécifique. La réservation ne peut pas être consommée automatiquement.

Cette option est utile, par exemple, lorsque vous souhaitez conserver une certaine capacité de sauvegarde pour des événements spéciaux. Dans ce scénario, une VM ne peut être créée que si ses propriétés et celles de la réservation spécifique correspondent.

Remarque : Vous pouvez créer une réservation spécifique et une VM avec cette affinité pour vérifier que la VM est correctement configurée pour utiliser automatiquement une réservation correspondante.
Ne peut consommer aucune réservation : la VM ne peut consommer aucune réservation.

Cette option est utile, par exemple, lorsque vous créez une VM temporaire qui ne doit pas utiliser de ressources réservées.

Utiliser des VM issues de n'importe quelle réservation correspondante

Dans ce modèle d'utilisation, les VM existantes et nouvelles utilisent automatiquement une réservation si leurs propriétés correspondent aux propriétés de VM spécifiées dans la réservation.

Lorsque vous utilisez ce modèle de consommation, les VM du projet actuel utilisent d'abord toutes les réservations à projet unique avant d'utiliser des réservations partagées. Pour en savoir plus sur la consommation automatique des réservations, consultez la page Ordre de consommation.

Lorsque vous créez une réservation, il s'agit du modèle de consommation par défaut, à condition que vous n'utilisiez pas l'option indiquant que des réservations spécifiques sont requises.

Console

Pour créer une réservation avec des ressources qui peuvent être utilisées par des VM avec une propriété d'affinité de réservation configurée pour utiliser toutes les réservations (par défaut), procédez comme suit :
1. Sélectionnez le type de réservation que vous souhaitez créer :
  - Pour créer une réservation autonome, procédez comme suit :
    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.
  - Pour créer une réservation associée à un engagement, procédez comme suit :
    1. Dans la console Google Cloud, accédez à la page Remises sur engagement d'utilisation.
      
      Accéder aux remises sur engagement d'utilisation
      
      La page Liste des engagements s'ouvre.
    2. Cliquez sur Souscrire un engagement.
      
      La page Acheter une remise sur engagement d'utilisation s'affiche.
    3. Spécifiez les propriétés de l'engagement. Ensuite, dans la section Réservations, cliquez sur Ajouter un élément.
      
      La section Ajouter une réservation s'affiche.
      
      Pour en savoir plus sur la souscription d'un engagement avec une réservation associée, consultez la section Souscrire des engagements avec des réservations associées.
2. Dans le champ Nom, saisissez le nom de la réservation. Pour cet exemple, saisissez reservation-01.
3. Choisissez la région et la zone dans lesquelles vous souhaitez réserver des ressources. Pour cet exemple, sélectionnez la région us-central1 et us-central1-a pour la zone.
4. Choisissez le type de partage souhaité :
  - Pour créer une réservation pour un seul projet, sélectionnez Local.
  - Pour créer une réservation partagée entre plusieurs projets, sélectionnez Partagé. Pour partager cette réservation avec d'autres projets, cliquez sur Ajouter des projets et sélectionnez les projets souhaités dans l'organisation du projet actuel.
5. Dans la section Utiliser avec une instance de VM, sélectionnez Utiliser automatiquement une réservation afin que toutes les VM correspondantes puissent utiliser automatiquement cette réservation.
6. Dans le champ Nombre d'instances de VM, saisissez le nombre de VM que vous souhaitez réserver. Pour cet exemple, saisissez 2.
7. Spécifiez les ressources que vous souhaitez réserver pour chaque VM :
  - Si vous souhaitez réserver des VM correspondant à un modèle d'instance existant, sélectionnez Utiliser un modèle d'instance, puis un modèle d'instance dans la liste.
  - Sinon, sélectionnez Spécifier un type de machine et 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 : spécifiez une configuration minimale de plate-forme de processeur et/ou de GPU :
      1. Pour développer la section Plate-forme du processeur et GPU, cliquez sur la flèche de développement .
      2. Facultatif : pour spécifier une configuration minimale de plate-forme de processeur, sélectionnez une option dans la liste Plate-forme de processeur.
      3. Facultatif : pour ajouter des GPU, cliquez sur Ajouter un GPU. Ensuite, dans les champs Type de GPU et Nombre de GPU, sélectionnez le type et le nombre de GPU pour chaque VM.
    3. Facultatif : ajoutez des disques SSD locaux :
      1. Dans le champ Nombre de disques, sélectionnez le nombre de disques SSD locaux pour chaque VM.
      2. Dans le champ Type d'interface, sélectionnez l'interface des disques SSD locaux.
  Pour cet exemple, sélectionnez Spécifier un type de machine. Sélectionnez ensuite le type de machine n2-standard-32 pour la famille de machines General-purpose et la série N2, puis sélectionnez la configuration minimale de la plate-forme du processeur Intel Cascade Lake.
8. Terminez la création de la réservation :
  - Si vous créez une réservation autonome, cliquez sur Créer.
  - Si vous créez une réservation associée à un engagement :
    1. Pour terminer la spécification des propriétés de cette réservation, cliquez sur OK.
    2. Pour terminer la création de l'engagement et des réservations associées, cliquez sur Acheter.
Dans le même projet ou un projet avec lequel la réservation est partagée, créez une VM qui cible toute réservation ouverte.

Vérifiez que les propriétés de la VM correspondent à celles de la VM dans reservation-01, y compris la zone, le type de machine (famille de machines, vCPU et mémoire), la configuration minimale de la plate-forme du processeur, la quantité et le type de GPU, ainsi que l'interface et la taille des disques SSD locaux.

Pour en savoir plus sur la création d'une VM, consultez la section Créer et démarrer une VM.
1. Accédez à la page Créer une instance dans Google Cloud Console.
  
  Accéder à la page Créer une instance
  
  La page Créer une instance s'ouvre.
2. Spécifiez un nom pour votre VM.
3. Dans les sections suivantes, sélectionnez une configuration qui correspond exactement à toutes les propriétés de votre réservation, y compris les propriétés facultatives. Pour cet exemple, vous devez mettre en correspondance les propriétés de VM suivantes avec reservation-01 :
  - Région : us-central1
  - Zone : us-central1-a
  - Type de machine : n2-standard-32
  - Configuration minimale de la plate-forme du CPU : Intel Cascade Lake
  - GPU : aucun
  - Disques SSD locaux : aucun
4. Développez la section Options avancées, puis la section Gestion. Dans la liste Réservations, cliquez sur Utiliser automatiquement la réservation créée.
5. Pour créer la VM, cliquez sur Créer.

gcloud

Créez une réservation ouverte appelée reservation-01.

gcloud compute reservations create reservation-01 \
    --vm-count=2 \
    --machine-type=n2-standard-32 \
    --min-cpu-platform="Intel Cascade Lake" \
    --zone=us-central1-a

Créez une VM ciblant toute réservation ouverte et correspondant aux propriétés de VM de reservation-01, y compris la zone, le type de machine (famille de machines virtuelles et processeurs virtuels), la configuration minimale de la plate-forme du processeur, la quantité et le type de GPU, et la quantité et l'interface de SSD local.
```
gcloud compute instances create instance-1 \
    --machine-type=n2-standard-32 \
    --min-cpu-platform="Intel Cascade Lake" \
    --zone=us-central1-a \
    --reservation-affinity=any
```

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

// consumeAnyReservation creates instance, consuming any available reservation
func consumeAnyReservation(w io.Writer, projectID, zone, instanceName, sourceTemplate string) error {
	// projectID := "your_project_id"
	// zone := "us-west3-a"
	// instanceName := "your_instance_name"
	// sourceTemplate: existing template path. Following formats are allowed:
	//  	- projects/{project_id}/global/instanceTemplates/{template_name}
	//  	- projects/{project_id}/regions/{region}/instanceTemplates/{template_name}
	//  	- https://www.googleapis.com/compute/v1/projects/{project_id}/global/instanceTemplates/instanceTemplate
	//  	- https://www.googleapis.com/compute/v1/projects/{project_id}/regions/{region}/instanceTemplates/instanceTemplate

	ctx := context.Background()

	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer instancesClient.Close()

	req := &computepb.InsertInstanceRequest{
		Project:                projectID,
		Zone:                   zone,
		SourceInstanceTemplate: proto.String(sourceTemplate),
		InstanceResource: &computepb.Instance{
			Name: proto.String(instanceName),
			// specifies that any matching reservation should be consumed
			ReservationAffinity: &computepb.ReservationAffinity{
				ConsumeReservationType: proto.String("ANY_RESERVATION"),
			},
		},
	}

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

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

	return nil
}

Java

import static com.google.cloud.compute.v1.ReservationAffinity.ConsumeReservationType.ANY_RESERVATION;

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.ReservationAffinity;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ConsumeAnyMatchingReservation {

  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";
    // Zone where the VM instance will be created.
    String zone = "us-central1-a";
    // Name of the VM instance you want to query.
    String instanceName = "YOUR_INSTANCE_NAME";
    // machineType: machine type of the VM being created.
    // *   For a list of machine types, see https://cloud.google.com/compute/docs/machine-types
    String machineTypeName = "n1-standard-4";
    // sourceImage: path to the operating system image to mount.
    // *   For details about images you can mount, see https://cloud.google.com/compute/docs/images
    String sourceImage = "projects/debian-cloud/global/images/family/debian-11";
    // diskSizeGb: storage size of the boot disk to attach to the instance.
    long diskSizeGb = 10L;
    // networkName: network interface to associate with the instance.
    String networkName = "default";
    // Minimum CPU platform of the instances.
    String minCpuPlatform = "Intel Skylake";

    createInstanceAsync(projectId, zone, instanceName, machineTypeName, sourceImage,
        diskSizeGb, networkName, minCpuPlatform);
  }

  // Create a virtual machine targeted with the reserveAffinity field.
  // In this consumption model, existing and new VMs automatically consume a reservation
  // if their properties match the VM properties specified in the reservation.
  public static Instance createInstanceAsync(String projectId, String zone,
      String instanceName, String machineTypeName, String sourceImage,
      long diskSizeGb, String networkName, String minCpuPlatform)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    String machineType = String.format("zones/%s/machineTypes/%s", zone, machineTypeName);
    // 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 (InstancesClient instancesClient = InstancesClient.create()) {
      AttachedDisk disk =
          AttachedDisk.newBuilder()
              .setBoot(true)
              .setAutoDelete(true)
              .setType(AttachedDisk.Type.PERSISTENT.toString())
              .setDeviceName("disk-1")
              .setInitializeParams(
                  AttachedDiskInitializeParams.newBuilder()
                      .setSourceImage(sourceImage)
                      .setDiskSizeGb(diskSizeGb)
                      .build())
              .build();

      NetworkInterface networkInterface = NetworkInterface.newBuilder()
          .setName(networkName)
          .build();

      ReservationAffinity reservationAffinity =
          ReservationAffinity.newBuilder()
              .setConsumeReservationType(ANY_RESERVATION.toString())
              .build();

      Instance instanceResource =
          Instance.newBuilder()
              .setName(instanceName)
              .setMachineType(machineType)
              .addDisks(disk)
              .addNetworkInterfaces(networkInterface)
              .setMinCpuPlatform(minCpuPlatform)
              .setReservationAffinity(reservationAffinity)
              .build();

      InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setInstanceResource(instanceResource)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.insertAsync(
          insertInstanceRequest);

      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        return null;
      }
      return instancesClient.get(projectId, zone, instanceName);
    }
  }
}

Node.js

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

// Instantiate a reservationsClient
const instancesClient = new computeLib.InstancesClient();
// 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 create instance.
const projectId = await instancesClient.getProjectId();
// The zone in which to create instance.
const zone = 'us-central1-a';
// The name of the instance to create.
// const instanceName = 'instance-01';
// Machine type to use for VM.
const machineType = 'n1-standard-4';

// Create instance to consume reservation if their properties match the VM properties
async function callCreateInstanceToConsumeAnyReservation() {
  // Describe the size and source image of the boot disk to attach to the instance.
  const disk = new compute.Disk({
    boot: true,
    autoDelete: true,
    type: 'PERSISTENT',
    initializeParams: {
      diskSizeGb: '10',
      sourceImage: 'projects/debian-cloud/global/images/family/debian-12',
    },
  });

  //  Define networkInterface
  const networkInterface = new compute.NetworkInterface({
    name: 'global/networks/default',
  });

  // Define reservationAffinity
  const reservationAffinity = new compute.ReservationAffinity({
    consumeReservationType: 'ANY_RESERVATION',
  });

  // Create an instance
  const instance = new compute.Instance({
    name: instanceName,
    machineType: `zones/${zone}/machineTypes/${machineType}`,
    minCpuPlatform: 'Intel Skylake',
    disks: [disk],
    networkInterfaces: [networkInterface],
    reservationAffinity,
  });

  const [response] = await instancesClient.insert({
    project: projectId,
    instanceResource: instance,
    zone,
  });

  let operation = response.latestResponse;

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

  console.log(`Instance ${instanceName} created.`);
}

await callCreateInstanceToConsumeAnyReservation();

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 consume_any_project_reservation(
    project_id: str,
    zone: str,
    reservation_name: str,
    instance_name: str,
    machine_type: str = "n1-standard-1",
    min_cpu_platform: str = "Intel Ivy Bridge",
) -> compute_v1.Instance:
    """
    Creates a specific reservation in a single project and launches a VM
    that consumes the newly created reservation.
    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.
        instance_name (str): The name of the instance to create.
        machine_type (str): The machine type for the instance.
        min_cpu_platform (str): The minimum CPU platform for the instance.
    """
    instance_properties = (
        compute_v1.AllocationSpecificSKUAllocationReservedInstanceProperties(
            machine_type=machine_type,
            min_cpu_platform=min_cpu_platform,
        )
    )

    reservation = compute_v1.Reservation(
        name=reservation_name,
        specific_reservation=compute_v1.AllocationSpecificSKUReservation(
            count=3,
            instance_properties=instance_properties,
        ),
    )

    # Create a reservation client
    client = compute_v1.ReservationsClient()
    operation = client.insert(
        project=project_id,
        zone=zone,
        reservation_resource=reservation,
    )
    wait_for_extended_operation(operation, "Reservation creation")

    instance = compute_v1.Instance()
    instance.name = instance_name
    instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
    instance.min_cpu_platform = min_cpu_platform
    instance.zone = zone

    # Set the reservation affinity to target any matching reservation
    instance.reservation_affinity = compute_v1.ReservationAffinity(
        consume_reservation_type="ANY_RESERVATION",  # Type of reservation to consume
    )
    # Define the disks for the instance
    instance.disks = [
        compute_v1.AttachedDisk(
            boot=True,  # Indicates that this is a boot disk
            auto_delete=True,  # The disk will be deleted when the instance is deleted
            initialize_params=compute_v1.AttachedDiskInitializeParams(
                source_image="projects/debian-cloud/global/images/family/debian-11",
                disk_size_gb=10,
            ),
        )
    ]
    instance.network_interfaces = [
        compute_v1.NetworkInterface(
            network="global/networks/default",  # The network to use
            access_configs=[
                compute_v1.AccessConfig(
                    name="External NAT",  # Name of the access configuration
                    type="ONE_TO_ONE_NAT",  # Type of access configuration
                )
            ],
        )
    ]
    # Create a request to insert the instance
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

    vm_client = compute_v1.InstancesClient()
    operation = vm_client.insert(request)
    wait_for_extended_operation(operation, "instance creation")
    print(f"Instance {instance_name} that targets any open reservation created.")

    return vm_client.get(project=project_id, zone=zone, instance=instance_name)

REST

Créez une réservation ouverte appelée reservation-01.

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

{
  "name": "reservation-01",
  "specificReservation": {
    "count": "2",
    "instanceProperties": {
      "machineType": "n2-standard-32",
      "minCpuPlatform": "Intel Cascade Lake",
    }
  }
}

Créez une VM ciblant toute réservation ouverte et correspondant aux propriétés de VM de reservation-01, y compris la zone, le type de machine (famille de machines virtuelles et processeurs virtuels), la configuration minimale de la plate-forme du processeur, la quantité et le type de GPU, et la quantité et l'interface de SSD local.

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

{
  "name": "instance-1",
  "machineType": "zones/us-central1-a/machineTypes/n2-standard-32",
  "minCpuPlatform": "Intel Cascade Lake",
  "disks": [
    {
      "boot": true,
      "initializeParams": {
        "sourceImage": "projects/debian-cloud/global/images/family/debian-12"
      }
    }
  ],
  "networkInterfaces": [
    {
      "network": "global/networks/default"
    }
  ],
  "reservationAffinity": {
    "consumeReservationType": "ANY_RESERVATION"
  }
}

Utiliser des VM d'une réservation spécifique

Dans ce modèle d'utilisation, seules les nouvelles VM qui ciblent une réservation spécifique par nom peuvent utiliser cette réservation. La réservation n'est donc pas utilisée automatiquement.

Lors de la création de la réservation, spécifiez que les VM sont requises pour cibler la réservation spécifique en utilisant l'une des méthodes suivantes :

Dans la console Google Cloud, cochez la case Sélectionner une réservation spécifique.
Dans la CLI gcloud, incluez l'option --require-specific-reservation.
Dans l'API Compute Engine, définissez le champ specificReservationRequired sur true.
Dans Terraform, définissez le champ specific_reservation_required sur true.

Ensuite, créez des VM qui ciblent spécifiquement cette réservation. Vous ne pouvez créer une VM qui cible une réservation spécifique que si les propriétés de la VM et celles de la réservation correspondent. Sinon, la création de la VMéchouera.

Si vous utilisez un modèle d'instance pour créer des VM dans un groupe d'instances géré régional, créez des réservations identiques portant le même nom dans chaque zone applicable. Ensuite, ciblez les réservations par leur nom dans le modèle d'instance du groupe.

Par exemple, créez une réservation spécifique nommée reservation-02, puis créez une VM correspondante qui cible cette réservation et qui correspond aux propriétés de VM de la réservation.

Selon le type de VM que vous souhaitez utiliser, suivez les étapes pour la consommation d'une réservation pour un seul projet ou la consommation d'une réservation partagée spécifique.

Consommer une réservation spécifique à un seul projet

Pour consommer une réservation spécifique à un seul projet, sélectionnez l'une des options suivantes:

Console

Pour créer une réservation avec des ressources qui ne peuvent être utilisées que par des VM ciblant spécifiquement la réservation par son nom, procédez comme suit :
1. Sélectionnez l'une des options suivantes :
  - Pour créer une réservation autonome, procédez comme suit :
    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.
  - Pour créer une réservation associée à un engagement, procédez comme suit :
    1. Dans la console Google Cloud, accédez à la page Remises sur engagement d'utilisation.
      
      Accéder aux remises sur engagement d'utilisation
    2. Cliquez sur Souscrire un engagement.
      
      La page Acheter une remise sur engagement d'utilisation s'affiche.
    3. Spécifiez les propriétés de l'engagement. Ensuite, dans la section Réservations, cliquez sur Ajouter un élément.
      
      La section Ajouter une réservation s'affiche.
      
      Pour en savoir plus sur la souscription d'un engagement avec une réservation associée, consultez la section Souscrire des engagements avec des réservations associées.
2. Dans le champ Nom, saisissez le nom de la réservation. Pour cet exemple, saisissez reservation-02.
3. Choisissez la région et la zone dans lesquelles vous souhaitez réserver des ressources. Pour cet exemple, sélectionnez la région us-central1 et us-central1-a pour la zone.
4. Pour spécifier que votre réservation sera une réservation pour un projet unique, sélectionnez Local comme Type de partage.
5. Dans la section Utiliser avec une instance de VM, sélectionnez Sélectionner une réservation spécifique afin que seules les VM correspondantes ciblant spécifiquement cette réservation par son nom puissent l'utiliser.
6. Dans le champ Nombre d'instances de VM, saisissez le nombre de VM que vous souhaitez réserver. Pour cet exemple, saisissez 10.
7. Spécifiez les ressources que vous souhaitez réserver pour chaque VM :
  - Si vous souhaitez réserver des VM correspondant à un modèle d'instance existant, sélectionnez Utiliser un modèle d'instance, puis un modèle d'instance dans la liste.
  - Sinon, sélectionnez Spécifier un type de machine et 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 : spécifiez une configuration minimale de plate-forme de processeur et/ou de GPU :
      1. Pour développer la section Plate-forme du processeur et GPU, cliquez sur la flèche de développement .
      2. Facultatif : pour spécifier une configuration minimale de plate-forme de processeur, sélectionnez une option dans la liste Plate-forme de processeur.
      3. Facultatif : pour ajouter des GPU, cliquez sur Ajouter un GPU. Ensuite, dans les champs Type de GPU et Nombre de GPU, sélectionnez le type et le nombre de GPU pour chaque VM.
    3. Facultatif : ajoutez des disques SSD locaux :
      1. Dans le champ Nombre de disques, sélectionnez le nombre de disques SSD locaux pour chaque VM.
      2. Dans le champ Type d'interface, sélectionnez l'interface des disques SSD locaux.
  Pour cet exemple, sélectionnez Spécifier un type de machine. Sélectionnez ensuite le type de machine n2-standard-32 pour la famille de machines General-purpose et la série N2, puis sélectionnez la configuration minimale de la plate-forme du processeur Intel Cascade Lake.
8. Terminez la création de la réservation :
  - Si vous créez une réservation autonome, cliquez sur Créer.
  - Si vous créez une réservation associée à un engagement :
    1. Pour terminer la spécification des propriétés de cette réservation, cliquez sur OK.
    2. Pour terminer la création de l'engagement et des réservations associées, cliquez sur Acheter.
Dans le même projet, créez une VM qui cible la réservation spécifique par son nom.

Vérifiez que les propriétés de la VM correspondent aux propriétés de la VM de cette réservation spécifique, y compris la zone, le type de machine (famille de machines, vCPU et mémoire), la configuration minimale de la plate-forme du processeur, le type et la quantité de GPU et l'interface et la taille des disques SSD locaux.

Pour en savoir plus sur la création d'une VM, consultez la section Créer et démarrer une VM.
1. Accédez à la page Créer une instance dans Google Cloud Console.
  
  Accéder à la page Créer une instance
2. Dans le champ Nom, saisissez un nom pour la VM.
3. Dans les sections suivantes, sélectionnez une configuration qui correspond exactement à toutes les propriétés de votre réservation, y compris les propriétés facultatives. Pour cet exemple, vous devez mettre en correspondance les propriétés de VM suivantes avec reservation-02 :
  - Région : us-central1
  - Zone : us-central1-a
  - Type de machine : n2-standard-32
  - Configuration minimale de la plate-forme du CPU : Intel Cascade Lake
  - GPU : aucun
  - Disques SSD locaux : aucun
4. Développez la section Options avancées et procédez comme suit :
  1. Développez la section Gestion.
  2. Dans la section Réservations, dans la liste Règle d'application, sélectionnez Sélectionner une réservation spécifique.
  3. Sélectionnez la réservation avec les propriétés de VM correspondantes que vous souhaitez que la VM consomme. Pour cet exemple, sélectionnez reservation-02.
5. Pour créer la VM, cliquez sur Créer.

gcloud

Créez une réservation appelée reservation-02 avec l'option --require-specific-reservation. Ces ressources réservées ne peuvent être utilisées que par des VM qui ciblent spécifiquement cette réservation par son nom.

gcloud compute reservations create reservation-02 \
    --machine-type=n2-standard-32 \
    --min-cpu-platform="Intel Cascade Lake" \
    --vm-count=10 \
    --zone=us-central1-a \
    --require-specific-reservation

Créez une VM qui cible reservation-02 par son nom en utilisant les options --reservation-affinity et --reservation.

Vérifiez que les propriétés de la VM correspondent aux propriétés de la réservation, y compris la zone, le type de machine (famille de machines, processeurs virtuels et mémoire), la configuration minimale de la plate-forme du processeur, le type et la quantité de GPU, et l'interface et la taille des disques SSD locaux.
```
gcloud compute instances create instance-2 \
    --machine-type=n2-standard-32 \
    --min-cpu-platform="Intel Cascade Lake" \
    --zone=us-central1-a \
    --reservation-affinity=specific \
    --reservation=reservation-02
```

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

// consumeSpecificReservation creates instance, consuming specific reservation
// Note: respective reservation should have SpecificReservationRequired: true
func consumeSpecificReservation(w io.Writer, projectID, zone, instanceName, reservationName string) error {
	// projectID := "your_project_id"
	// zone := "us-west3-a"
	// reservationName := "your_reservation_name"
	// instanceName := "your_instance_name"

	ctx := context.Background()
	machineType := fmt.Sprintf("zones/%s/machineTypes/%s", zone, "n2-standard-32")
	sourceImage := "projects/debian-cloud/global/images/family/debian-12"

	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer instancesClient.Close()

	req := &computepb.InsertInstanceRequest{
		Project: projectID,
		Zone:    zone,
		InstanceResource: &computepb.Instance{
			Disks: []*computepb.AttachedDisk{
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb:  proto.Int64(10),
						SourceImage: proto.String(sourceImage),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(true),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
			},
			MachineType:    proto.String(machineType),
			MinCpuPlatform: proto.String("Intel Cascade Lake"),
			Name:           proto.String(instanceName),
			NetworkInterfaces: []*computepb.NetworkInterface{
				{
					Name: proto.String("global/networks/default"),
				},
			},
			// specifies particular reservation, which should be consumed
			ReservationAffinity: &computepb.ReservationAffinity{
				ConsumeReservationType: proto.String("SPECIFIC_RESERVATION"),
				Key:                    proto.String("compute.googleapis.com/reservation-name"),
				Values:                 []string{reservationName},
			},
		},
	}

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

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

	return nil
}

Java

import static com.google.cloud.compute.v1.ReservationAffinity.ConsumeReservationType.SPECIFIC_RESERVATION;

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.ReservationAffinity;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ConsumeSingleProjectReservation {
  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 where the reservation is located.
    String zone = "us-central1-a";
    // Name of the reservation you want to query.
    String reservationName = "YOUR_RESERVATION_NAME";
    // Name of the VM instance you want to query.
    String instanceName = "YOUR_INSTANCE_NAME";
    // machineType: machine type of the VM being created.
    // *   For a list of machine types, see https://cloud.google.com/compute/docs/machine-types
    String machineTypeName = "n1-standard-4";
    // sourceImage: path to the operating system image to mount.
    // *   For details about images you can mount, see https://cloud.google.com/compute/docs/images
    String sourceImage = "projects/debian-cloud/global/images/family/debian-11";
    // diskSizeGb: storage size of the boot disk to attach to the instance.
    long diskSizeGb = 10L;
    // networkName: network interface to associate with the instance.
    String networkName = "default";
    // Minimum CPU platform of the instances.
    String minCpuPlatform = "Intel Skylake";

    createInstanceAsync(projectId, zone, instanceName, reservationName, machineTypeName,
        sourceImage, diskSizeGb, networkName, minCpuPlatform);
  }

  // Create a virtual machine targeted with the reserveAffinity field.
  // Ensure that the VM's properties match the reservation's VM properties.
  public static Instance createInstanceAsync(String projectId, String zone, String instanceName,
      String reservationName, String machineTypeName, String sourceImage, long diskSizeGb,
      String networkName, String minCpuPlatform)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    String machineType = String.format("zones/%s/machineTypes/%s", zone, machineTypeName);
    // 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 (InstancesClient instancesClient = InstancesClient.create()) {
      AttachedDisk disk =
          AttachedDisk.newBuilder()
              .setBoot(true)
              .setAutoDelete(true)
              .setType(AttachedDisk.Type.PERSISTENT.toString())
              .setDeviceName("disk-1")
              .setInitializeParams(
                  AttachedDiskInitializeParams.newBuilder()
                      .setSourceImage(sourceImage)
                      .setDiskSizeGb(diskSizeGb)
                      .build())
              .build();

      NetworkInterface networkInterface = NetworkInterface.newBuilder()
          .setName(networkName)
          .build();

      ReservationAffinity reservationAffinity =
          ReservationAffinity.newBuilder()
              .setConsumeReservationType(SPECIFIC_RESERVATION.toString())
              .setKey("compute.googleapis.com/reservation-name")
              // Set specific reservation
              .addValues(reservationName)
              .build();

      Instance instanceResource =
          Instance.newBuilder()
              .setName(instanceName)
              .setMachineType(machineType)
              .addDisks(disk)
              .addNetworkInterfaces(networkInterface)
              .setMinCpuPlatform(minCpuPlatform)
              .setReservationAffinity(reservationAffinity)
              .build();

      InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setInstanceResource(instanceResource)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.insertAsync(
          insertInstanceRequest);
      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        return null;
      }
      return instancesClient.get(projectId, zone, instanceName);
    }
  }
}

Node.js

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

// Instantiate a reservationsClient
const instancesClient = new computeLib.InstancesClient();
// 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 create instance.
const projectId = await instancesClient.getProjectId();
// The zone in which to create instance.
const zone = 'us-central1-a';
// The name of the instance to create.
// const instanceName = 'instance-01';
// The name of the reservation to consume.
// Ensure that the specificReservationRequired field in reservation properties is set to true.
// const reservationName = 'reservation-01';
// Machine type to use for VM.
const machineType = 'n1-standard-4';

// Create instance to consume a specific single-project reservation
async function callCreateInstanceToConsumeSingleProjectReservation() {
  // Describe the size and source image of the boot disk to attach to the instance.
  // Ensure that the VM's properties match the reservation's VM properties,
  // including the zone, machine type (machine family, vCPUs, and memory),
  // minimum CPU platform, GPU amount and type, and local SSD interface and size
  const disk = new compute.Disk({
    boot: true,
    autoDelete: true,
    type: 'PERSISTENT',
    initializeParams: {
      diskSizeGb: '10',
      sourceImage: 'projects/debian-cloud/global/images/family/debian-12',
    },
  });

  //  Define networkInterface
  const networkInterface = new compute.NetworkInterface({
    name: 'global/networks/default',
  });

  // Define reservationAffinity
  const reservationAffinity = new compute.ReservationAffinity({
    consumeReservationType: 'SPECIFIC_RESERVATION',
    key: 'compute.googleapis.com/reservation-name',
    values: [reservationName],
  });

  // Create an instance
  const instance = new compute.Instance({
    name: instanceName,
    machineType: `zones/${zone}/machineTypes/${machineType}`,
    minCpuPlatform: 'Intel Skylake',
    disks: [disk],
    networkInterfaces: [networkInterface],
    reservationAffinity,
  });

  const [response] = await instancesClient.insert({
    project: projectId,
    instanceResource: instance,
    zone,
  });

  let operation = response.latestResponse;

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

  console.log(`Instance ${instanceName} created.`);
}

await callCreateInstanceToConsumeSingleProjectReservation();

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 consume_specific_single_project_reservation(
    project_id: str,
    zone: str,
    reservation_name: str,
    instance_name: str,
    machine_type: str = "n1-standard-1",
    min_cpu_platform: str = "Intel Ivy Bridge",
) -> compute_v1.Instance:
    """
    Creates a specific reservation in a single project and launches a VM
    that consumes the newly created reservation.
    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.
        instance_name (str): The name of the instance to create.
        machine_type (str): The machine type for the instance.
        min_cpu_platform (str): The minimum CPU platform for the instance.
    """
    instance_properties = (
        compute_v1.AllocationSpecificSKUAllocationReservedInstanceProperties(
            machine_type=machine_type,
            min_cpu_platform=min_cpu_platform,
        )
    )

    reservation = compute_v1.Reservation(
        name=reservation_name,
        specific_reservation=compute_v1.AllocationSpecificSKUReservation(
            count=3,
            instance_properties=instance_properties,
        ),
        # Only VMs that target the reservation by name can consume from this reservation
        specific_reservation_required=True,
    )

    # Create a reservation client
    client = compute_v1.ReservationsClient()
    operation = client.insert(
        project=project_id,
        zone=zone,
        reservation_resource=reservation,
    )
    wait_for_extended_operation(operation, "Reservation creation")

    instance = compute_v1.Instance()
    instance.name = instance_name
    instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
    instance.min_cpu_platform = min_cpu_platform
    instance.zone = zone

    # Set the reservation affinity to target the specific reservation
    instance.reservation_affinity = compute_v1.ReservationAffinity(
        consume_reservation_type="SPECIFIC_RESERVATION",  # Type of reservation to consume
        key="compute.googleapis.com/reservation-name",  # Key for the reservation
        values=[reservation_name],  # Reservation name to consume
    )
    # Define the disks for the instance
    instance.disks = [
        compute_v1.AttachedDisk(
            boot=True,  # Indicates that this is a boot disk
            auto_delete=True,  # The disk will be deleted when the instance is deleted
            initialize_params=compute_v1.AttachedDiskInitializeParams(
                source_image="projects/debian-cloud/global/images/family/debian-11",
                disk_size_gb=10,
            ),
        )
    ]
    instance.network_interfaces = [
        compute_v1.NetworkInterface(
            network="global/networks/default",  # The network to use
            access_configs=[
                compute_v1.AccessConfig(
                    name="External NAT",  # Name of the access configuration
                    type="ONE_TO_ONE_NAT",  # Type of access configuration
                )
            ],
        )
    ]
    # Create a request to insert the instance
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

    vm_client = compute_v1.InstancesClient()
    operation = vm_client.insert(request)
    wait_for_extended_operation(operation, "instance creation")
    print(f"Instance {instance_name} with specific reservation created successfully.")

    return vm_client.get(project=project_id, zone=zone, instance=instance_name)

REST

Créez une réservation nommée reservation-02 avec le champ specificReservationRequired défini sur true.

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

{
  "name":"reservation-02",
  "specificReservation":{
    "count":"10",
    "instanceProperties":{
      "machineType":"n2-standard-32",
      "minCpuPlatform": "Intel Cascade Lake",
    }
  },
  "specificReservationRequired": true
}

Créez une VM ciblant reservation-02 par son nom à l'aide du champ reservationAffinity.

Vérifiez que les propriétés de la VM correspondent aux propriétés de la réservation, y compris la zone, le type de machine (famille de machines, processeurs virtuels et mémoire), la configuration minimale de la plate-forme du processeur, le type et la quantité de GPU, et l'interface et la taille des disques SSD locaux.

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

{
  "name": "instance-2",
  "machineType": "zones/us-central1-a/machineTypes/n2-standard-32",
  "minCpuPlatform": "Intel Cascade Lake",
  "disks": [
    {
      "boot": true,
      "initializeParams": {
        "sourceImage": "projects/debian-clouid/global/images/family/debian-12"
      }
    }
  ],
  "networkInterfaces": [
    {
      "network": "global/networks/default"
    }
  ],
  "reservationAffinity": {
    "consumeReservationType": "SPECIFIC_RESERVATION",
    "key": "compute.googleapis.com/reservation-name",
    "values": [
      "reservation-02"
    ]
  }
}

Utiliser une réservation partagée spécifique

Pour consommer une réservation partagée spécifique, sélectionnez l'une des options suivantes:

Console

Pour créer une réservation partagée avec des ressources qui ne peuvent être utilisées que par des VM ciblant spécifiquement cette réservation par son nom, procédez comme suit :
1. Sélectionnez l'une des options suivantes :
  - Pour créer une réservation autonome, procédez comme suit :
    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.
  - Pour créer une réservation associée à un engagement, procédez comme suit :
    1. Dans la console Google Cloud, accédez à la page Remises sur engagement d'utilisation.
      
      Accéder aux remises sur engagement d'utilisation
    2. Cliquez sur Souscrire un engagement.
      
      La page Acheter une remise sur engagement d'utilisation s'affiche.
    3. Spécifiez les propriétés de l'engagement. Ensuite, dans la section Réservations, cliquez sur Ajouter un élément.
      
      La section Ajouter une réservation s'affiche.
      
      Pour en savoir plus sur la souscription d'un engagement avec une réservation associée, consultez la section Souscrire des engagements avec des réservations associées.
2. Dans le champ Nom, saisissez le nom de la réservation. Pour cet exemple, saisissez reservation-02.
3. Choisissez la région et la zone dans lesquelles vous souhaitez réserver des ressources. Pour cet exemple, sélectionnez la région us-central1 et us-central1-a pour la zone.
4. Pour spécifier que votre réservation est une réservation partagée, sélectionnez Partagé comme type de partage.
5. Cliquez sur Ajouter des projets, puis sélectionnez les projets de l'organisation du projet actuel avec lesquels vous souhaitez partager la réservation.
6. Dans la section Utiliser avec une instance de VM, sélectionnez Sélectionner une réservation spécifique afin que seules les VM correspondantes ciblant spécifiquement cette réservation par son nom puissent l'utiliser.
7. Dans le champ Nombre d'instances de VM, saisissez le nombre de VM que vous souhaitez réserver. Pour cet exemple, saisissez 10.
8. Spécifiez les ressources que vous souhaitez réserver pour chaque VM :
  - Si vous souhaitez réserver des VM correspondant à un modèle d'instance existant, sélectionnez Utiliser un modèle d'instance, puis un modèle d'instance dans la liste.
  - Sinon, sélectionnez Spécifier un type de machine et 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 : spécifiez une configuration minimale de plate-forme de processeur et/ou de GPU :
      1. Pour développer la section Plate-forme du processeur et GPU, cliquez sur la flèche de développement .
      2. Facultatif : pour spécifier une configuration minimale de plate-forme de processeur, sélectionnez une option dans la liste Plate-forme de processeur.
      3. Facultatif : pour ajouter des GPU, cliquez sur Ajouter un GPU. Ensuite, dans les champs Type de GPU et Nombre de GPU, sélectionnez le type et le nombre de GPU pour chaque VM.
    3. Facultatif : ajoutez des disques SSD locaux :
      1. Dans le champ Nombre de disques, sélectionnez le nombre de disques SSD locaux pour chaque VM.
      2. Dans le champ Type d'interface, sélectionnez l'interface des disques SSD locaux.
  Pour cet exemple, sélectionnez Spécifier un type de machine. Sélectionnez ensuite le type de machine n2-standard-32 pour la famille de machines General-purpose et la série N2, puis sélectionnez la configuration minimale de la plate-forme du processeur Intel Cascade Lake. 1. Terminez la création de la réservation :
  - Si vous créez une réservation autonome, cliquez sur Créer.
  - Si vous créez une réservation associée à un engagement :
    1. Pour terminer la spécification des propriétés de cette réservation, cliquez sur OK.
    2. Pour terminer la création de l'engagement et des réservations associées, cliquez sur Acheter.
Dans le même projet ou le projet avec lequel la réservation est partagée, créez une VM qui cible la réservation spécifique par son nom.

Vérifiez que les propriétés de la VM correspondent aux propriétés de la VM de cette réservation spécifique, y compris la zone, le type de machine (famille de machines, vCPU et mémoire), la configuration minimale de la plate-forme du processeur, le type et la quantité de GPU et l'interface et la taille des disques SSD locaux.
1. Accédez à la page Créer une instance dans Google Cloud Console.
  
  Accéder à la page Créer une instance
  
  La page Créer une instance s'ouvre.
2. Spécifiez un nom pour votre VM.
3. Dans les sections suivantes, sélectionnez une configuration qui correspond exactement à toutes les propriétés de votre réservation, y compris les propriétés facultatives. Pour cet exemple, vous devez mettre en correspondance les propriétés de VM suivantes avec reservation-02 :
  - Région : us-central1
  - Zone : us-central1-a
  - Type de machine : n2-standard-32
  - Configuration minimale de la plate-forme du CPU : Intel Cascade Lake
  - GPU : aucun
  - Disques SSD locaux : aucun
4. Développez la section Options avancées, puis la section Gestion. Dans la liste Réservations, sélectionnez Sélectionner une réservation spécifique, puis procédez comme suit :
  1. Sélectionnez un projet de réservation ayant des réservations partagées avec votre projet actuel. Pour cet exemple, sélectionnez le projet que vous avez utilisé pour créer reservation-02.
  2. Sélectionnez le nom de la réservation de la réservation partagée que vous souhaitez que cette VM utilise. Pour cet exemple, sélectionnez reservation-02.
5. Pour créer la VM, cliquez sur Créer.

gcloud

gcloud compute reservations create reservation-02 \
    --machine-type=n2-standard-32 \
    --min-cpu-platform="Intel Cascade Lake" \
    --vm-count=10 \
    --zone=us-central1-a \
    --project=my-owner-project \
    --share-setting=projects \
    --share-with=project-1,project-2 \
    --require-specific-reservation

Créez une VM qui cible reservation-02 par son nom en utilisant les options --reservation-affinity et --reservation. Pour utiliser cette réservation à partir de tous les projets clients avec lesquels cette réservation est partagée, vous devez également spécifier le projet qui a créé la réservation, my-owner-project.

Vérifiez que les propriétés de la VM correspondent aux propriétés de la réservation, y compris la zone, le type de machine (famille de machines, processeurs virtuels et mémoire), la configuration minimale de la plate-forme du processeur, le type et la quantité de GPU, et l'interface et la taille des disques SSD locaux.
```
gcloud compute instances create instance-2 \
    --machine-type=n2-standard-32 \
    --min-cpu-platform="Intel Cascade Lake" \
    --zone=us-central1-a \
    --reservation-affinity=specific \
    --reservation=projects/my-owner-project/reservations/reservation-02
```

Go

import (
	"context"
	"fmt"
	"io"

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

// consumeSpecificSharedReservation consumes specific shared reservation in particular zone
func consumeSpecificSharedReservation(w io.Writer, client InstanceClientInterface, projectID, baseProjectId, zone, instanceName, reservationName string) error {
	// client, err := compute.NewInstancesRESTClient(ctx)
	// projectID := "your_project_id". Project where reservation is created.
	// baseProjectId := "shared_project_id". Project where instance will be consumed and created.
	// zone := "us-west3-a"
	// reservationName := "your_reservation_name"
	// instanceName := "your_instance_name"

	ctx := context.Background()
	machineType := fmt.Sprintf("zones/%s/machineTypes/%s", zone, "n2-standard-32")
	sourceImage := "projects/debian-cloud/global/images/family/debian-12"
	sharedReservation := fmt.Sprintf("projects/%s/reservations/%s", baseProjectId, reservationName)

	req := &computepb.InsertInstanceRequest{
		Project: projectID,
		Zone:    zone,
		InstanceResource: &computepb.Instance{
			Disks: []*computepb.AttachedDisk{
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb:  proto.Int64(10),
						SourceImage: proto.String(sourceImage),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(true),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
			},
			MachineType:    proto.String(machineType),
			MinCpuPlatform: proto.String("Intel Cascade Lake"),
			Name:           proto.String(instanceName),
			NetworkInterfaces: []*computepb.NetworkInterface{
				{
					Name: proto.String("global/networks/default"),
				},
			},
			// specifies particular reservation, which should be consumed
			ReservationAffinity: &computepb.ReservationAffinity{
				ConsumeReservationType: proto.String("SPECIFIC_RESERVATION"),
				Key:                    proto.String("compute.googleapis.com/reservation-name"),
				Values:                 []string{sharedReservation},
			},
		},
	}

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

	if op != nil {
		if err = op.Wait(ctx); err != nil {
			return fmt.Errorf("unable to wait for the operation: %w", err)
		}
	}
	fmt.Fprintf(w, "Instance created from shared reservation\n")

	return nil
}

Java

import static com.google.cloud.compute.v1.ReservationAffinity.ConsumeReservationType.SPECIFIC_RESERVATION;

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.ReservationAffinity;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ConsumeSpecificSharedReservation {
  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 the reservation is located.
    String zone = "us-central1-a";
    // Name of the reservation you want to query.
    String reservationName = "YOUR_RESERVATION_NAME";
    // Name of the VM instance you want to query.
    String instanceName = "YOUR_INSTANCE_NAME";
    // machineType: machine type of the VM being created.
    // *   For a list of machine types, see https://cloud.google.com/compute/docs/machine-types
    String machineTypeName = "n1-standard-4";
    // sourceImage: path to the operating system image to mount.
    // *   For details about images you can mount, see https://cloud.google.com/compute/docs/images
    String sourceImage = "projects/debian-cloud/global/images/family/debian-11";
    // diskSizeGb: storage size of the boot disk to attach to the instance.
    long diskSizeGb = 10L;
    // networkName: network interface to associate with the instance.
    String networkName = "default";
    // Minimum CPU platform of the instances.
    String minCpuPlatform = "Intel Skylake";

    createInstanceAsync(projectId, zone, instanceName, reservationName, machineTypeName,
        sourceImage, diskSizeGb, networkName, minCpuPlatform);
  }

  // Create a virtual machine targeted with the reserveAffinity field.
  // Ensure that the VM's properties match the reservation's VM properties.
  public static Instance createInstanceAsync(String projectId, String zone, String instanceName,
      String reservationName, String machineTypeName, String sourceImage, long diskSizeGb,
      String networkName, String minCpuPlatform)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    String machineType = String.format("zones/%s/machineTypes/%s", zone, machineTypeName);
    // To consume this reservation from any consumer projects that this reservation is shared with,
    // you must also specify the owner project of the reservation - the path to the reservation.
    String reservationPath =
        String.format("projects/%s/reservations/%s", projectId, reservationName);
    // 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 (InstancesClient instancesClient = InstancesClient.create()) {
      AttachedDisk disk =
          AttachedDisk.newBuilder()
              .setBoot(true)
              .setAutoDelete(true)
              .setType(AttachedDisk.Type.PERSISTENT.toString())
              .setDeviceName("disk-1")
              .setInitializeParams(
                  AttachedDiskInitializeParams.newBuilder()
                      .setSourceImage(sourceImage)
                      .setDiskSizeGb(diskSizeGb)
                      .build())
              .build();

      NetworkInterface networkInterface = NetworkInterface.newBuilder()
          .setName(networkName)
          .build();

      ReservationAffinity reservationAffinity =
          ReservationAffinity.newBuilder()
              .setConsumeReservationType(SPECIFIC_RESERVATION.toString())
              .setKey("compute.googleapis.com/reservation-name")
              // Set specific reservation
              .addValues(reservationPath)
              .build();

      Instance instanceResource =
          Instance.newBuilder()
              .setName(instanceName)
              .setMachineType(machineType)
              .addDisks(disk)
              .addNetworkInterfaces(networkInterface)
              .setMinCpuPlatform(minCpuPlatform)
              .setReservationAffinity(reservationAffinity)
              .build();

      InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setInstanceResource(instanceResource)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.insertAsync(
          insertInstanceRequest);
      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        return null;
      }
      return instancesClient.get(projectId, zone, instanceName);
    }
  }
}

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 consume_specific_shared_project_reservation(
    owner_project_id: str,
    shared_project_id: str,
    zone: str,
    reservation_name: str,
    instance_name: str,
    machine_type: str = "n1-standard-1",
    min_cpu_platform: str = "Intel Ivy Bridge",
) -> compute_v1.Instance:
    """
    Creates a specific reservation in a single project and launches a VM
    that consumes the newly created reservation.
    Args:
        owner_project_id (str): The ID of the Google Cloud project.
        shared_project_id: The ID of the owner project of the reservation in the same zone.
        zone (str): The zone to create the reservation.
        reservation_name (str): The name of the reservation to create.
        instance_name (str): The name of the instance to create.
        machine_type (str): The machine type for the instance.
        min_cpu_platform (str): The minimum CPU platform for the instance.
    """
    instance_properties = (
        compute_v1.AllocationSpecificSKUAllocationReservedInstanceProperties(
            machine_type=machine_type,
            min_cpu_platform=min_cpu_platform,
        )
    )

    reservation = compute_v1.Reservation(
        name=reservation_name,
        specific_reservation=compute_v1.AllocationSpecificSKUReservation(
            count=3,
            instance_properties=instance_properties,
        ),
        # Only VMs that target the reservation by name can consume from this reservation
        specific_reservation_required=True,
        share_settings=compute_v1.ShareSettings(
            share_type="SPECIFIC_PROJECTS",
            project_map={
                shared_project_id: compute_v1.ShareSettingsProjectConfig(
                    project_id=shared_project_id
                )
            },
        ),
    )

    # Create a reservation client
    client = compute_v1.ReservationsClient()
    operation = client.insert(
        project=owner_project_id,
        zone=zone,
        reservation_resource=reservation,
    )
    wait_for_extended_operation(operation, "Reservation creation")

    instance = compute_v1.Instance()
    instance.name = instance_name
    instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
    instance.min_cpu_platform = min_cpu_platform
    instance.zone = zone

    # Set the reservation affinity to target the specific reservation
    instance.reservation_affinity = compute_v1.ReservationAffinity(
        consume_reservation_type="SPECIFIC_RESERVATION",  # Type of reservation to consume
        key="compute.googleapis.com/reservation-name",
        # To consume this reservation from any consumer projects, specify the owner project of the reservation
        values=[f"projects/{owner_project_id}/reservations/{reservation_name}"],
    )
    # Define the disks for the instance
    instance.disks = [
        compute_v1.AttachedDisk(
            boot=True,  # Indicates that this is a boot disk
            auto_delete=True,  # The disk will be deleted when the instance is deleted
            initialize_params=compute_v1.AttachedDiskInitializeParams(
                source_image="projects/debian-cloud/global/images/family/debian-11",
                disk_size_gb=10,
            ),
        )
    ]
    instance.network_interfaces = [
        compute_v1.NetworkInterface(
            network="global/networks/default",  # The network to use
            access_configs=[
                compute_v1.AccessConfig(
                    name="External NAT",  # Name of the access configuration
                    type="ONE_TO_ONE_NAT",  # Type of access configuration
                )
            ],
        )
    ]
    # Create a request to insert the instance
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    # The instance will be created in the shared project
    request.project = shared_project_id
    request.instance_resource = instance

    vm_client = compute_v1.InstancesClient()
    operation = vm_client.insert(request)
    wait_for_extended_operation(operation, "instance creation")
    print(f"Instance {instance_name} from project {owner_project_id} created.")
    # The instance is created in the shared project, so we return it from there.
    return vm_client.get(project=shared_project_id, zone=zone, instance=instance_name)

REST

Créez une réservation nommée reservation-02 avec le champ specificReservationRequired défini sur true.

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

{
  "name":"reservation-02",
  "specificReservation":{
    "count":"10",
    "instanceProperties":{
      "machineType":"n2-standard-32",
      "minCpuPlatform": "Intel Cascade Lake"
    }
  },
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "project-1": {
        "projectId": "project-1"
      },
      "project-2": {
        "projectId": "project-2"
      }
    }
  },
  "specificReservationRequired": true
}

Créez une VM ciblant reservation-02 par son nom à l'aide du champ reservationAffinity. Pour utiliser cette réservation à partir de tous les projets clients avec lesquels elle est partagée, vous devez également spécifier le projet propriétaire de la réservation, my-owner-project.

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

{
  "name": "instance-2",
  "machineType": "zones/us-central1-a/machineTypes/n2-standard-32",
  "minCpuPlatform": "Intel Cascade Lake",
  "disks": [
    {
      "boot": true,
      "initializeParams": {
        "sourceImage": "projects/debian-clouid/global/images/family/debian-12"
      }
    }
  ],
  "networkInterfaces": [
    {
      "network": "global/networks/default"
    }
  ],
  "reservationAffinity": {
    "consumeReservationType": "SPECIFIC_RESERVATION",
    "key": "compute.googleapis.com/reservation-name",
    "values": [
      "projects/my-owner-project/reservations/reservation-02"
    ]
  }
}

Créer des VM sans consommer de réservations

Si vous créez une réservation utilisée automatiquement, toutes les VM en cours d'exécution de votre projet avec des propriétés correspondantes peuvent utiliser la réservation. Pour empêcher une ou plusieurs de vos VM de consommer la réservation, procédez comme suit:

Définissez la propriété d'affinité de réservation des VM pour qu'elles ne consomment explicitement aucune réservation, comme décrit dans cette section.
Assurez-vous que vos VM ne correspondent pas aux propriétés de VM de la réservation.

Pour créer des VM qui ne consomment pas de réservations explicitement, sélectionnez l'une des méthodes suivantes:

Créez une VM pour ne pas consommer de réservations.
Créez un modèle d'instance pour ne pas utiliser de réservations.

Créer une VM pour ne pas consommer de réservations

Pour créer une VM qui ne consomme pas de réservations explicitement, sélectionnez l'une des options suivantes:

Console

Accédez à la page Créer une instance dans Google Cloud Console.

Accéder à la page Créer une instance
Dans le champ Nom, saisissez un nom pour la VM.
Dans les listes Région et Zone, sélectionnez la région et la zone dans lesquelles créer la VM.
Dans la section Configuration de la machine, spécifiez le type de machine à utiliser pour la VM.
Développez la section Options avancées et procédez comme suit :
1. Développez la section Gestion.
2. Dans la section Réservations, dans la liste Règle d'application, sélectionnez Ne pas utiliser.
Cliquez sur Créer.

gcloud

Pour créer une VM qui ne consomme pas de réservations explicitement, exécutez la commande gcloud compute instances create avec l'option --reservation-affinity=none.

gcloud compute instances create VM_NAME \
    --machine-type=MACHINE_TYPE \
    --reservation-affinity=none \
    --zone=ZONE

Remplacez les éléments suivants :

VM_NAME : Nom de la VM.
MACHINE_TYPE : type de machine à utiliser pour la VM.
ZONE : Zone dans laquelle créer l'instance de VM.

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

// createInstanceNotConsumeReservation creates VM, without consuming reservation
func createInstanceNotConsumeReservation(w io.Writer, projectID, zone, instanceName string) error {
	ctx := context.Background()
	machineType := fmt.Sprintf("zones/%s/machineTypes/%s", zone, "n2-standard-32")
	sourceImage := "projects/debian-cloud/global/images/family/debian-12"

	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer instancesClient.Close()

	req := &computepb.InsertInstanceRequest{
		Project: projectID,
		Zone:    zone,
		InstanceResource: &computepb.Instance{
			Disks: []*computepb.AttachedDisk{
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb:  proto.Int64(10),
						SourceImage: proto.String(sourceImage),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(true),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
			},
			MachineType:    proto.String(machineType),
			MinCpuPlatform: proto.String("Intel Cascade Lake"),
			Name:           proto.String(instanceName),
			NetworkInterfaces: []*computepb.NetworkInterface{
				{
					Name: proto.String("global/networks/default"),
				},
			},
			ReservationAffinity: &computepb.ReservationAffinity{
				ConsumeReservationType: proto.String("NO_RESERVATION"),
			},
		},
	}

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

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

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

	return nil
}

Java

import static com.google.cloud.compute.v1.ReservationAffinity.ConsumeReservationType.NO_RESERVATION;

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.ReservationAffinity;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateInstanceWithoutConsumingReservation {
  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 you want to use.
    String zone = "us-central1-a";
    // Name of the VM instance you want to query.
    String instanceName = "YOUR_INSTANCE_NAME";
    // machineType: machine type of the VM being created.
    // *   This value uses the format zones/{zone}/machineTypes/{type_name}.
    // *   For a list of machine types, see https://cloud.google.com/compute/docs/machine-types
    String machineTypeName = "n1-standard-1";
    // sourceImage: path to the operating system image to mount.
    // *   For details about images you can mount, see https://cloud.google.com/compute/docs/images
    String sourceImage = "projects/debian-cloud/global/images/family/debian-11";
    // diskSizeGb: storage size of the boot disk to attach to the instance.
    long diskSizeGb = 10L;
    // networkName: network interface to associate with the instance.
    String networkName = "default";

    createInstanceWithoutConsumingReservationAsync(projectId, zone, instanceName,
        machineTypeName, sourceImage, diskSizeGb, networkName);
  }

  // Create a virtual machine that explicitly doesn't consume reservations
  public static Instance createInstanceWithoutConsumingReservationAsync(
      String project, String zone, String instanceName,
      String machineTypeName, String sourceImage, long diskSizeGb, String networkName)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    String machineType = String.format("zones/%s/machineTypes/%s", zone, machineTypeName);

    // 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 (InstancesClient instancesClient = InstancesClient.create()) {
      AttachedDisk disk =
          AttachedDisk.newBuilder()
              .setBoot(true)
              .setAutoDelete(true)
              .setType(AttachedDisk.Type.PERSISTENT.toString())
              .setDeviceName("disk-1")
              .setInitializeParams(
                  AttachedDiskInitializeParams.newBuilder()
                      .setSourceImage(sourceImage)
                      .setDiskSizeGb(diskSizeGb)
                      .build())
              .build();

      NetworkInterface networkInterface = NetworkInterface.newBuilder()
          .setName(networkName)
          .build();

      ReservationAffinity reservationAffinity =
          ReservationAffinity.newBuilder()
              .setConsumeReservationType(NO_RESERVATION.toString())
              .build();

      Instance instanceResource =
          Instance.newBuilder()
              .setName(instanceName)
              .setMachineType(machineType)
              .addDisks(disk)
              .addNetworkInterfaces(networkInterface)
              .setReservationAffinity(reservationAffinity)
              .build();

      InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstanceResource(instanceResource)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.insertAsync(
          insertInstanceRequest);

      // Wait for the operation to complete.
      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        return null;
      }
      return instancesClient.get(project, zone, instanceName);
    }
  }
}

Node.js

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

// Instantiate a reservationsClient
const instancesClient = new computeLib.InstancesClient();
// 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 create instance.
const projectId = await instancesClient.getProjectId();
// The zone in which to create instance.
const zone = 'us-central1-a';
// The name of the instance to create.
// const instanceName = 'instance-01';
// Machine type to use for VM.
const machineType = 'n1-standard-4';

// Create a VM that explicitly doesn't consume reservations
async function callCreateInstanceToNotConsumeReservation() {
  // Describe the size and source image of the boot disk to attach to the instance.
  const disk = new compute.Disk({
    boot: true,
    autoDelete: true,
    type: 'PERSISTENT',
    initializeParams: {
      diskSizeGb: '10',
      sourceImage: 'projects/debian-cloud/global/images/family/debian-12',
    },
  });

  //  Define networkInterface
  const networkInterface = new compute.NetworkInterface({
    name: 'global/networks/default',
  });

  // Define reservationAffinity
  const reservationAffinity = new compute.ReservationAffinity({
    consumeReservationType: 'NO_RESERVATION',
  });

  // Create an instance
  const instance = new compute.Instance({
    name: instanceName,
    machineType: `zones/${zone}/machineTypes/${machineType}`,
    minCpuPlatform: 'Intel Skylake',
    disks: [disk],
    networkInterfaces: [networkInterface],
    reservationAffinity,
  });

  const [response] = await instancesClient.insert({
    project: projectId,
    instanceResource: instance,
    zone,
  });

  let operation = response.latestResponse;

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

  console.log(`Instance ${instanceName} created.`);
}

await callCreateInstanceToNotConsumeReservation();

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_vm_not_consume_reservation(
    project_id: str, zone: str, instance_name: str, machine_type: str = "n2-standard-2"
) -> compute_v1.Instance:
    """Creates a VM that explicitly doesn't consume reservations
    Args:
        project_id (str): The ID of the Google Cloud project.
        zone (str): The zone where the VM will be created.
        instance_name (str): The name of the instance to create.
        machine_type (str, optional): The machine type for the instance.
    Returns:
        compute_v1.Instance: The created instance.
    """
    instance = compute_v1.Instance()
    instance.name = instance_name
    instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
    instance.zone = zone

    instance.disks = [
        compute_v1.AttachedDisk(
            boot=True,  # Indicates that this is a boot disk
            auto_delete=True,  # The disk will be deleted when the instance is deleted
            initialize_params=compute_v1.AttachedDiskInitializeParams(
                source_image="projects/debian-cloud/global/images/family/debian-11",
                disk_size_gb=10,
            ),
        )
    ]

    instance.network_interfaces = [
        compute_v1.NetworkInterface(
            network="global/networks/default",  # The network to use
            access_configs=[
                compute_v1.AccessConfig(
                    name="External NAT",  # Name of the access configuration
                    type="ONE_TO_ONE_NAT",  # Type of access configuration
                )
            ],
        )
    ]

    # Set the reservation affinity to not consume any reservation
    instance.reservation_affinity = compute_v1.ReservationAffinity(
        consume_reservation_type="NO_RESERVATION",  # Prevents the instance from consuming reservations
    )

    # Create a request to insert the instance
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

    vm_client = compute_v1.InstancesClient()
    operation = vm_client.insert(request)
    wait_for_extended_operation(operation, "Instance creation")

    print(f"Creating the {instance_name} instance in {zone}...")

    return vm_client.get(project=project_id, zone=zone, instance=instance_name)

REST

Pour créer une VM qui ne consomme pas de réservations explicitement, envoyez une requête POST à la méthode instances.insert. Dans le corps de la requête, incluez le champ consumeReservationType défini sur NO_RESERVATION.

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

{
  "name": "VM_NAME",
  "machineType": "zones/ZONE/machineTypes/MACHINE_TYPE",
  "disks": [
    {
      "boot": true,
      "initializeParams": {
        "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
      }
    }
  ],
  "networkInterfaces": [
    {
      "network": "global/networks/default"
    }
  ],
  "reservationAffinity": {
    "consumeReservationType": "NO_RESERVATION"
  }
}

Remplacez les éléments suivants :

PROJECT_ID : ID du projet dans lequel la VM sera créée.
ZONE : Zone dans laquelle créer l'instance de VM.
VM_NAME : Nom de la VM.
MACHINE_TYPE : type de machine à utiliser pour la VM.
IMAGE_PROJECT : projet d'image contenant l'image d'OS ; par exemple, debian-cloud. Pour en savoir plus sur les projets d'image compatibles, consultez la page Images publiques.
IMAGE : spécifiez l'une des options suivantes :
- Version spécifique de l'image de l'OS. Exemple : debian-12-bookworm-v20240617
- Une famille d'images, qui doit être au format family/IMAGE_FAMILY. Cela permet de spécifier l'image d'OS non obsolète la plus récente. Par exemple, si vous spécifiez family/debian-12, la dernière version de la famille d'images Debian 12 est utilisée. Pour en savoir plus sur l'utilisation des familles d'images, consultez la page Bonnes pratiques concernant les familles d'images.

Pour en savoir plus sur la création d'une VM, consultez la section Créer et démarrer une instance Compute Engine.

Créer un modèle d'instance pour ne pas consommer de réservations

Pour créer un modèle d'instance qui crée des VM qui ne consomment pas explicitement de réservations, sélectionnez l'une des options suivantes:

Console

Dans la console Google Cloud, accédez à la page Créer un modèle d'instance.

Accédez à la page Créer un modèle d'instance.
Dans le champ Nom, saisissez un nom pour le modèle d'instance.
Dans la section Emplacement, indiquez si vous souhaitez créer un modèle d'instance régional (par défaut) ou global.
Dans la section Configuration de la machine, spécifiez le type de machine à utiliser pour les VM créées à l'aide du modèle.
Développez la section Options avancées et procédez comme suit :
1. Développez la section Gestion.
2. Dans la section Réservations, dans la liste Règle d'application, sélectionnez Ne pas utiliser.
Cliquez sur Créer.

gcloud

Pour créer un modèle d'instance qui crée des VM qui ne consomment pas explicitement de réservations, exécutez la commande gcloud compute instances-templates create avec l'option --reservation-affinity=none.

Par exemple, pour créer un modèle d'instance global qui crée des VM qui ne consomment pas explicitement de réservations, exécutez la commande suivante:

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --machine-type=MACHINE_TYPE \
    --reservation-affinity=none

Remplacez les éléments suivants :

INSTANCE_TEMPLATE_NAME : nom du modèle d'instance.
MACHINE_TYPE: type de machine à utiliser pour les VM créées à l'aide du modèle d'instance.

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

// createInstanceNotConsumeReservation creates a new instance template, which won't consume reservations
func createTemplateNotConsumeReservation(w io.Writer, projectID, templateName string) error {
	// projectID := "your_project_id"
	// templateName := "your_template_name"

	ctx := context.Background()
	instanceTemplatesClient, err := compute.NewInstanceTemplatesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstanceTemplatesRESTClient: %w", err)
	}
	defer instanceTemplatesClient.Close()

	req := &computepb.InsertInstanceTemplateRequest{
		Project: projectID,
		InstanceTemplateResource: &computepb.InstanceTemplate{
			Name: proto.String(templateName),
			Properties: &computepb.InstanceProperties{
				// The template describes the size and source image of the boot disk
				// to attach to the instance.
				Disks: []*computepb.AttachedDisk{
					{
						InitializeParams: &computepb.AttachedDiskInitializeParams{
							DiskSizeGb:  proto.Int64(250),
							SourceImage: proto.String("projects/debian-cloud/global/images/family/debian-11"),
						},
						AutoDelete: proto.Bool(true),
						Boot:       proto.Bool(true),
					},
				},
				MachineType: proto.String("e2-standard-4"),
				// The template connects the instance to the `default` network,
				// without specifying a subnetwork.
				NetworkInterfaces: []*computepb.NetworkInterface{
					{
						Name: proto.String("global/networks/default"),
						// The template lets the instance use an external IP address.
						AccessConfigs: []*computepb.AccessConfig{
							{
								Name:        proto.String("External NAT"),
								Type:        proto.String(computepb.AccessConfig_ONE_TO_ONE_NAT.String()),
								NetworkTier: proto.String(computepb.AccessConfig_PREMIUM.String()),
							},
						},
					},
				},
				ReservationAffinity: &computepb.ReservationAffinity{
					ConsumeReservationType: proto.String("NO_RESERVATION"),
				},
			},
		},
	}

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

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

	fmt.Fprintf(w, "Instance template created\n")

	return nil
}

Java

import static com.google.cloud.compute.v1.ReservationAffinity.ConsumeReservationType.NO_RESERVATION;

import com.google.cloud.compute.v1.AccessConfig;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.InsertInstanceTemplateRequest;
import com.google.cloud.compute.v1.InstanceProperties;
import com.google.cloud.compute.v1.InstanceTemplate;
import com.google.cloud.compute.v1.InstanceTemplatesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.ReservationAffinity;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateTemplateWithoutConsumingReservation {
  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 template you want to query.
    String templateName = "YOUR_INSTANCE_TEMPLATE_NAME";
    String machineType = "e2-standard-4";
    String sourceImage = "projects/debian-cloud/global/images/family/debian-11";

    createTemplateWithoutConsumingReservationAsync(
        projectId, templateName, machineType, sourceImage);
  }


  // Create a template that explicitly doesn't consume any reservations.
  public static InstanceTemplate createTemplateWithoutConsumingReservationAsync(
      String projectId, String templateName, String machineType, String sourceImage)
      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 (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create()) {
      AttachedDisk attachedDisk = AttachedDisk.newBuilder()
          .setInitializeParams(AttachedDiskInitializeParams.newBuilder()
              .setSourceImage(sourceImage)
              .setDiskType("pd-balanced")
              .setDiskSizeGb(250)
              .build())
          .setAutoDelete(true)
          .setBoot(true)
          .build();

      NetworkInterface networkInterface = NetworkInterface.newBuilder()
          .setName("global/networks/default")
          .addAccessConfigs(AccessConfig.newBuilder()
              .setName("External NAT")
              .setType(AccessConfig.Type.ONE_TO_ONE_NAT.toString())
              .setNetworkTier(AccessConfig.NetworkTier.PREMIUM.toString())
              .build())
          .build();

      ReservationAffinity reservationAffinity =
          ReservationAffinity.newBuilder()
              .setConsumeReservationType(NO_RESERVATION.toString())
              .build();

      InstanceProperties instanceProperties = InstanceProperties.newBuilder()
          .addDisks(attachedDisk)
          .setMachineType(machineType)
          .setReservationAffinity(reservationAffinity)
          .addNetworkInterfaces(networkInterface)
          .build();

      InsertInstanceTemplateRequest insertInstanceTemplateRequest = InsertInstanceTemplateRequest
          .newBuilder()
          .setProject(projectId)
          .setInstanceTemplateResource(InstanceTemplate.newBuilder()
              .setName(templateName)
              .setProperties(instanceProperties)
              .build())
          .build();

      Operation response = instanceTemplatesClient.insertAsync(insertInstanceTemplateRequest)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        return null;
      }
      return instanceTemplatesClient.get(projectId, templateName);
    }
  }
}

Node.js

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

// Instantiate an instanceTemplatesClient
const instanceTemplatesClient = new computeLib.InstanceTemplatesClient();
// Instantiate a globalOperationsClient
const globalOperationsClient = new computeLib.GlobalOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The ID of the project where you want to create template.
const projectId = await instanceTemplatesClient.getProjectId();
// The name of the template to create.
// const templateName = 'instance-01';

// Create an instance template that creates VMs that don't explicitly consume reservations
async function callCreateTemplateToNotConsumeReservation() {
  // Define the boot disk for the instance template
  const disk = new compute.AttachedDisk({
    initializeParams: new compute.AttachedDiskInitializeParams({
      sourceImage:
        'projects/debian-cloud/global/images/debian-12-bookworm-v20240815',
      diskSizeGb: '100',
      diskType: 'pd-balanced',
    }),
    autoDelete: true,
    boot: true,
    type: 'PERSISTENT',
  });

  // Define the network interface for the instance template
  const network = new compute.NetworkInterface({
    network: `projects/${projectId}/global/networks/default`,
  });

  // Define reservationAffinity
  const reservationAffinity = new compute.ReservationAffinity({
    consumeReservationType: 'NO_RESERVATION',
  });

  // Define instance template
  const instanceTemplate = new compute.InstanceTemplate({
    name: templateName,
    properties: {
      disks: [disk],
      machineType: 'e2-medium',
      // The template connects the instance to the `default` network,
      // without specifying a subnetwork.
      networkInterfaces: [network],
      reservationAffinity,
    },
  });

  const [response] = await instanceTemplatesClient.insert({
    project: projectId,
    instanceTemplateResource: instanceTemplate,
  });

  let operation = response.latestResponse;

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

  console.log(`Template ${templateName} created.`);
}

await callCreateTemplateToNotConsumeReservation();

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_instance_template_not_consume_reservation(
    project_id: str,
    template_name: str,
    machine_type: str = "n1-standard-1",
) -> compute_v1.InstanceTemplate:
    """
    Creates an instance template that creates VMs that don't explicitly consume reservations

    Args:
        project_id: project ID or project number of the Cloud project you use.
        template_name: name of the new template to create.
        machine_type: machine type for the instance.
    Returns:
        InstanceTemplate object that represents the new instance template.
    """

    template = compute_v1.InstanceTemplate()
    template.name = template_name
    template.properties.machine_type = machine_type
    # The template describes the size and source image of the boot disk
    # to attach to the instance.
    template.properties.disks = [
        compute_v1.AttachedDisk(
            boot=True,
            auto_delete=True,  # The disk will be deleted when the instance is deleted
            initialize_params=compute_v1.AttachedDiskInitializeParams(
                source_image="projects/debian-cloud/global/images/family/debian-11",
                disk_size_gb=10,
            ),
        )
    ]
    # The template connects the instance to the `default` network,
    template.properties.network_interfaces = [
        compute_v1.NetworkInterface(
            network="global/networks/default",
            access_configs=[
                compute_v1.AccessConfig(
                    name="External NAT",
                    type="ONE_TO_ONE_NAT",
                )
            ],
        )
    ]
    # The template doesn't explicitly consume reservations
    template.properties.reservation_affinity = compute_v1.ReservationAffinity(
        consume_reservation_type="NO_RESERVATION"
    )

    template_client = compute_v1.InstanceTemplatesClient()
    operation = template_client.insert(
        project=project_id, instance_template_resource=template
    )

    wait_for_extended_operation(operation, "instance template creation")

    return template_client.get(project=project_id, instance_template=template_name)

REST

Pour créer un modèle d'instance qui crée des VM qui ne consomment pas explicitement de réservations, envoyez une requête POST à l'une des méthodes suivantes:

Pour créer un modèle d'instance global : méthode instanceTemplates.insert.
Pour créer un modèle d'instance régional : méthode regionInstanceTemplates.insert.

Dans le corps de la requête, incluez le champ consumeReservationType et définissez-le sur NO_RESERVATION.

Par exemple, pour créer un modèle d'instance global qui crée des VM qui ne consomment pas explicitement de réservations, envoyez une requête comme suit:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/InstanceTemplates

{
  "name": "INSTANCE_TEMPLATE_NAME",
  "properties": {
    "machineType": "MACHINE_TYPE",
    "disks": [
      {
        "boot": true,
        "initializeParams": {
          "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
        }
      }
    ],
    "networkInterfaces": [
      {
        "network": "global/networks/default"
      }
    ],
    "reservationAffinity": {
      "consumeReservationType": "NO_RESERVATION"
    }
  }
}

Remplacez les éléments suivants :

PROJECT_ID: ID du projet dans lequel créer le modèle d'instance.
INSTANCE_TEMPLATE_NAME : nom du modèle d'instance.
MACHINE_TYPE: type de machine à utiliser pour les VM créées à l'aide du modèle d'instance.
IMAGE_PROJECT : projet d'image contenant l'image d'OS ; par exemple, debian-cloud. Pour en savoir plus sur les projets d'image compatibles, consultez la page Images publiques.
IMAGE : spécifiez l'une des options suivantes :
- Version spécifique de l'image de l'OS. Exemple : debian-12-bookworm-v20240617
- Une famille d'images, qui doit être au format family/IMAGE_FAMILY. Cela permet de spécifier l'image d'OS non obsolète la plus récente. Par exemple, si vous spécifiez family/debian-12, la dernière version de la famille d'images Debian 12 est utilisée. Pour en savoir plus sur l'utilisation des familles d'images, consultez la page Bonnes pratiques concernant les familles d'images.

Pour en savoir plus sur la création de modèles d'instances, consultez la section Création de modèles d'instances.

Tester la correspondance entre les propriétés d'une VM et une réservation

Pour vérifier si les VM peuvent consommer automatiquement une réservation, vous pouvez créer une copie de la réservation en tant que réservation spécifique, puis vérifier si une VM que vous prévoyez de créer peut consommer cette réservation. Si vous pouvez créer la VM, vous avez vérifié qu'elle peut utiliser correctement la réservation correspondante. Sinon, la création de la VM échoue, car les propriétés ne correspondent pas ou aucune ressource réservée n'est disponible. Une fois les tests effectués, vous pouvez effectuer l'une ou plusieurs des opérations suivantes :

Supprimez ou mettez à jour la réservation spécifique que vous avez utilisée pour les tests.
Supprimez la VM ou mettez-la à jour pour qu'elle ait une autre affinité de réservation (reservationAffinity).

Vérifier la consommation des réservations

Pour vous assurer que vos VM consomment effectivement vos réservations, vous pouvez vérifier leur consommation à l'aide des méthodes suivantes:

Affichez les détails de la réservation.

Si le nombre de VM consommant une réservation augmente de 1 après avoir créé ou mis à jour une VM, votre action a probablement entraîné l'utilisation de la réservation par la VM. Il s'agit du moyen le plus rapide de vérifier si une réservation est consommée. Toutefois, il est possible que la vérification de la VM exacte qui utilise la réservation ne fonctionne pas correctement.
Créer la VM pour cibler une réservation spécifique

Si vous pouvez créer une VM qui cible une réservation spécifique, la VM utilise la réservation. Il s'agit de la méthode la plus fiable pour vérifier qu'une VM spécifique consomme une réservation et que ses propriétés correspondent à celles de la réservation.
Surveiller votre consommation de réservations

Grâce à Cloud Monitoring, vous pouvez accéder aux informations associées à la consommation des réservations créées dans votre projet et les afficher. La surveillance met à jour vos données de consommation de réservations au moins une fois toutes les 30 minutes. Cette méthode est utile pour vérifier la tendance de consommation d'une ou de plusieurs réservations dans un projet, ainsi que pour recevoir des notifications pour les réservations sous-utilisées ou inutilisées.

Consulter l'historique de l'utilisation de vos réservations

Grâce au planificateur de capacité (Aperçu), vous pouvez accéder à l'historique d'utilisation de vos réservations depuis leur création jusqu'à leur suppression, et l'afficher. Le planificateur de capacité met à jour les données de consommation des réservations toutes les 24 heures. Cette méthode est utile pour vérifier la consommation passée de vos réservations dans un projet, un dossier ou une organisation, et pour vous aider à planifier vos futurs besoins en capacité.

Si vous constatez qu'une VM n'utilise pas une réservation après avoir vérifié que l'affinité de réservation de la VM peut l'utiliser, que la réservation n'est pas entièrement utilisée et que les propriétés de la VM et de la réservation correspondent, consultez la section Disponibilité des ressources.

Afficher les rapports d'utilisation des réservations

Exportez des rapports détaillés sur votre utilisation de Compute Engine vers un bucket Cloud Storage à l'aide de la fonctionnalité d'exportation de l'utilisation. Pour savoir comment procéder, consultez la page Afficher les rapports d'utilisation.

Le rapport d'utilisation affiche les informations suivantes :

Les ressources réservées en cours d'utilisation. Ces entrées apparaissent comme des ressources "processeur virtuel", "mémoire", "GPU" et "SSD local" normales.
Les ressources réservées qui ne sont pas en cours d'utilisation. Ces entrées ont des codes SKU normaux et des URI de ressources de type "réservation".
Total des ressources réservées. Ces entrées ont des codes SKU et des URI de ressource de type "réservation". Aucun coût n'est associé à ces entrées. Utilisez ces entrées pour calculer la quantité de réservations que vous utilisez.

Mesure	Format `MeasurementId`	Format `Resource URI`
Ressources réservées en cours d'utilisation	`com.google.cloud/services/compute-engine/SKU_NAME`	`https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/RESOURCE_TYPE/RESOURCE_NAME`. Par exemple, `https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central1-a/instances/my-instance`
Ressources réservées non utilisées	`com.google.cloud/services/compute-engine/SKU_NAME`	`https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations/RESERVATION_NAME`. Par exemple, `https://compute.googleapis.com/compute/v1/projects/my-project/zones/europe-west1-b/reservations/my-reservation`
Total des ressources réservées	`com.google.cloud/services/compute-engine/ReservationSKU_NAME`	`https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations/RESERVATION_NAME`. Par exemple, `https://compute.googleapis.com/compute/v1/projects/my-project/zones/europe-west1-b/reservations/my-reservation`

Par exemple, dans l'extrait de rapport d'utilisation pour une réservation nommée my-reservation présenté ci-dessous :

La ligne 1 indique la quantité de mémoire RAM réservée actuellement utilisée. Le ResourceId de la ligne indique que cette mémoire RAM est utilisée par une VM nommée my-instance.
La ligne 2 indique la quantité de mémoire RAM réservée qui n'est pas utilisée. Le ResourceId de la ligne indique que cette mémoire RAM réservée est conservée par my-reservation ; elle n'est pour l'instant utilisée par aucune VM.
La ligne 3 indique la quantité totale de mémoire réservée pour la réservation.

Report Date,MeasurementId,Quantity,Unit,Resource URI,ResourceId,Location
2019-06-06,com.google.cloud/services/compute-engine/VmimageN2StandardRam,166970074857472,byte-seconds,https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central2-a/instances/my-instance,1775485842510981624,us-central2-a
2019-06-06,com.google.cloud/services/compute-engine/VmimageN2StandardRam,166970074857472,byte-seconds,https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central2-a/reservations/my-reservation,7.58809E+17,us-central2-a
2019-06-06,com.google.cloud/services/compute-engine/ReservationN2StandardRam,333940149714944,byte-seconds,https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central2-a/reservations/my-reservation,7.58809E+17,us-central2-a
...

Résoudre les problèmes

Découvrez comment résoudre les problèmes liés à l'utilisation des réservations.

Étapes suivantes

Découvrez comment surveiller la consommation des réservations.
Découvrez comment modifier des réservations.
Découvrez comment supprimer des réservations.