Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Afficher les réservations ou les demandes de réservations futures

Ce document explique comment afficher vos réservations, vos demandes de réservations futures et votre consommation de réservations. Pour en savoir plus sur les réservations, consultez Choisir un type de réservation.

Lorsque vous affichez vos réservations, vos demandes de réservations futures ou votre consommation de réservations, vous pouvez effectuer les opérations suivantes :

Affichez les paramètres de réservation. Cet examen vous aide à vérifier les détails de vos réservations, à vous assurer qu'elles répondent à vos besoins et à planifier la capacité.
Déterminez le nombre d'instances consommables. Cette vérification vous aide à déterminer le nombre d'instances Compute Engine pouvant consommer votre capacité réservée.
Afficher la consommation des réservations Cet examen vous permet de vérifier la réservation utilisée par une instance Compute Engine spécifique ou de lister toutes les instances qui utilisent une réservation particulière dans un projet.

Limites

Vous ne pouvez afficher une réservation partagée ou une requête de réservation future partagée que dans le projet dans lequel vous l'avez créée.

Avant de commencer

Si ce n'est pas déjà fait, configurez l'authentification. L'authentification permet 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 :
Sélectionnez l'onglet correspondant à la façon dont vous prévoyez d'utiliser les exemples de cette page :
Console

Lorsque vous utilisez la console Google Cloud pour accéder aux services et aux API Google Cloud , vous n'avez pas besoin de configurer l'authentification.
gcloud
1. Installez la Google Cloud CLI. Une fois l'installation terminée, initialisez la Google Cloud CLI en exécutant la commande suivante :
  gcloud init
  Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.
  
  Remarque : Si vous avez déjà installé la gcloud CLI, assurez-vous que vous disposez de la dernière version en exécutant gcloud components update.
Définissez une région et une zone par défaut.

Go

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

Installez la Google Cloud CLI.
Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.
Si vous utilisez un shell local, créez des identifiants d'authentification locaux pour votre compte utilisateur :
```
gcloud auth application-default login
```
Vous n'avez pas besoin de le faire si vous utilisez Cloud Shell.

Si une erreur d'authentification est renvoyée et que vous utilisez un fournisseur d'identité (IdP) externe, vérifiez que vous vous êtes connecté à la gcloud CLI avec votre identité fédérée.

Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Java

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

Installez la Google Cloud CLI.
Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.
Si vous utilisez un shell local, créez des identifiants d'authentification locaux pour votre compte utilisateur :
```
gcloud auth application-default login
```
Vous n'avez pas besoin de le faire si vous utilisez Cloud Shell.

Si une erreur d'authentification est renvoyée et que vous utilisez un fournisseur d'identité (IdP) externe, vérifiez que vous vous êtes connecté à la gcloud CLI avec votre identité fédérée.

Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Node.js

Pour utiliser les exemples Node.js de cette page dans un environnement de développement local, installez et initialisez la gcloud CLI, puis configurez les Identifiants par défaut de l'application avec vos identifiants utilisateur.

Installez la Google Cloud CLI.
Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.
Si vous utilisez un shell local, créez des identifiants d'authentification locaux pour votre compte utilisateur :
```
gcloud auth application-default login
```
Vous n'avez pas besoin de le faire si vous utilisez Cloud Shell.

Si une erreur d'authentification est renvoyée et que vous utilisez un fournisseur d'identité (IdP) externe, vérifiez que vous vous êtes connecté à la gcloud CLI avec votre identité fédérée.

Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Python

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

Installez la Google Cloud CLI.
Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.
Si vous utilisez un shell local, créez des identifiants d'authentification locaux pour votre compte utilisateur :
```
gcloud auth application-default login
```
Vous n'avez pas besoin de le faire si vous utilisez Cloud Shell.

Si une erreur d'authentification est renvoyée et que vous utilisez un fournisseur d'identité (IdP) externe, vérifiez que vous vous êtes connecté à la gcloud CLI avec votre identité fédérée.

Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

REST

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

Installez la Google Cloud CLI.

Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

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

Rôles requis

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

Ce rôle prédéfini contient les autorisations requises pour afficher les réservations ou les demandes de réservations futures. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Vous devez disposer des autorisations suivantes pour afficher les réservations ou les demandes de réservations futures :

Pour afficher la liste des réservations : compute.reservations.list sur le projet
Pour afficher la liste des demandes de réservations futures : compute.futureReservations.list sur le projet
Pour afficher les détails d'une réservation : compute.reservations.get sur le projet
Pour afficher les détails d'une demande de réservation future : compute.futureReservations.get sur le projet

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

Afficher les paramètres de réservation

Les sections suivantes expliquent comment afficher les paramètres de vos réservations ou de vos demandes de réservations futures.

Afficher les réservations

Pour afficher les paramètres d'une ou de plusieurs réservations, utilisez l'une des méthodes suivantes décrites dans cette section :

Pour obtenir un aperçu de toutes les réservations de votre projet, affichez la liste de vos réservations.
Pour afficher tous les détails d'une réservation, consultez-les.

