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 consultez 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 de réservations Cet examen vous permet de vérifier la réservation qu'une instance Compute Engine spécifique utilise, 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 :

    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. Installez la Google Cloud CLI. Une fois que la Google Cloud CLI est installée, initialisez-la 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.

    2. Set a default region and zone.

    Go

    Pour utiliser les exemples Go de cette page dans un environnement de développement local, installez et initialisez la gcloud CLI, puis configurez le service 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.

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

      gcloud auth application-default login

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

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

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

    Java

    Pour utiliser les exemples Java de cette page dans un environnement de développement local, installez et initialisez la gcloud CLI, puis configurez le service 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.

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

      gcloud auth application-default login

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

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

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

    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 le service 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.

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

      gcloud auth application-default login

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

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

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

    Python

    Pour utiliser les exemples Python de cette page dans un environnement de développement local, installez et initialisez la gcloud CLI, puis configurez le service 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.

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

      gcloud auth application-default login

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

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

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

    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éservation future :

  • 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 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 détails de la réservation.

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

  1. 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é.

  2. 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 la liste des réservations, dans le champ Filtrer , sélectionnez les propriétés selon lesquelles vous souhaitez filtrer les réservations.

  3. 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 spécifier le flag --filter pour affiner une liste de réservations à l'aide d'une expression de filtre :

    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 en 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éservations futures, utilisez l'une des méthodes décrites dans cette section :

  • Pour obtenir un aperçu de toutes les demandes de réservations futures dans votre projet, affichez la liste de vos demandes.

  • Pour afficher tous les détails d'une demande de réservation future, consultez les détails de la demande.

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

Console

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

    Accéder à la page "Réservations"

  2. Cliquez sur l'onglet Réservations futures.

    Le tableau liste chaque demande de réservation future, et chaque colonne décrit une propriété.

  3. Facultatif : Pour affiner la liste des demandes, dans le champ Filtrer, sélectionnez les propriétés selon lesquelles vous souhaitez filtrer les demandes.

  4. Pour afficher les détails d'une demande, 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 également inclure l'option --filter pour affiner une liste de demandes de réservations futures à l'aide d'une expression de filtre :

    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 trouve 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 demandes de réservations futures.

    • ZONE : zone dans laquelle se situent 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 en 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 trouve 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, procédez de l'une des manières suivantes :

Instances utilisables dans une réservation

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

  • Nombre garanti (assuredCount) : nombre d'instances physiquement réservées dans la zone de la réservation. Ce nombre inclut les instances réservées à votre projet et à 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é.

  • 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 demande de réservation future

Vous pouvez déterminer le nombre d'instances de calcul pour lesquelles Compute Engine crée une réservation à l'heure de début d'une requête de réservation future. Pour une demande à l'état "Brouillon", "En attente d'approbation" ou "Approuvée", vous pouvez déterminer ce nombre comme suit :

  1. Découvrez le nombre d'instances en cours d'exécution et de réservations inutilisées dans votre projet, ainsi que dans tout projet avec lequel la demande est partagée, qui correspondent aux propriétés de la demande.

  2. Soustrayez le nombre d'instances en cours d'exécution correspondantes et de réservations inutilisées du nombre total de la requête.

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 demandes individuelles, sélectionnez l'une des options suivantes :

Console

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

    Accéder à la page "Réservations"

  2. Cliquez sur l'onglet Réservations futures.

    Le tableau liste chaque demande de réservation future, et chaque colonne décrit une propriété.

  3. Pour déterminer le nombre d'instances que Compute Engine prévoit de réserver pour une requête à son heure de début, soustrayez la colonne Nombre de correspondances à la colonne Nombre total.

    La colonne Nombre de correspondances affiche l'un des avertissements suivants :

    • Le nombre de correspondances est nul : aucune instance en cours d'exécution ni aucune réservation inutilisée ne correspond à votre projet ni à aucun projet avec lequel votre demande est partagée.

    • Le nombre de correspondances est égal au nombre total : Compute Engine ne réserve aucune instance pour votre demande à son heure de début.

    Si vous modifiez une requête ou créez des instances ou des réservations qui correspondent à la requête, Compute Engine met à jour la colonne Nombre de correspondances dans les 30 minutes.

  4. Facultatif : Pour vérifier la date de la dernière mise à jour de la colonne Nombre de correspondances dans une demande, 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'ouvre.

    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

  1. 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 trouve 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
...

  2. Soustrayez la valeur de count de celle de totalCount. Par exemple, si count est défini sur 50 et totalCount sur 100, Compute Engine crée automatiquement une réservation pour 50 instances à l'heure de début de la demande.

    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, consultez la valeur de existingMatchingUsageInfo.timestamp.

REST

  1. 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 d'afficher uniquement 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 demandes de réservations futures.

    • ZONE : zone dans laquelle se trouve la demande de réservation future.

    Dans le résultat, recherchez les champs count et totalCount pour chaque demande à l'état "Brouillon", "En attente d'approbation" ou "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"
        }
      }
    }
  ]
}

  2. Pour chaque requête, soustrayez la valeur de count de totalCount. Par exemple, si count est défini sur 50 et totalCount sur 100, Compute Engine crée automatiquement une réservation pour 50 instances à l'heure de début de la demande.

    Si vous modifiez une demande ou créez des instances ou des réservations correspondant à la demande, Compute Engine met à jour le champ existingMatchingUsageInfo sous 30 minutes. Pour vérifier la date de la dernière mise à jour de ce champ, consultez la valeur de existingMatchingUsageInfo.timestamp.

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 utilise une réservation, vous pouvez afficher les informations suivantes :

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

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

    Accéder à la page Instances de VM

  2. Cliquez sur le nom de l'instance qui utilise une réservation que vous souhaitez afficher.

  3. Dans la section Informations de base, le champ Réservation utilisée indique le nom de la réservation utilisée par l'instance.

gcloud

Pour afficher la réservation qu'une instance consomme, utilisez 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/var>/zones/ZONE/instances/INSTANCE_NAME?fields=resourceStatus.reservationConsumptionInfo

Remplacez les éléments suivants :

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

Une réponse semblable à celle-ci 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 consomment 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 à celui-ci 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 à celle-ci 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