Conferir reservas ou solicitações de reserva futuras

Neste documento, explicamos como visualizar suas reservas, solicitações de reserva adiantada e consumo de reservas. Para saber mais sobre reservas, consulte Escolher um tipo de reserva.

Ao visualizar suas reservas, solicitações de reserva adiantada ou consumo de reserva, você pode fazer o seguinte:

  • Ver configurações de reserva. Essa análise ajuda a verificar os detalhes das reservas, garantir que elas atendam às suas necessidades e planejar a capacidade.

  • Determine o número de instâncias consumíveis. Essa verificação ajuda a determinar quantas instâncias do Compute Engine podem consumir sua capacidade reservada.

  • Ver o consumo de reservas. Essa análise permite verificar qual reserva uma instância específica do Compute Engine está consumindo ou listar todas as instâncias que estão consumindo uma reserva específica em um projeto.

Limitações

Só é possível visualizar uma reserva compartilhada ou uma solicitação de reserva adiantada compartilhada no projeto em que ela foi criada.

Antes de começar

Funções exigidas

Para receber as permissões necessárias para visualizar reservas ou solicitações de reserva adiantada, peça ao administrador para conceder a você o papel do IAM de Administrador do Compute (roles/compute.admin) no projeto. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esse papel predefinido contém as permissões necessárias para visualizar reservas ou solicitações de reserva adiantada. Para acessar as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As seguintes permissões são necessárias para visualizar reservas ou solicitações de reserva adiantada:

  • Para ver uma lista de reservas: compute.reservations.list no projeto
  • Para ver uma lista de solicitações de reserva adiantada: compute.futureReservations.list no projeto
  • Para ver os detalhes de uma reserva: compute.reservations.get no projeto
  • Para ver os detalhes de uma solicitação de reserva adiantada: compute.futureReservations.get no projeto

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

Ver configurações de reserva

As seções a seguir explicam como visualizar as configurações das suas reservas ou solicitações de reserva adiantada.

Exibir reservas

Para conferir as configurações de uma ou mais reservas, use um dos seguintes métodos descritos nesta seção:

  • Para ter uma visão geral de todas as reservas no seu projeto, confira uma lista de suas reservas.

  • Para conferir todos os detalhes de uma única reserva, consulte os detalhes da reserva.

Para conferir os campos deleteAtTime e reservationSharingPolicy (prévia) em uma reserva, consulte os detalhes de uma reserva usando a Google Cloud CLI ou confira as reservas usando a API REST. Se você não precisar desses campos, selecione uma das seguintes opções para ver as reservas:

Console

  1. No console do Google Cloud , acesse a página Reservas.

    Acessar "Reservas"

    Na guia Reservas imediatas (padrão), a tabela lista cada reserva, e cada coluna descreve uma propriedade.

  2. Opcional: na tabela Reservas imediatas, realize uma das ações a seguir ou ambas:

    • Para mostrar a contagem garantida das suas reservas, clique em Opções de exibição de colunas..., marque a caixa de seleção Contagem garantida e clique em OK.

    • Para refinar sua lista de reservas, no campo Filtro, selecione as propriedades que você quer usar para filtrar as reservas.

  3. Para conferir os detalhes de uma reserva, na coluna Nome, clique no nome da reserva. Uma página com os detalhes da reserva será aberta.