Pour afficher les champs deleteAtTime et reservationSharingPolicy (aperçu) dans une réservation, affichez les détails d'une réservation à l'aide de Google Cloud CLI ou affichez les réservations à l'aide de l'API REST. Si vous n'avez pas besoin de ces champs, affichez les réservations en sélectionnant l'une des options suivantes :

Console

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

Accéder à la page "Réservations"

Dans l'onglet Réservations à la demande (par défaut), le tableau liste chaque réservation et chaque colonne décrit une propriété.
Facultatif : Dans le tableau Réservations à la demande, effectuez l'une des opérations suivantes, ou les deux :
- Pour afficher le nombre garanti de vos réservations, cliquez sur Options d'affichage des colonnes..., cochez la case Nombre garanti, puis cliquez sur OK.
- Pour affiner votre liste de réservations, sélectionnez les propriétés par lesquelles vous souhaitez filtrer les réservations dans le champ Filtre.
Pour afficher les détails d'une réservation, cliquez sur son nom dans la colonne Nom. Une page indiquant les détails de la réservation s'affiche.

gcloud

Pour afficher la liste de vos réservations, utilisez la commande gcloud compute reservations list :
```
gcloud compute reservations list
```
Le résultat ressemble à celui de l'exemple ci-dessous.
```
NAME: r-01
IN_USE_COUNT: 0
COUNT: 5
ZONE: us-central1-a
SHARE_TYPE: LOCAL

NAME: r-02
IN_USE_COUNT: 3
COUNT: 10
ZONE: us-central1-f
SHARE_TYPE: LOCAL
```
Vous pouvez également affiner une liste de réservations à l'aide d'une expression de filtre en incluant l'option --filter :
```
gcloud compute reservations list \
    --filter="FILTER_EXPRESSION"
```
Remplacez FILTER_EXPRESSION par une expression de filtre.

Pour afficher les détails d'une réservation, utilisez la commande gcloud compute reservations describe :

gcloud compute reservations describe RESERVATION_NAME \
    --zone=ZONE

Remplacez les éléments suivants :

RESERVATION_NAME : nom d'une réservation existante.
ZONE : zone où se trouve la réservation.

Le résultat ressemble à celui de l'exemple ci-dessous.

creationTimestamp: '2024-10-11T03:25:23.192-07:00'
id: '4488228526648280060'
kind: compute#reservation
name: r-01
selfLink: https://www.googleapis.com/compute/v1/projects/my-project/zones/us-central1-a/reservations/r-01
shareSettings:
  shareType: LOCAL
specificReservation:
  assuredCount: '50'
  count: '50'
  inUseCount: '25'
  instanceProperties:
    machineType: n2-standard-2
specificReservationRequired: false
status: READY
zone: https://www.googleapis.com/compute/v1/projects/my-project/zones/us-central1-a

Go

Pour afficher la liste de vos réservations, utilisez l'exemple de code suivant :

// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package snippets

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/api/iterator"
)

// Get list of reservations for given project in particular zone
func listReservations(w io.Writer, projectID, zone string) error {
	// projectID := "your_project_id"
	// zone := "us-west3-a"

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

	req := &computepb.ListReservationsRequest{
		Project: projectID,
		Zone:    zone,
	}

	it := reservationsClient.List(ctx, req)
	fmt.Fprintf(w, "Instances found in zone %s:\n", zone)
	for {
		instance, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "- %s %d\n", instance.GetName(), instance.GetSpecificReservation().GetCount())
	}

	return nil
}

Pour afficher les détails d'une réservation, utilisez l'exemple de code suivant :

// Copyright 2024 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package snippets

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
)

// Get certain reservation for given project and zone
func getReservation(w io.Writer, projectID, zone, reservationName string) (*computepb.Reservation, error) {
	// projectID := "your_project_id"
	// zone := "us-west3-a"
	// reservationName := "your_reservation_name"

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

	req := &computepb.GetReservationRequest{
		Project:     projectID,
		Reservation: reservationName,
		Zone:        zone,
	}

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

	fmt.Fprintf(w, "Reservation: %s\n", reservation.GetName())

	return reservation, nil
}

Java

Pour afficher la liste de vos réservations, utilisez l'exemple de code suivant :

