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

Ce document explique comment afficher vos réservations ou vos demandes de réservations futures. Pour en savoir plus sur les différents types de réservations, consultez la section Type de provisionnement.

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

  • Affichez les paramètres des réservations. Cette vérification vous permet de vérifier les détails de vos réservations, de vous assurer qu'elles répondent à vos besoins et de 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.

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 les avez créées.

Avant de commencer

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

    Select the tab for how you plan to use the samples on this page:

    Console

    When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

    gcloud

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

      gcloud init
    2. Set a default region and zone.

      3. Go

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

      1. Install the Google Cloud CLI.

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

        gcloud init

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

        gcloud auth application-default login

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

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

      Java

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

      1. Install the Google Cloud CLI.

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

        gcloud init

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

        gcloud auth application-default login

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

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

      Node.js

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

      1. Install the Google Cloud CLI.

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

        gcloud init

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

        gcloud auth application-default login

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

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

      Python

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

      1. Install the Google Cloud CLI.

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

        gcloud init

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

        gcloud auth application-default login

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

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

      REST

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

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

        gcloud init

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

Rôles requis

Pour obtenir les autorisations nécessaires pour 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 la page Gérer l'accès aux projets, aux dossiers et aux organisations.

Ce rôle prédéfini contient les autorisations requises pour 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 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 les détails complets d'une seule réservation, consultez les détails de la réservation.

Pour afficher les champs deleteAtTime et reservationSharingPolicy (Aperçu) d'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: pour affiner votre liste de réservations, dans le champ Filtre , sélectionnez les propriétés par 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.

    La page d'informations 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 l'option --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 de votre projet, affichez la liste de vos demandes.

  • Pour afficher les détails complets d'une seule 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 votre liste de requêtes, dans le champ Filtre , sélectionnez les propriétés que vous souhaitez utiliser pour filtrer les requêtes.

  4. Pour afficher les détails d'une demande, cliquez sur son nom dans la colonne Nom.

    Une page contenant 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 beta compute future-reservations list:

    gcloud beta 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 beta 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 beta compute future-reservations describe:

    gcloud beta 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/beta/projects/example-project/zones/us-central1-a/futureReservations/fr-01
selfLinkWithId: https://www.googleapis.com/compute/beta/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/beta/projects/example-project/zones/us-central1-a

REST

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

    GET https://compute.googleapis.com/compute/beta/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 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/beta/projects/my-project/zones/us-east1-a/futureReservations/fr-base",
      "selfLinkWithId": "https://www.googleapis.com/compute/beta/projects/my-project/zones/us-east1-a/futureReservations/743865190848184978",
      "zone": "https://www.googleapis.com/compute/beta/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/beta/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éservation futures à l'aide d'une expression de filtre en incluant le paramètre de requête filter:

    GET https://compute.googleapis.com/compute/beta/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 bêta:

    GET https://compute.googleapis.com/compute/beta/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/beta/projects/example-project/zones/us-central1-a/futureReservations/fr-01",
  "selfLinkWithId": "https://www.googleapis.com/compute/beta/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/beta/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 comme suit:

Instances consommables dans une réservation

Lorsque vous consultez les détails d'une réservation, vous pouvez voir combien d'instances de calcul utilisent la réservation et combien d'instances peuvent l'utiliser en vérifiant les champs suivants:

  • Nombre assuré (assuredCount): nombre d'instances réservées dans la zone de la réservation 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 garanti.

  • Machines utilisées (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 utilisent 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, 25 autres instances 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 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 en attente d'approbation, approuvée ou en cours de rédaction, vous pouvez déterminer ce nombre comme suit:

  1. Afficher 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 requête est partagée, qui correspondent aux propriétés de la requête

  2. Soustrayez le nombre d'instances en cours d'exécution et de réservations inutilisées de la somme totale 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 requêtes uniques, 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, soustraitez 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 ou réservation inutilisée ne correspond dans votre projet ni dans l'un des projets avec lesquels votre requête est partagée.

    • Nombre de correspondances égal au nombre total: Compute Engine ne réserve aucune instance pour votre requête au moment de son 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 sous 30 minutes.

  4. 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 Name (Nom), cliquez sur le nom de la requête.

      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

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

    gcloud beta 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 totalCount. Par exemple, si count est 50 et totalCount est 100, Compute Engine crée automatiquement une réservation pour 50 instances à l'heure de début de la requête.

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

REST

  1. Pour afficher la liste de vos demandes de réservation futures, envoyez une requête GET à la méthode futureReservations.list bêta. 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/beta/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 de 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, soustrahissez la valeur de count de totalCount. Par exemple, si count est égal à 50 et totalCount à 100, Compute Engine crée automatiquement une réservation pour 50 instances à l'heure de début de la requête.

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

Étape suivante