gcloud

  • Para ver uma lista das suas reservas, use o comando gcloud compute reservations list:

    gcloud compute reservations list

    A resposta será semelhante a:

    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

    Para refinar uma lista de reservas usando uma expressão de filtro, inclua a flag --filter:

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

    Substitua FILTER_EXPRESSION por uma expressão de filtro.

  • Para conferir os detalhes de uma reserva, use o comando gcloud compute reservations describe:

    gcloud compute reservations describe RESERVATION_NAME \
    --zone=ZONE

    Substitua:

    • RESERVATION_NAME: o nome de uma reserva.

    • ZONE: a zona em que a reserva existe.

    A resposta será semelhante a:

    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

  • Para ver uma lista das suas reservas, use o seguinte exemplo de código:

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

  • Para conferir os detalhes de uma reserva, use o exemplo de código a seguir:

    // 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

  • Para ver uma lista das suas reservas, use o seguinte exemplo de código:

    /*
 * 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;
  }
}

  • Para ver os detalhes de uma reserva, use o seguinte exemplo de código:

    /*
 * 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

  • Para conferir uma lista das suas reservas, use o exemplo de código a seguir:

    /*
 * 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;
});

  • Para conferir os detalhes de uma reserva, use o exemplo de código a seguir:

    /*
 * 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

  • Para ver uma lista das suas reservas, use o seguinte exemplo de código:

    # 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

  • Para ver os detalhes de uma reserva, use o seguinte exemplo de código:

    # 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

  • Para ver uma lista das suas reservas, faça uma solicitação GET ao método reservations.list:

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

    Substitua:

    • PROJECT_ID: o ID do projeto em que você criou as reservas.

    • ZONE: a zona em que as reservas estão localizadas.

    A resposta será semelhante a:

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

    Para refinar uma lista de reservas usando uma expressão de filtro, inclua o parâmetro de consulta filter:

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

    Substitua FILTER_EXPRESSION por uma expressão de filtro que usa valores codificados em URL.

  • Para visualizar os detalhes de uma reserva, faça uma solicitação GET para o método reservations.get.

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

    Substitua:

    • PROJECT_ID: o ID do projeto em que você criou a reserva.

    • ZONE: a zona em que a reserva existe.

    • RESERVATION_NAME: o nome de uma reserva.

    A resposta será semelhante a:

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

Conferir solicitações de reserva adiantada

Para conferir as configurações de uma ou mais solicitações de reserva adiantada, use um dos seguintes métodos descritos nesta seção:

  • Para ter uma visão geral de todas as solicitações de reserva adiantada no seu projeto, confira uma lista das suas solicitações.

  • Para conferir todos os detalhes de uma única solicitação de reserva adiantada, confira os detalhes da solicitação.

Para conferir as solicitações de reserva adiantada, selecione uma das seguintes opções:

Console

  1. No console do Google Cloud , acesse a página Reservas.

    Acesse "Reservas"

  2. Clique na guia Reservas adiantadas.

    A tabela lista cada solicitação de reserva adiantada, e cada coluna da tabela descreve uma propriedade.

  3. Opcional: para refinar sua lista de solicitações, no campo Filtro, selecione as propriedades que você quer usar para filtrar as solicitações.

  4. Para conferir os detalhes de uma solicitação, na coluna Nome, clique no nome da solicitação. Uma página com os detalhes da solicitação de reserva adiantada vai aparecer.

gcloud

  • Para ver uma lista das suas solicitações de reserva adiantadas, use o comando gcloud compute future-reservations list:

    gcloud compute future-reservations list

    A resposta será semelhante a:

    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

    Para refinar uma lista de solicitações de reserva adiantada usando uma expressão de filtro, inclua a flag --filter:

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

    Substitua FILTER_EXPRESSION por uma expressão de filtro.

  • Para visualizar os detalhes de uma solicitação de reserva adiantada, use o comando gcloud compute future-reservations describe:

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

    Substitua:

    • FUTURE_RESERVATION_NAME: o nome de uma solicitação de reserva adiantada atual.

    • ZONE: a zona em que a solicitação de reserva adiantada existe.

    A resposta será semelhante a:

    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

  • Para ver uma lista das suas solicitações de reserva adiantada, faça uma solicitação GET para o método futureReservations.list:

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

    Substitua:

    • PROJECT_ID: o ID do projeto em que você criou as solicitações de reserva adiantada.

    • ZONE: a zona em que seus pedidos de reserva adiantada estão localizados.

    A resposta será semelhante a:

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

    Também é possível refinar uma lista de solicitações de reserva adiantada usando uma expressão de filtro incluindo o parâmetro de consulta filter:

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

    Substitua FILTER_EXPRESSION por uma expressão de filtro que use valores codificados em URL.

  • Para visualizar os detalhes de uma solicitação de reserva adiantada, faça uma solicitação GET para o método futureReservations.get:

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

    Substitua:

    • PROJECT_ID: o ID do projeto em que você criou a solicitação de reserva adiantada.

    • ZONE: a zona em que a solicitação de reserva adiantada existe.

    • FUTURE_RESERVATION_NAME: o nome de uma solicitação de reserva adiantada atual.

    O resultado será o seguinte:

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

Determinar o número de instâncias consumíveis

Para determinar o número de instâncias de computação que podem consumir sua capacidade reservada, siga um destes procedimentos:

Instâncias consumíveis em uma reserva

Ao conferir os detalhes de uma reserva, é possível verificar quantas instâncias de computação estão consumindo a reserva e quantas podem consumir. Para isso, confira os seguintes campos:

  • Contagem garantida (assuredCount): o número de instâncias que estão reservadas fisicamente na zona da reserva. Esse número inclui as instâncias reservadas para seu projeto e para qualquer projeto com que uma reserva compartilhada seja compartilhada.

  • Contagem total (count): o número de instâncias reservadas especificadas na reserva. Esse número precisa corresponder à contagem garantida.

  • Máquinas em uso (inUseCount): o número de instâncias em execução no seu projeto ou em um projeto com o qual uma reserva compartilhada é compartilhada, que estão consumindo a reserva.

Por exemplo, se a contagem garantida (assuredCount) e a contagem total (count) forem 50, e o número de instâncias que consomem a reserva (inUseCount) for 25, mais 25 instâncias poderão consumir a reserva antes que ela seja totalmente consumida.

Instâncias consumíveis em uma solicitação de reserva adiantada

É possível determinar o número de instâncias de computação que o Compute Engine planeja reservar no horário de início de um pedido de reserva adiantada em rascunho, pendente ou aprovado.

Esse número depende da afinidade de reserva da sua solicitação:

  • Reservas consumidas automaticamente: para determinar esse número, faça o seguinte:

    1. Confira quantas instâncias em execução e reservas não consumidas no seu projeto e nos projetos de consumidor correspondem às propriedades da solicitação.

    2. Subtraia essa contagem correspondente da contagem total na solicitação.

  • Reservas especificamente segmentadas: esse número é igual à contagem total na solicitação de reserva adiantada. O Compute Engine não subtrai reservas atuais ou VMs ativas.

É possível determinar o número de instâncias consumíveis para uma ou várias solicitações de uma só vez. Para várias solicitações, use o console do Google Cloud ou a API REST. Para solicitações únicas, selecione uma das seguintes opções:

Console

  1. No console do Google Cloud , acesse a página Reservas.

    Acesse "Reservas"

  2. Clique na guia Reservas adiantadas. A tabela lista cada solicitação de reserva adiantada, e cada coluna da tabela descreve uma propriedade.

  3. Para determinar o número de instâncias de computação que o Compute Engine planeja reservar no horário de início, faça o seguinte:

    • Solicitações consumidas automaticamente: subtraia a coluna Contagem de correspondências da coluna Contagem total. Com base na contagem total, a coluna Contagem de correspondências mostra um dos seguintes avisos:

      • A contagem de correspondências é zero: não há instâncias em execução ou reservas não utilizadas correspondentes no seu projeto ou em qualquer projeto com que sua solicitação seja compartilhada.

      • Contagem de correspondências igual à contagem total: o Compute Engine não vai reservar nenhuma instância para sua solicitação no horário de início.

      Se você modificar uma solicitação ou criar instâncias ou reservas que correspondam à solicitação, o Compute Engine vai atualizar a coluna Contagem de correspondência em até 30 minutos.

    • Reservas segmentadas especificamente: verifique a coluna Contagem total. O Compute Engine provisiona essa contagem completa.

  4. Opcional: para verificar quando a coluna Contagem de correspondências foi atualizada pela última vez em uma solicitação, faça o seguinte:

    1. Na coluna Nome, clique no nome da solicitação. Uma página com os detalhes da solicitação de reserva adiantada é aberta.

    2. Na seção Detalhes do recurso, verifique o campo Horário da avaliação de último uso correspondente.

gcloud

  1. Para visualizar os detalhes de uma solicitação de reserva adiantada, use o comando gcloud compute future-reservations describe:

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

    Substitua:

    • FUTURE_RESERVATION_NAME: o nome de uma solicitação de reserva adiantada atual.

    • ZONE: a zona em que a solicitação de reserva adiantada existe.

    Na saída, encontre os campos count e totalCount:

    ...
specificSkuProperties:
  ...
  totalCount: '100'
status:
  existingMatchingUsageInfo:
    count: '50'
    timestamp: '2025-03-30T01:00:00Z'
  ...
  procurementStatus: DRAFTING
...

  2. Determine o número de instâncias consumíveis que o Compute Engine planeja reservar no horário de início da solicitação com base na afinidade de reserva:

    • Solicitações consumidas automaticamente: subtraia count de totalCount. Por exemplo, se count for 50 e totalCount for 100, o Compute Engine planeja reservar 50 instâncias de computação no horário de início. Se você modificar a solicitação, ou criar novas instâncias ou reservas que correspondam à solicitação, o Compute Engine vai atualizar o campo existingMatchingUsageInfo em até 30 minutos. Para verificar quando esse campo foi atualizado pela última vez, confira o valor de existingMatchingUsageInfo.timestamp.

    • Reservas especificamente segmentadas: o Compute Engine planeja reservar o valor especificado no campo totalCount no horário de início da solicitação.

REST

  1. Para ver uma lista das suas solicitações de reserva adiantada, faça uma solicitação GET ao método futureReservations.list. No URL da solicitação, inclua o parâmetro de consulta filter e especifique para mostrar apenas os campos name, specificSkuProperties e status:

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

    Substitua:

    • PROJECT_ID: o ID do projeto em que você criou as solicitações de reserva adiantada.

    • ZONE: a zona em que a solicitação de reserva adiantada existe.

    Na saída, encontre os campos count e totalCount para cada rascunho, solicitação pendente de aprovação ou aprovada:

    {
  "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. Determine o número de instâncias consumíveis que o Compute Engine planeja reservar no horário de início da solicitação com base na afinidade de reserva:

    • Solicitações consumidas automaticamente: subtraia count de totalCount. Por exemplo, se count for 50 e totalCount for 100, o Compute Engine vai planejar a reserva de 50 instâncias de computação no horário de início. Se você modificar a solicitação ou criar instâncias ou reservas que correspondam à solicitação, o Compute Engine vai atualizar o campo existingMatchingUsageInfo em até 30 minutos. Para verificar quando esse campo foi atualizado pela última vez, confira o valor de existingMatchingUsageInfo.timestamp.

    • Reservas especificamente segmentadas: o Compute Engine planeja reservar o valor especificado no campo totalCount no horário de início da solicitação.

Instâncias consumíveis em uma solicitação de reserva adiantada no modo de calendário

Ao visualizar os detalhes de uma solicitação de reserva adiantada, é possível ver quantas instâncias de computação o Compute Engine planeja provisionar no horário de início da solicitação. O Compute Engine cria o número de instâncias especificado na solicitação, independente do número de instâncias correspondentes no seu projeto ou em qualquer projeto com que a solicitação seja compartilhada.

Ver o consumo de reserva

Sempre que uma instância de computação consome uma reserva, é possível ver o seguinte:

Ver a reserva que uma instância está consumindo

Para conferir a reserva que uma instância está consumindo, selecione uma das seguintes opções:

Console

  1. No console do Google Cloud , acesse a página Instâncias de VM.

    Acessar instâncias de VM

  2. Clique no nome da instância que está consumindo uma reserva que você quer visualizar.

  3. Na seção Informações básicas, o campo Reserva consumida mostra o nome da reserva que a instância está consumindo.

gcloud

Para ver a reserva que uma instância está consumindo, use o comando gcloud compute instances describe com a flag --flatten=resourceStatus.reservationConsumptionInfo:

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

Substitua:

  • INSTANCE_NAME: o nome da instância.
  • ZONE: a zona em que a instância está.

Você verá uma saída semelhante a esta:

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

REST

Para ver a reserva que uma instância está consumindo, faça uma solicitação GET ao método instances.get. No URL da solicitação, inclua o parâmetro de consulta fields definido como resourceStatus.reservationConsumptionInfo:

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

Substitua:

  • PROJECT_ID: o ID do projeto em que a instância está.
  • ZONE: a zona em que a instância está.
  • INSTANCE_NAME: o nome da instância.

Você vai receber uma resposta semelhante a esta:

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

Conferir uma lista de instâncias que estão consumindo uma reserva

É possível ver uma lista de instâncias que consomem uma reserva em um único projeto. Para reservas compartilhadas, esse método retorna apenas as instâncias no projeto especificado. Ele não inclui instâncias de outros projetos de consumidor que estão consumindo a mesma reserva.

Para conferir as instâncias que estão consumindo uma reserva, selecione uma das seguintes opções:

gcloud

Para conferir as instâncias que estão consumindo uma reserva, use o comando gcloud compute instances list com a flag --filter definida como a reserva que você quer conferir:

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"

Substitua:

  • CONSUMER_PROJECT_ID: o ID do projeto que consome a reserva.
  • ZONE: a zona em que a reserva e as instâncias estão localizadas.
  • HOST_PROJECT_ID: o ID do projeto em que a reserva foi criada (se for diferente do projeto do consumidor).
  • RESERVATION_NAME: o nome da reserva.

Você verá uma saída semelhante a esta:

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

Para visualizar as instâncias que estão consumindo uma reserva, faça uma solicitação GET para o método instances.list. No URL da solicitação, inclua o parâmetro de consulta filter definido como o nome da reserva que você quer ver:

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

Substitua:

  • CONSUMER_PROJECT_ID: o ID do projeto que consome a reserva.
  • ZONE: a zona em que a reserva e as instâncias estão localizadas.
  • HOST_PROJECT_ID: o ID do projeto em que a reserva foi criada (se for diferente do projeto do consumidor).
  • RESERVATION_NAME: o nome da reserva.

Você verá uma resposta semelhante a esta:

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

A seguir