/*
 * Copyright 2024 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package compute.reservation;

import com.google.cloud.compute.v1.Reservation;
import com.google.cloud.compute.v1.ReservationsClient;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class ListReservations {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String project = "YOUR_PROJECT_ID";
    // Zone in which reservations are located.
    String zone = "us-central1-a";

    listReservations(project, zone);
  }

  // List all reservations in the given project and zone.
  public static List<Reservation> listReservations(String project, String zone) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    List<Reservation> listOfReservations = new ArrayList<>();

    try (ReservationsClient reservationsClient = ReservationsClient.create()) {
      for (Reservation reservation : reservationsClient.list(project, zone).iterateAll()) {
        listOfReservations.add(reservation);
        System.out.println("Reservation: " + reservation.getName());
      }
    }
    return listOfReservations;
  }
}

Pour afficher les détails d'une réservation, utilisez l'exemple de code suivant :

/*
 * Copyright 2024 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package compute.reservation;

import com.google.cloud.compute.v1.Reservation;
import com.google.cloud.compute.v1.ReservationsClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeoutException;

public class GetReservation {

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

    getReservation(projectId, reservationName, zone);
  }

  // Retrieve a reservation with the given name in the given zone.
  public static Reservation getReservation(
      String projectId, String reservationName, String zone)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (ReservationsClient reservationsClient = ReservationsClient.create()) {

      // Get the reservation.
      Reservation reservation = reservationsClient.get(projectId, zone, reservationName);

      System.out.println("Reservation: " + reservation.getName());
      return reservation;
    }
  }
}

Node.js

Pour afficher la liste de vos réservations, utilisez l'exemple de code suivant :

/*
 * Copyright 2024 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

'use strict';

async function main() {
  // Import the Compute library
  const computeLib = require('@google-cloud/compute');

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

  /**
   * TODO(developer): Update these variables before running the sample.
   */
  // The ID of the project where your reservations are located.
  const projectId = await reservationsClient.getProjectId();
  // The zone where your reservations are located.
  const zone = 'us-central1-a';

  async function callGetReservations() {
    const reservations = (
      await reservationsClient.list({
        project: projectId,
        zone,
      })
    )[0];

    console.log(JSON.stringify(reservations));
  }

  await callGetReservations();
}

main().catch(err => {
  console.error(err);
  process.exitCode = 1;
});

Pour afficher les détails d'une réservation, utilisez l'exemple de code suivant :

/*
 * Copyright 2024 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

'use strict';

async function main(reservationName) {
  // Import the Compute library
  const computeLib = require('@google-cloud/compute');

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

  /**
   * TODO(developer): Update/uncomment these variables before running the sample.
   */
  // The ID of the project where your reservation is located.
  const projectId = await reservationsClient.getProjectId();
  // The zone where your reservation is located.
  const zone = 'us-central1-a';
  // The name of the reservation to return.
  // reservationName = 'reservation-01';

  async function callGetReservation() {
    const requestedReservation = (
      await reservationsClient.get({
        project: projectId,
        zone,
        reservation: reservationName,
      })
    )[0];

    console.log(JSON.stringify(requestedReservation));
  }

  await callGetReservation();
}

main(...process.argv.slice(2)).catch(err => {
  console.error(err);
  process.exitCode = 1;
});

Python

Pour afficher la liste de vos réservations, utilisez l'exemple de code suivant :

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


# This file is automatically generated. Please do not modify it directly.
# Find the relevant recipe file in the samples/recipes or samples/ingredients
# directory and apply your changes there.


from google.cloud import compute_v1
from google.cloud.compute_v1.services.reservations.pagers import ListPager


def list_compute_reservation(project_id: str, zone: str = "us-central1-a") -> ListPager:
    """
    Lists all compute reservations in a specified Google Cloud project and zone.
    Args:
        project_id (str): The ID of the Google Cloud project.
        zone (str): The zone of the reservations.
    Returns:
        ListPager: A pager object containing the list of reservations.
    """

    client = compute_v1.ReservationsClient()

    reservations_list = client.list(
        project=project_id,
        zone=zone,
    )

    for reservation in reservations_list:
        print("Name: ", reservation.name)
        print(
            "Machine type: ",
            reservation.specific_reservation.instance_properties.machine_type,
        )
    # Example response:
    # Name:  my-reservation_1
    # Machine type:  n1-standard-1
    # Name:  my-reservation_2
    # Machine type:  n1-standard-1

    return reservations_list

Pour afficher les détails d'une réservation, utilisez l'exemple de code suivant :

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


# This file is automatically generated. Please do not modify it directly.
# Find the relevant recipe file in the samples/recipes or samples/ingredients
# directory and apply your changes there.


from google.cloud import compute_v1
from google.cloud.compute_v1.types import compute


def get_compute_reservation(
    project_id: str,
    zone: str = "us-central1-a",
    reservation_name="your-reservation-name",
) -> compute.Reservation:
    """
    Retrieves a compute reservation from GCP.
    Args:
        project_id (str): The ID of the Google Cloud project.
        zone (str): The zone of the reservation.
        reservation_name (str): The name of the reservation to retrieve.
    Returns:
        compute.Reservation: The reservation object retrieved from Google Cloud.
    """

    client = compute_v1.ReservationsClient()

    reservation = client.get(
        project=project_id,
        zone=zone,
        reservation=reservation_name,
    )

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

    return reservation

REST

Pour afficher la liste de vos réservations, envoyez une requête GET à la méthode reservations.list :

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

Remplacez les éléments suivants :

PROJECT_ID : ID du projet dans lequel vous avez créé vos réservations.
ZONE : zone où se trouvent vos réservations.

Le résultat ressemble à celui de l'exemple ci-dessous.

