Se usó la API de Cloud Translation para traducir esta página.

Ver reservas

En este documento, se explica cómo ver reservas.

La visualización de reservas es útil para obtener una descripción general de todas las reservas en tu proyecto o revisar los detalles de configuración de una reserva. Si deseas ver una reserva compartida, solo puedes verla con el proyecto propietario.

Antes de comenzar

Si aún no lo hiciste, configura la autenticación. La autenticación es el proceso mediante el cual se verifica tu identidad para acceder a los servicios y las API de Google Cloud. Para ejecutar código o muestras desde un entorno de desarrollo local, puedes autenticarte en Compute Engine seleccionando una de las siguientes opciones:

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

When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.
gcloud
1. Install the Google Cloud CLI, then initialize it by running the following command:
  gcloud init
  Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
2. Set a default region and zone.

Roles obligatorios

Si quieres obtener los permisos que necesitas para ver reservas, pídele a tu administrador que te otorgue el rol de IAM Administrador de Compute (roles/compute.admin) en el proyecto. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

Este rol predefinido contiene los permisos necesarios para ver reservas. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

Se requieren los siguientes permisos para ver las reservas:

Para ver una lista de reservas: compute.reservations.list en el proyecto
Para ver los detalles de una reserva: compute.reservations.get en el proyecto

También puedes obtener estos permisos con roles personalizados o con otros roles predefinidos.

Ver reservas

Para ver información sobre una reserva en tu proyecto, usa uno de los siguientes métodos:

Para obtener una descripción general de todas las reservas de tu proyecto, consulta una lista de tus reservas.
Para obtener los detalles completos de una reserva específica, consulta los detalles de una reserva.

Visualiza una lista de tus reservas

Para ver una lista de tus reservas, selecciona una de las siguientes opciones:

Console

En la consola de Google Cloud, ve a la página Reservas.

Ir a Reservas
En la pestaña Reservas según demanda (predeterminada), en la tabla, cada fila describe una reserva y cada columna describe una propiedad.
Opcional: Para modificar qué reservas y propiedades se muestran, usa Filtro y Opciones de visualización de columnas respectivamente.

gcloud

Para ver una lista de tus reservas, usa el comando gcloud compute reservations list.

gcloud compute reservations list

El resultado debería ser similar al siguiente ejemplo:

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

De forma opcional, para limitar una lista de reservas con una expresión de filtro, incluye la marca --filter.

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

Reemplaza FILTER_EXPRESSION por una expresión de filtro.

Por ejemplo, para ver solo las reservas con un nombre que comienza con prefix y se encuentran en la zona us-central1-a, ejecuta el siguiente comando:

gcloud compute reservations list \
    --filter="name~prefix AND zone=us-central1-a"

Go

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
}

Java

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

Node.js

// 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();

Python

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

REST

Para ver una lista de tus reservas, realiza una solicitud GET al método reservations.list.

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

Reemplaza lo siguiente:

PROJECT_ID: el ID del proyecto en el que se encuentran tus reservas.
ZONE: Es la zona donde se encuentran tus recursos.

El resultado es similar al siguiente ejemplo.

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

De forma opcional, para limitar una lista de reservas con una expresión de filtro, incluye el parámetro de consulta filter de la siguiente manera:

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

Reemplaza lo siguiente:

PROJECT_ID: el ID del proyecto en el que se encuentran tus reservas.
ZONE: Es la zona donde se encuentran tus recursos.
FILTER_EXPRESSION: es una expresión de filtro.

Por ejemplo, para ver solo las reservas con un nombre que comienza con prefix y se encuentran en la zona us-central1-a, realiza la siguiente solicitud GET con valores codificados en URL:

GET https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/reservations?filter=name%7Eprefix%20AND%20zone=us-central1-a

Cómo ver los detalles de una reserva

Para ver cuántas VMs consume cada producto de Google Cloud compatible en una reserva, consulta los detalles de la reserva con la consola de Google Cloud. De lo contrario, selecciona cualquiera de las siguientes opciones:

Console

En la consola de Google Cloud, ve a la página Reservas.

Ir a Reservas
En la pestaña Reservas según demanda (predeterminada), en la columna Nombre, haz clic en el nombre de la reserva de la que deseas ver los detalles.

Se abrirá la página de detalles de la reserva. Si deseas ver el campo Recuento garantizado, debes consultar una lista de tus reservas.

gcloud

Para ver los detalles de una reserva, usa el comando gcloud compute reservations describe.

gcloud compute reservations describe RESERVATION_NAME \
    --zone=ZONE

Reemplaza lo siguiente:

RESERVATION_NAME: Es el nombre de una reserva existente.
ZONE: Es la zona en la que se encuentra la reserva.

El resultado es similar a este:

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

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

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

// 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();

Python

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 los detalles de una reserva, haz una solicitud GET al método reservations.get.

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

Reemplaza lo siguiente:

PROJECT_ID: El ID del proyecto en el que se encuentra la reserva.
ZONE: Es la zona en la que se encuentra la reserva.
RESERVATION_NAME: Es el nombre de una reserva existente.

El resultado es similar a este:

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

Determina la cantidad de VMs consumibles

Cuando veas una reserva, puedes determinar cuántas VMs la consumen y cuántas más VMs pueden consumirla. Para ello, verifica los siguientes campos:

Recuento garantizado (assuredCount): Es la cantidad de VMs que se reservan físicamente en la zona de la reserva para tu proyecto y para cualquier proyecto con el que se comparte una reserva compartida.
Recuento total (count): Es la cantidad de VMs reservadas que se especifica en la reserva. Este número debe coincidir con el recuento garantizado.

Precaución: Si el recuento garantizado de una reserva es inferior al recuento total, se reservan menos VMs de las esperadas. Para resolver este problema, consulta Menos VMs disponibles para el consumo.
Máquinas en uso (inUseCount): Es la cantidad de VMs en ejecución en tu proyecto, o un proyecto con el que se comparte una reserva, que consumen la reserva.

Por ejemplo, si el recuento garantizado (assuredCount) y el recuento total (count) son ambos 50, y la cantidad de VMs que consumen la reserva (inUseCount) es 25, entonces 25 VMs consumen la reserva, y puedes crear y ejecutar 25 VMs más antes de que se consuma por completo.

¿Qué sigue?

Obtén más información para adjuntar reservas a los compromisos.
Obtén información sobre cómo consumir reservas.
Obtén información sobre cómo modificar reservas.
Obtén más información sobre cómo borrar reservas.

Ver reservas

Antes de comenzar

Console

gcloud

Terraform

Go

Java

Node.js

Python

REST

Roles obligatorios

Permisos necesarios

Ver reservas

Visualiza una lista de tus reservas

Console

gcloud

Go

Java

Node.js

Python

REST

Cómo ver los detalles de una reserva

Console

gcloud

Go

Java

Node.js

Python

REST

Determina la cantidad de VMs consumibles

¿Qué sigue?