{
  "kind": "compute#reservation",
  "id": "4100668622331754141",
  "creationTimestamp": "2019-09-27T08:21:14.707-07:00",
  "selfLink": "https://www.googleapis.com/compute/v1/projects/my-project/zones/us-central1-a/reservations/reservation-05",
  "zone": "https://www.googleapis.com/compute/v1/projects/my-project/zones/us-central1-a",
  "name": "reservation-05",
  "specificReservation": {
    "instanceProperties": {
      "machineType": "n1-standard-2"
    },
    "count": "100",
    "inUseCount": "0",
    "assuredCount": "100"
  },
  "specificReservationRequired": false,
  "status": "READY",
  "shareSettings": {
    "shareType": "LOCAL"
  }
},
{
  "kind": "compute#reservation",
  "id": "2533514314332214789",
  "creationTimestamp": "2019-09-27T08:21:14.707-07:00",
  "selfLink": "https://www.googleapis.com/compute/v1/projects/my-project/zones/us-central1-a/reservations/reservation-04",
  "zone": "https://www.googleapis.com/compute/v1/projects/my-project/zones/us-central1-a",
  "name": "reservation-04",
  "specificReservation": {
    "instanceProperties": {
      "machineType": "n1-standard-2",
      "guestAccelerators": [
        {
          "acceleratorType": "nvidia-tesla-t4",
          "acceleratorCount": 1
        }
      ],
      "localSsds": [
        {
          "diskSizeGb": "375",
          "interface": "SCSI"
        }
      ]
    },
    "count": "50",
    "inUseCount": "25",
    "assuredCount": "50"
  },
  "specificReservationRequired": false,
  "status": "READY",
  "shareSettings": {
    "shareType": "LOCAL"
  }
}

Vous pouvez éventuellement affiner une liste de réservations à l'aide d'une expression de filtre en incluant le paramètre de requête filter :

GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations?filter=FILTER_EXPRESSION

Remplacez FILTER_EXPRESSION par une expression de filtre qui utilise des valeurs encodées au format URL.

Pour afficher les détails d'une réservation, envoyez une requête GET à la méthode reservations.get.

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

Remplacez les éléments suivants :

PROJECT_ID : ID du projet dans lequel vous avez créé la réservation.
ZONE : zone où se trouve la réservation.
RESERVATION_NAME : nom d'une réservation existante.

Le résultat ressemble à celui de l'exemple ci-dessous.

{
  "kind": "compute#reservation",
  "id": "4488228526648280060",
  "creationTimestamp": "2024-10-11T03:25:23.192-07:00",
  "selfLink": "https://www.googleapis.com/compute/v1/projects/davide-experimental/zones/us-central1-a/reservations/r-01",
  "zone": "https://www.googleapis.com/compute/v1/projects/davide-experimental/zones/us-central1-a",
  "name": "r-01",
  "specificReservation": {
    "instanceProperties": {
      "machineType": "n2-standard-2"
    },
    "count": "50",
    "inUseCount": "25",
    "assuredCount": "50"
  },
  "specificReservationRequired": false,
  "status": "READY",
  "shareSettings": {
    "shareType": "LOCAL"
  }
}

Afficher les demandes de réservations futures

Pour afficher les paramètres d'une ou de plusieurs demandes de réservation future, utilisez l'une des méthodes décrites dans cette section :

Pour afficher un aperçu de toutes les demandes de réservations futures de votre projet, affichez la liste de vos demandes.
Pour afficher tous les détails d'une seule demande de réservation future, affichez les détails de la demande.

Pour afficher les demandes de réservation future, sélectionnez l'une des options suivantes :

Console

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

Accéder à la page "Réservations"
Cliquez sur l'onglet Réservations futures.

Le tableau liste chaque demande de réservation future, et chaque colonne du tableau décrit une propriété.
Facultatif : Pour affiner la liste des demandes, dans le champ Filtrer, sélectionnez les propriétés selon lesquelles vous souhaitez filtrer les demandes.
Pour afficher les détails d'une requête, cliquez sur son nom dans la colonne Nom. Une page indiquant les détails de la demande de réservation future s'affiche.

gcloud

Pour afficher la liste de vos demandes de réservations futures, utilisez la commande gcloud compute future-reservations list :

gcloud compute future-reservations list

Le résultat ressemble à celui de l'exemple ci-dessous.

NAME: fr-04
TOTAL_COUNT: 100
START_TIME: 2025-07-20T07:00:00Z
END_TIME: 2025-08-05T07:00:00Z
PROCUREMENT_STATUS: FULFILLED
ZONE: us-east1-a

NAME: fr-05
TOTAL_COUNT: 10
START_TIME: 2025-07-20T07:00:00Z
END_TIME: 2025-12-01T00:00:00Z
PROCUREMENT_STATUS: PENDING_APPROVAL
ZONE: us-west1-c

Vous pouvez éventuellement affiner une liste de demandes de réservation futures à l'aide d'une expression de filtre en incluant l'option --filter :

gcloud compute future-reservations list \
    --filter="FILTER_EXPRESSION"

Remplacez FILTER_EXPRESSION par une expression de filtre.

Pour afficher les détails d'une demande de réservation future, utilisez la commande gcloud compute future-reservations describe :

gcloud compute future-reservations describe FUTURE_RESERVATION_NAME \
    --zone=ZONE

Remplacez les éléments suivants :

FUTURE_RESERVATION_NAME : nom d'une demande de réservation future existante.
ZONE : zone dans laquelle se situe la demande de réservation future.

Le résultat ressemble à celui de l'exemple ci-dessous.

autoCreatedReservationsDeleteTime: '2025-05-02T01:00:00Z'
creationTimestamp: '2025-03-23T10:08:31.613-07:00'
id: '5212276518668495076'
kind: compute#futureReservation
name: fr-01
planningStatus: SUBMITTED
selfLink: https://www.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/futureReservations/fr-01
selfLinkWithId: https://www.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/futureReservations/5212276518668495076
shareSettings:
  shareType: LOCAL
specificSkuProperties:
  instanceProperties:
    machineType: n1-standard-64
  totalCount: '800'
status:
  existingMatchingUsageInfo:
    count: '3'
    timestamp: '2025-03-30T01:00:00Z'
  lockTime: '2025-03-30T17:09:59.297799Z'
  procurementStatus: APPROVED
timeWindow:
  endTime: '2025-05-02T01:00:00Z'
  startTime: '2025-04-30T17:30:00Z'
zone: https://www.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a

REST

Pour afficher la liste de vos demandes de réservations futures, envoyez une requête GET à la méthode futureReservations.list :

GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/futureReservations

Remplacez les éléments suivants :

PROJECT_ID : ID du projet dans lequel vous avez créé vos requêtes de réservation future.
ZONE : zone dans laquelle se trouvent vos demandes de réservations futures.

Le résultat ressemble à celui de l'exemple ci-dessous.

{
  "id": "projects/my-project/zones/us-east1-a/futureReservations",
  "items": [
    {
      "id": "743865190848184978",
      "creationTimestamp": "2025-03-23T18:16:45.274-07:00",
      "selfLink": "https://www.googleapis.com/compute/v1/projects/my-project/zones/us-east1-a/futureReservations/fr-base",
      "selfLinkWithId": "https://www.googleapis.com/compute/v1/projects/my-project/zones/us-east1-a/futureReservations/743865190848184978",
      "zone": "https://www.googleapis.com/compute/v1/projects/my-project/zones/us-east1-a",
      "name": "fr-base",
      "specificSkuProperties": {
        "instanceProperties": {
          "machineType": "n1-standard-1"
        },
        "totalCount": "100"
      },
      "planningStatus": "SUBMITTED",
      "timeWindow": {
        "endTime": "2025-05-02T01:00:00Z",
        "startTime": "2025-04-30T17:30:00Z"
      },
      "status": {
        "procurementStatus": "FULFILLED",
        "lockTime": "2025-03-30T07:00:00Z",
        "existingMatchingUsageInfo": {
          "count": "3",
          "timestamp": "2025-03-30T01:00:00Z"
        }
      },
      "kind": "compute#futureReservation"
    },
    ...
  ],
  "selfLink": "https://www.googleapis.com/compute/v1/projects/my-project/zones/us-east1-a/futureReservations",
  "etag": "AnzKY34l-cvvV-JnniESJ0dtQvQ=/hvc4jaHpxFAZmOt1FVtKNgzZu-M=",
  "kind": "compute#futureReservationsListResponse"
}

Vous pouvez éventuellement affiner une liste de demandes de réservations futures à l'aide d'une expression de filtre en incluant le paramètre de requête filter :

GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/aggregated/futureReservations?filter=FILTER_EXPRESSION

Remplacez FILTER_EXPRESSION par une expression de filtre qui utilise des valeurs encodées au format URL.

Pour afficher les détails d'une demande de réservation future, envoyez une requête GET à la méthode futureReservations.get :

GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/futureReservations/FUTURE_RESERVATION_NAME

Remplacez les éléments suivants :

PROJECT_ID : ID du projet dans lequel vous avez créé la demande de réservation future.
ZONE : zone dans laquelle se situe la demande de réservation future.
FUTURE_RESERVATION_NAME : nom d'une demande de réservation future existante.

Le résultat ressemble à ce qui suit :

{
  "autoCreatedReservationsDeleteTime": "2025-05-02T01:00:00Z",
  "creationTimestamp": "2025-03-23T10:08:31.613-07:00",
  "id": "5212276518668495076",
  "kind": "compute#futureReservation",
  "name": "fr-01",
  "planningStatus": "SUBMITTED",
  "selfLink": "https://www.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/futureReservations/fr-01",
  "selfLinkWithId": "https://www.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/futureReservations/5212276518668495076",
  "shareSettings": {
    "shareType": "LOCAL"
  },
  "specificSkuProperties": {
    "instanceProperties": {
      "machineType": "n1-standard-64"
    },
    "totalCount": "800"
  },
  "status": {
    "lockTime": "2025-03-30T17:09:59.297799Z",
    "procurementStatus": "APPROVED",
    "existingMatchingUsageInfo": {
      "count": "3",
      "timestamp": "2025-03-30T01:00:00Z"
    }
  },
  "timeWindow": {
    "endTime": "2025-05-02T01:00:00Z",
    "startTime": "2025-04-30T17:30:00Z"
  },
  "zone": "https://www.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a"
}

Déterminer le nombre d'instances consommables

Pour déterminer le nombre d'instances de calcul pouvant consommer votre capacité réservée, effectuez l'une des opérations suivantes :

Pour afficher le nombre maximal d'instances pouvant consommer une réservation, consultez Instances utilisables dans une réservation.
Pour afficher le nombre d'instances que Compute Engine doit réserver pour une requête de réservation future à l'heure de début de la requête, consultez Instances consommables dans une requête de réservation future.
Pour afficher le nombre d'instances que Compute Engine doit réserver pour une demande de réservation future en mode Agenda à l'heure de début de la demande, consultez Instances consommables dans une demande de réservation future en mode Agenda.

Instances consommables dans une réservation

Lorsque vous affichez les détails d'une réservation, vous pouvez voir le nombre d'instances de calcul qui consomment la réservation et le nombre d'instances qui peuvent la consommer en consultant les champs suivants :

Nombre assuré (assuredCount) : nombre d'instances physiquement réservées dans la zone de la réservation. Ce nombre inclut les instances réservées pour votre projet et pour tout projet avec lequel une réservation partagée est partagée.
Nombre total (count) : nombre d'instances réservées spécifié dans la réservation. Ce nombre doit correspondre au nombre assuré.

Attention : Si le nombre assuré est inférieur au nombre total, le nombre d'instances réservées est inférieur au nombre attendu. Pour résoudre ce problème, consultez Moins de VM disponibles pour la consommation.
Machines en cours d'utilisation (inUseCount) : nombre d'instances en cours d'exécution dans votre projet ou dans un projet avec lequel une réservation partagée est partagée, qui consomment la réservation.

Par exemple, si le nombre assuré (assuredCount) et le nombre total (count) sont tous deux de 50, et que le nombre d'instances consommant la réservation (inUseCount) est de 25, alors 25 instances supplémentaires peuvent consommer la réservation avant qu'elle ne soit entièrement consommée.

Instances consommables dans une requête de réservation future

Vous pouvez déterminer le nombre d'instances de calcul que Compute Engine prévoit de réserver à l'heure de début d'une demande de réservation future à l'état de brouillon, en attente ou approuvée.

Ce nombre dépend de l'affinité de réservation de votre demande :

Réservations consommées automatiquement : pour déterminer ce nombre, procédez comme suit :
1. Affichez le nombre d'instances en cours d'exécution et de réservations non consommées dans votre projet et vos projets clients qui correspondent aux propriétés de la requête.
2. Soustrayez ce nombre de correspondances du nombre total de la requête.
Réservations spécifiquement ciblées : ce nombre est égal au nombre total de la requête de réservation future. Compute Engine ne soustrait pas les réservations existantes ni les VM actives.

Vous pouvez déterminer le nombre d'instances consommables pour une ou plusieurs requêtes à la fois. Pour plusieurs requêtes, utilisez la console Google Cloud ou l'API REST. Pour les requêtes uniques, sélectionnez l'une des options suivantes :

Console

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

Accéder à la page "Réservations"
Cliquez sur l'onglet Réservations futures. Le tableau liste chaque demande de réservation future, et chaque colonne décrit une propriété.
Pour déterminer le nombre d'instances de calcul que Compute Engine prévoit de réserver à l'heure de début, sélectionnez l'une des méthodes suivantes :
- Demandes consommées automatiquement : soustrayez la colonne Nombre de correspondances de la colonne Nombre total. En fonction du nombre total, la colonne Nombre de correspondances affiche l'un des avertissements suivants :
  - Le nombre de correspondances est nul : il n'y a aucune instance en cours d'exécution ni aucune réservation inutilisée dans votre projet, ni dans aucun projet avec lequel votre demande est partagée.
  - Le nombre de correspondances est égal au nombre total : Compute Engine ne réservera aucune instance pour votre requête à son heure de début.
  Si vous modifiez une requête, ou si vous créez des instances ou des réservations correspondant à la requête, Compute Engine met à jour la colonne Nombre de correspondances dans un délai de 30 minutes.
- Réservations spécifiquement ciblées : consultez la colonne Nombre total. Compute Engine provisionne ce nombre total.
Facultatif : Pour vérifier la date de la dernière mise à jour de la colonne Nombre de correspondances dans une requête, procédez comme suit :
1. Dans la colonne Nom, cliquez sur le nom de la demande. Une page contenant les détails de la demande de réservation future s'affiche.
2. Dans la section Détails de la ressource, vérifiez le champ Date/heure de la dernière évaluation du nombre d'utilisations correspondantes.

gcloud

Pour afficher les détails d'une demande de réservation future, utilisez la commande gcloud compute future-reservations describe :
```
gcloud compute future-reservations describe FUTURE_RESERVATION_NAME \
    --zone=ZONE
```
Remplacez les éléments suivants :
- FUTURE_RESERVATION_NAME : nom d'une demande de réservation future existante.
- ZONE : zone dans laquelle se situe la demande de réservation future.
Dans le résultat, recherchez les champs count et totalCount :
```
...
specificSkuProperties:
  ...
  totalCount: '100'
status:
  existingMatchingUsageInfo:
    count: '50'
    timestamp: '2025-03-30T01:00:00Z'
  ...
  procurementStatus: DRAFTING
...
```
Déterminez le nombre d'instances consommables que Compute Engine prévoit de réserver à l'heure de début de la requête en fonction de l'affinité de réservation :
- Requêtes consommées automatiquement : soustrayez count de totalCount. Par exemple, si count est défini sur 50 et totalCount sur 100, Compute Engine prévoit de réserver 50 instances de calcul à l'heure de début. Si vous modifiez la demande ou créez des instances ou des réservations correspondant à la demande, Compute Engine met à jour le champ existingMatchingUsageInfo dans les 30 minutes. Pour vérifier la date de la dernière mise à jour de ce champ, vérifiez la valeur de existingMatchingUsageInfo.timestamp.
- Réservations spécifiquement ciblées : Compute Engine prévoit de réserver la valeur spécifiée dans le champ totalCount à l'heure de début de la requête.

REST

Pour afficher la liste de vos demandes de réservations futures, envoyez une requête GET à la méthode futureReservations.list. Dans l'URL de la requête, incluez le paramètre de requête filter et spécifiez de n'afficher que les champs name, specificSkuProperties et status :

GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/futureReservations?fields=items.name,items.specificSkuProperties,items.status

Remplacez les éléments suivants :

PROJECT_ID : ID du projet dans lequel vous avez créé vos requêtes de réservation future.
ZONE : zone dans laquelle se situe la demande de réservation future.

Dans le résultat, recherchez les champs count et totalCount pour chaque brouillon, demande en attente d'approbation ou demande approuvée :

{
  "items": [
    {
      "specificSkuProperties": {
        ...
        totalCount: "100"
      },
      "name": "fr-01",
      "status": {
        "procurementStatus": "APPROVED",
        ...
        existingMatchingUsageInfo: {
          count: "50",
          "timestamp": "2025-01-22T07:54:26.295Z"
        }
      }
    },
    {
      "specificSkuProperties": {
        ...
        totalCount: "20"
      },
      "name": "fr-02",
      "status": {
        "procurementStatus": "DRAFTING",
        ...
        existingMatchingUsageInfo: {
          "count": "2",
          "timestamp": "2025-01-22T07:54:26.295Z"
        }
      }
    }
  ]
}

Déterminez le nombre d'instances consommables que Compute Engine prévoit de réserver à l'heure de début de la requête en fonction de l'affinité de réservation :
- Demandes consommées automatiquement : soustrayez count de totalCount. Par exemple, si count est défini sur 50 et totalCount sur 100, Compute Engine prévoit de réserver 50 instances de calcul à l'heure de début. Si vous modifiez la requête, ou si vous créez des instances ou des réservations correspondant à la requête, Compute Engine met à jour le champ existingMatchingUsageInfo dans un délai de 30 minutes. Pour vérifier la date de la dernière mise à jour de ce champ, consultez la valeur de existingMatchingUsageInfo.timestamp.
- Réservations spécifiquement ciblées : Compute Engine prévoit de réserver la valeur spécifiée dans le champ totalCount à l'heure de début de la requête.

Instances consommables dans une demande de réservation future en mode Agenda

Lorsque vous affichez les détails d'une demande de réservation future, vous pouvez voir le nombre d'instances de calcul que Compute Engine prévoit de provisionner au début de la période de réservation. Compute Engine crée le nombre d'instances spécifié dans la requête, quel que soit le nombre d'instances correspondantes dans votre projet ou dans tout projet avec lequel la requête est partagée.

Afficher la consommation des réservations

Chaque fois qu'une instance de calcul consomme une réservation, vous pouvez afficher les éléments suivants :

Afficher la réservation qu'une instance consomme
Afficher la liste des instances qui consomment une réservation

Afficher la réservation qu'une instance consomme

Pour afficher la réservation qu'une instance consomme, sélectionnez l'une des options suivantes :

Console

Dans la console Google Cloud , accédez à la page Instances de VM.

Accéder à la page Instances de VM
Cliquez sur le nom de l'instance qui utilise une réservation que vous souhaitez afficher.
Dans la section Informations de base, le champ Réservation consommée affiche le nom de la réservation que l'instance consomme.

gcloud

Pour afficher la réservation qu'une instance utilise, exécutez la commande gcloud compute instances describe avec l'option --flatten=resourceStatus.reservationConsumptionInfo :

gcloud compute instances describe INSTANCE_NAME \
    --flatten=resourceStatus.reservationConsumptionInfo \
    --zone=ZONE

Remplacez les éléments suivants :

INSTANCE_NAME : nom de l'instance.
ZONE : zone où se trouve l'instance.

Un résultat semblable à celui-ci s'affiche :

consumedReservation: https://www.googleapis.com/compute/v1/projects/example-project/zones/us-central1-c/reservations/example-reservation

REST

Pour afficher la réservation qu'une instance utilise, envoyez une requête GET à la méthode instances.get. Dans l'URL de la requête, incluez le paramètre de requête fields défini sur resourceStatus.reservationConsumptionInfo :

GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME?fields=resourceStatus.reservationConsumptionInfo

Remplacez les éléments suivants :

PROJECT_ID : ID du projet dans lequel l'instance existe.
ZONE : zone où se trouve l'instance.
INSTANCE_NAME : nom de l'instance.

Une réponse semblable à la suivante s'affiche :

{
  "resourceStatus": {
    "reservationConsumptionInfo": {
      "consumedReservation": "https://www.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/reservations/example-reservation"
    }
  }
}

Afficher la liste des instances qui utilisent une réservation

Vous pouvez afficher la liste des instances consommant une réservation dans un même projet. Pour les réservations partagées, cette méthode ne renvoie que les instances du projet que vous spécifiez. Elle n'inclut pas les instances d'autres projets clients qui utilisent la même réservation.

Pour afficher les instances qui consomment une réservation, sélectionnez l'une des options suivantes :

gcloud

Pour afficher les instances qui consomment une réservation, utilisez la commande gcloud compute instances list avec l'option --filter définie sur la réservation que vous souhaitez afficher :

gcloud compute instances list \
    --project=CONSUMER_PROJECT_ID \
    --zones=ZONE \
    --filter="resourceStatus.reservationConsumptionInfo.consumedReservation:https://www.googleapis.com/compute/v1/projects/HOST_PROJECT_ID/zones/ZONE/reservations/RESERVATION_NAME"

Remplacez les éléments suivants :

CONSUMER_PROJECT_ID : ID du projet qui utilise la réservation.
ZONE : zone où se trouvent la réservation et les instances.
HOST_PROJECT_ID : ID du projet dans lequel la réservation a été créée (s'il est différent du projet client).
RESERVATION_NAME : nom de la réservation.

Un résultat semblable aux lignes suivantes s'affiche :

NAME               ZONE           MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP     STATUS
my-e2-instance     us-central1-c  e2-medium                  10.128.0.61  35.239.208.172  RUNNING
my-e2-instance-02  us-central1-c  e2-medium                  10.128.0.62  104.154.31.123  RUNNING
my-e2-instance-03  us-central1-c  e2-medium                  10.128.0.63  34.171.90.254   RUNNING

REST

Pour afficher les instances qui utilisent une réservation, envoyez une requête GET à la méthode instances.list. Dans l'URL de la requête, incluez le paramètre de requête filter défini sur le nom de la réservation que vous souhaitez afficher :

GET https://compute.googleapis.com/compute/v1/projects/CONSUMER_PROJECT_ID/zones/ZONE/instances?filter=resourceStatus.reservationConsumptionInfo.consumedReservation%3D%22.*%2Fprojects%2FHOST_PROJECT_ID%2Fzones%2FZONE%2Freservations%2FRESERVATION_NAME%22

Remplacez les éléments suivants :

CONSUMER_PROJECT_ID : ID du projet qui utilise la réservation.
ZONE : zone où se trouvent la réservation et les instances.
HOST_PROJECT_ID : ID du projet dans lequel la réservation a été créée (s'il est différent du projet client).
RESERVATION_NAME : nom de la réservation.

Une réponse semblable à la suivante s'affiche :

{
  "kind": "compute#instanceList",
  "id": "projects/example-project/zones/us-central1-a/instances",
  "items": [
    {
      ...
      "name": "example-instance-01",
      ...
      "resourceStatus": {
        "scheduling": {},
        "reservationConsumptionInfo": {
          "consumedReservation": "https://www.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/reservations/example-reservation"
        }
      }
    },
    {
      ...
      "name": "example-instance-02",
      ...
      "resourceStatus": {
        "scheduling": {},
        "reservationConsumptionInfo": {
          "consumedReservation": "https://www.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/reservations/example-reservation"
        }
      },
      ...
    }
  ],
  "selfLink": "https://www.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/instances"
}

Étapes suivantes

Découvrez comment associer des réservations à des engagements.
Découvrez comment consommer des réservations.
Découvrez comment modifier des réservations.
Découvrez comment supprimer des réservations.

Afficher les réservations ou les demandes de réservations futures Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Limites

Avant de commencer

Console

gcloud

Go

Java

Node.js

Python

REST

Rôles requis

Autorisations requises

Afficher les paramètres de réservation

Afficher les réservations

Console

gcloud

Go

Java

Node.js

Python

REST

Afficher les demandes de réservations futures

Console

gcloud

REST

Déterminer le nombre d'instances consommables

Instances consommables dans une réservation

Instances consommables dans une requête de réservation future

Console

gcloud

REST

Instances consommables dans une demande de réservation future en mode Agenda

Afficher la consommation des réservations

Afficher la réservation qu'une instance consomme

Console

gcloud

REST

Afficher la liste des instances qui utilisent une réservation

gcloud

REST

Étapes suivantes

Afficher les réservations ou les demandes de réservations futures