Esta página se ha traducido con Cloud Translation API.

Crear una reserva para un solo proyecto

En este documento se explica cómo crear una reserva de un solo proyecto, que solo pueden usar las instancias de máquina virtual (VM) del mismo proyecto. Para obtener más información sobre las reservas, consulta el artículo sobre la reserva de recursos de zona de Compute Engine.

Para ver otros métodos de creación de reservas, consulta las páginas siguientes:

Para crear una reserva que puedan usar varios proyectos, consulta Crear una reserva compartida.
Para crear una reserva al comprar un compromiso basado en recursos, consulta Comprar compromisos con reservas asociadas. Los compromisos ofrecen descuentos, conocidos como descuentos por uso confirmado (CUDs), en los costes de los recursos bajo demanda a cambio de comprar un nivel mínimo de recursos o de gastar un importe mínimo.

Antes de empezar

Consulta los requisitos y las restricciones de las reservas.
Si aún no lo has hecho, configura la autenticación. La autenticación verifica tu identidad para acceder a Google Cloud servicios y APIs. Para ejecutar código o ejemplos 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. Instala Google Cloud CLI. Después de la instalación, inicializa la CLI de Google Cloud ejecutando el siguiente comando:
  gcloud init
  Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.
  
  Nota: Si ya has instalado la CLI de gcloud, asegúrate de que tienes la versión más reciente ejecutando gcloud components update.
2. Set a default region and zone.
Terraform

Para usar las muestras de Terraform de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.
Para obtener más información, consulta Set up authentication for a local development environment.
REST

Para usar las muestras de la API REST de esta página en un entorno de desarrollo local, debes usar las credenciales que proporciones a la CLI de gcloud.
Para obtener más información, consulta el artículo Autenticarse para usar REST de la documentación sobre autenticación de Google Cloud .

Roles obligatorios

Para obtener los permisos que necesitas para crear reservas de un solo proyecto, pide a tu administrador que te conceda el rol de gestión de identidades y accesos Administrador de Compute (roles/compute.admin) en el proyecto. Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

Este rol predefinido contiene los permisos necesarios para crear reservas de un solo proyecto. Para ver los permisos exactos que se necesitan, despliega la sección Permisos necesarios:

Permisos obligatorios

Para crear reservas de un solo proyecto, se necesitan los siguientes permisos:

compute.reservations.create del proyecto
Para especificar una plantilla de instancia, siga estos pasos: compute.instanceTemplates.useReadOnly en la plantilla de instancia

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

Crear una reserva para un solo proyecto

Para consumir una reserva, una VM debe tener propiedades que coincidan exactamente con esa reserva. Para especificar las propiedades de las VMs que quiere reservar, seleccione una de las siguientes secciones de este documento:

Recomendación: Especifica una plantilla de instancia.

En esta sección se explica cómo usar una plantilla de instancia para definir las propiedades de una reserva. Si usas una plantilla de instancia, puedes definir las propiedades de una reserva y las VMs que pueden usarla en el mismo lugar.
Especificar una VM

En esta sección se explica cómo usar una VM para definir las propiedades de una reserva. Si usas las propiedades de una VM, puedes consumir la reserva creando VMs con propiedades que coincidan con la VM de referencia.
Especificar propiedades directamente

En esta sección se explica cómo definir directamente las propiedades de una reserva. Con este método, debe asegurarse manualmente de que las propiedades de sus máquinas virtuales y reservas coincidan exactamente. Si no coinciden, no se podrán consumir.

De forma predeterminada, cualquier VM con propiedades que coincidan con una reserva puede consumirla automáticamente. Si quieres controlar el consumo de reservas, haz una o varias de las siguientes acciones:

Crea una reserva que solo puedan usar las VMs que la tengan como objetivo específico, tal como se explica en las siguientes secciones de este documento. A continuación, configura las VMs para que usen esa reserva específica.
Configura las VMs para que no consuman reservas.

Además, puede especificar una política de emplazamiento compacta al crear una reserva específica de un solo proyecto. Una política de emplazamiento compacta especifica que las VMs deben estar lo más cerca posible entre sí para reducir la latencia de la red.

Especificar una plantilla de instancia

Para evitar errores al crear una reserva especificando una plantilla de instancia, asegúrate de que se cumplan los siguientes requisitos:

Crea la reserva en la misma región y zona que los recursos de la plantilla de instancia. Cualquier recurso regional o de zona especificado en una plantilla de instancia (como un tipo de máquina o un volumen de disco persistente) restringe el uso de la plantilla a las ubicaciones en las que se encuentran esos recursos. Por ejemplo, si tu plantilla de instancia especifica un volumen de disco persistente en la zona us-central1-a, solo podrás crear la reserva en esa zona. Para comprobar si una plantilla ya creada especifica algún recurso que la vincule a una región o zona concretas, consulta los detalles de la plantilla de instancia y busca referencias a recursos regionales o zonales en ella.
Si la plantilla de instancia especifica una política de colocación compacta, asegúrate de que la plantilla especifique un tipo de máquina compatible para las políticas de colocación compacta. De lo contrario, no se podrá crear la reserva.

Para crear una reserva de un solo proyecto especificando una plantilla de instancia, selecciona una de las siguientes opciones:

Consola

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

Ir a Reservas
En la pestaña Reservas bajo demanda (opción predeterminada), haz clic en Crear reserva.

Se abrirá la página Crear una reserva.
En Name (Nombre), escribe el nombre de la reserva.
En Región y Zona, selecciona dónde quieres reservar los recursos.
En la sección Tipo de uso compartido, seleccione Local si no está seleccionado.
Opcional: Para permitir que los trabajos de entrenamiento personalizado o los trabajos de predicción de Vertex AI consuman una reserva de VMs con GPU, en la sección Servicios de Google Cloud, selecciona Compartir reserva.
En la sección Uso con instancia de VM, selecciona una de las siguientes opciones:
- Para permitir que las VMs coincidentes consuman automáticamente esta reserva, selecciona Usar reserva automáticamente si aún no lo has hecho.
- Para consumir los recursos de esta reserva solo al crear VMs que coincidan y que se dirijan específicamente a esta reserva por su nombre, selecciona Seleccionar reserva específica.
  
  Nota: Si tu plantilla de instancia especifica un tipo de máquina A3 Mega, A3 High o A3 Edge, o bien una política de colocación compacta, debes seleccionar Seleccionar reserva específica. De lo contrario, se producirán errores.
En Número de instancias de VM, introduce el número de VMs que quieras reservar.
En la sección Configuración de la máquina, haga lo siguiente:
1. Para especificar las propiedades de tus VMs a partir de una plantilla de instancia, selecciona Usar plantilla de instancia.
2. En el campo Plantilla de instancia, selecciona la plantilla de instancia que quieras. Si seleccionas una plantilla de instancia regional, solo podrás reservar recursos en la región de la plantilla de instancia.
En la sección Eliminación automática, puedes habilitar esta opción para que Compute Engine elimine automáticamente la reserva en una fecha y hora concretas. Eliminar automáticamente las reservas puede ser útil para evitar cargos innecesarios cuando dejes de consumir la reserva.
Para crear la reserva, haz clic en Crear.

Se abrirá la página Reservas. La creación de la reserva de un solo proyecto puede tardar hasta un minuto.

gcloud

Para crear una reserva de un solo proyecto, usa el comando gcloud compute reservations create.

Para crear una reserva de un solo proyecto especificando una plantilla de instancia y sin incluir ninguna marca opcional, ejecuta el siguiente comando:

gcloud compute reservations create RESERVATION_NAME \
    --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

Haz los cambios siguientes:

RESERVATION_NAME: el nombre de la reserva que se va a crear.
PROJECT_ID: el ID del proyecto en el que quieres reservar recursos y en el que se encuentra la plantilla de instancia.
LOCATION: la ubicación de la plantilla de instancia. Se debe utilizar uno de los valores indicados a continuación.
- En el caso de una plantilla de instancia global, global.
- En el caso de una plantilla de instancia regional, regions/REGION. Sustituye REGION por la región en la que se encuentra la plantilla de instancia. Si especificas una plantilla de instancia regional, solo podrás reservar VMs en la misma región que la plantilla.
INSTANCE_TEMPLATE_NAME: nombre de una plantilla de instancia. Si la plantilla de instancia especifica un tipo de máquina A3 Mega, A3 High o A3 Edge, o una política de colocación compacta, debes incluir la marca --require-specific-reservation. Esto indica que solo las máquinas virtuales que se dirijan específicamente a la reserva podrán consumirla. Para obtener más información, consulta Consumir VMs de una reserva específica.
NUMBER_OF_VMS: número de máquinas virtuales que se van a reservar.
ZONE: la zona en la que se reservarán los recursos.

Por ejemplo, para crear una reserva de diez VMs en la zona us-central1-a especificando una plantilla de instancia global, ejecuta el siguiente comando:

gcloud compute reservations create my-reservation \
    --source-instance-template=projects/example-project/global/example-instance-template \
    --vm-count=10 \
    --zone=us-central1-a

También puede hacer lo siguiente:

Para especificar que solo las VMs que se dirijan específicamente a esta reserva puedan consumirla, incluya la marca --require-specific-reservation.

gcloud compute reservations create RESERVATION_NAME \
    --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
    --require-specific-reservation \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

Para permitir que las tareas de entrenamiento personalizadas o las tareas de predicción de Vertex AI consuman una reserva de VMs con GPU, incluye la marca --reservation-sharing-policy con el valor ALLOW_ALL.

gcloud compute reservations create RESERVATION_NAME \
    --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
    --reservation-sharing-policy=ALLOW_ALL \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

Para permitir que Compute Engine elimine automáticamente la reserva, seleccione uno de los siguientes métodos:

Vista previa — The --delete-at-time and --delete-after-duration flags

Esta función está sujetas a los "Términos de las Ofertas de Acceso Previo a la Disponibilidad General" de la sección Términos Generales de los Servicios de los Términos Específicos de los Servicios. Las funciones previas a la disponibilidad general están disponibles tal cual y pueden tener una compatibilidad y asistencia limitadas. Para obtener más información, consulta las descripciones de las fases de lanzamiento.
- Para eliminar la reserva en una fecha y hora concretas, usa el comando gcloud beta compute reservations create con la marca --delete-at-time.
```
gcloud beta compute reservations create RESERVATION_NAME \
    --delete-at-time=DELETE_AT_TIME \
    --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
  Sustituye DELETE_AT_TIME por una fecha y una hora en formato de marca de tiempo RFC 3339, que debe ser la siguiente: none YYYY-MM-DDTHH:MM:SSOFFSET
  
  Haz los cambios siguientes:
  - YYYY-MM-DD: una fecha con el formato de año de 4 dígitos, mes de 2 dígitos y día del mes de 2 dígitos, separados por guiones (-).
  - HH:MM:SS: hora con formato de hora de 2 dígitos en formato de 24 horas, minutos de 2 dígitos y segundos de 2 dígitos, separados por dos puntos (:).
  - OFFSET: la zona horaria con el formato de una diferencia con respecto al tiempo universal coordinado (UTC). Por ejemplo, para usar la hora estándar del Pacífico (PST), especifica -08:00. También puede especificar Z para no usar ningún desplazamiento.
- Para eliminar la reserva después de un periodo específico, usa el comando gcloud beta compute reservations create con la marca --delete-after-duration.
```
gcloud beta compute reservations create RESERVATION_NAME \
    --delete-after-duration=DELETE_AFTER_DURATION \
    --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
  Sustituye DELETE_AFTER_DURATION por una duración en días, horas, minutos o segundos. Por ejemplo, especifica 30m para 30 minutos o 1d2h3m4s para 1 día, 2 horas, 3 minutos y 4 segundos.

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

// Creates the reservation from given template in particular zone
func createReservation(w io.Writer, projectID, zone, reservationName, sourceTemplate string) error {
	// projectID := "your_project_id"
	// zone := "us-west3-a"
	// reservationName := "your_reservation_name"
	// template: existing template path. Following formats are allowed:
	//  	- projects/{project_id}/global/instanceTemplates/{template_name}
	//  	- projects/{project_id}/regions/{region}/instanceTemplates/{template_name}
	//  	- https://www.googleapis.com/compute/v1/projects/{project_id}/global/instanceTemplates/instanceTemplate
	//  	- https://www.googleapis.com/compute/v1/projects/{project_id}/regions/{region}/instanceTemplates/instanceTemplate

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

	req := &computepb.InsertReservationRequest{
		Project: projectID,
		ReservationResource: &computepb.Reservation{
			Name: proto.String(reservationName),
			Zone: proto.String(zone),
			SpecificReservation: &computepb.AllocationSpecificSKUReservation{
				Count:                  proto.Int64(2),
				SourceInstanceTemplate: proto.String(sourceTemplate),
			},
		},
		Zone: zone,
	}

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

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Reservation created\n")

	return nil
}

Java

import com.google.cloud.compute.v1.AllocationSpecificSKUReservation;
import com.google.cloud.compute.v1.Operation;
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.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateReservationForInstanceTemplate {

  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 = "YOUR_RESERVATION_NAME";
    // The number of virtual machines you want to create.
    int numberOfVms = 3;
    // The URI of the instance template with GLOBAL location
    // to be used for creating the reservation.
    String instanceTemplateUri =
        "projects/YOUR_PROJECT_ID/global/instanceTemplates/YOUR_INSTANCE_TEMPLATE_NAME";
    // The URI of the instance template with REGIONAL location
    // to be used for creating the reservation. For us-central1 region in this case.
    // String instanceTemplateUri =
    // "projects/YOUR_PROJECT_ID/regions/us-central1/instanceTemplates/YOUR_INSTANCE_TEMPLATE_NAME"

    createReservationForInstanceTemplate(
        projectId, reservationName, instanceTemplateUri, numberOfVms, zone);
  }

  // Creates a reservation in a project for the instance template.
  public static Reservation createReservationForInstanceTemplate(
      String projectId, String reservationName, String instanceTemplateUri,
      int numberOfVms, String zone)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // 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()) {
      Reservation reservation =
          Reservation.newBuilder()
              .setName(reservationName)
              .setZone(zone)
              .setSpecificReservation(
                  AllocationSpecificSKUReservation.newBuilder()
                      // Set the number of instances
                      .setCount(numberOfVms)
                      // Set the instance template to be used for creating the reservation.
                      .setSourceInstanceTemplate(instanceTemplateUri)
                      .build())
              .build();

      Operation response =
          reservationsClient.insertAsync(projectId, zone, reservation).get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        return null;
      }
      return reservationsClient.get(projectId, zone, reservationName);
    }
  }
}

Node.js

// Import the Compute library
const computeLib = require('@google-cloud/compute');
const compute = computeLib.protos.google.cloud.compute.v1;

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

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The ID of the project where you want to reserve resources and where the instance template exists.
const projectId = await reservationsClient.getProjectId();
// The zone in which to reserve resources.
const zone = 'us-central1-a';
// The name of the reservation to create.
// reservationName = 'reservation-01';
// The number of VMs to reserve.
const vmsNumber = 3;

/**
 * The name of an existing instance template.
 * TODO(developer): Uncomment and update instanceTemplateName before running the sample.
 */
// const instanceTemplateName = 'pernament-region-template-name';

/**
 * // The location of the instance template.
 * TODO(developer): Uncomment the `location` variable depending on which template you want to use.
 */

// The location for a regional instance template: regions/{region}. Replace region with the region where the instance template is located.
// If you specify a regional instance template, then you can only reserve VMs within the same region as the template's region.
// const location = `regions/${zone.slice(0, -2)}`;

// The location for a global instance template.
// const location = 'global';

async function callCreateComputeReservationInstanceTemplate() {
  // Create reservation for 3 VMs in zone us-central1-a by specifying a instance template.
  const specificReservation = new compute.AllocationSpecificSKUReservation({
    count: vmsNumber,
    sourceInstanceTemplate: `projects/${projectId}/${location}/instanceTemplates/${instanceTemplateName}`,
  });

  // Create a reservation.
  const reservation = new compute.Reservation({
    name: reservationName,
    specificReservation,
    // To specify that only VMs that specifically target this reservation can consume it,
    // set specificReservationRequired field to true.
    specificReservationRequired: true,
  });

  const [response] = await reservationsClient.insert({
    project: projectId,
    reservationResource: reservation,
    zone,
  });

  let operation = response.latestResponse;

  // Wait for the create reservation operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await zoneOperationsClient.wait({
      operation: operation.name,
      project: projectId,
      zone: operation.zone.split('/').pop(),
    });
  }

  console.log(`Reservation: ${reservationName} created.`);
}

await callCreateComputeReservationInstanceTemplate();

Python

from __future__ import annotations

import sys
from typing import Any

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


def create_reservation_from_template(
    project_id: str, reservation_name: str, template: str
) -> compute_v1.Reservation:
    """
    Create a new reservation based on an existing template.

    Args:
        project_id: project ID or project number of the Cloud project you use.
        reservation_name: the name of new reservation.
        template: existing template path. Following formats are allowed:
            - projects/{project_id}/global/instanceTemplates/{template_name}
            - projects/{project_id}/regions/{region}/instanceTemplates/{template_name}
            - https://www.googleapis.com/compute/v1/projects/{project_id}/global/instanceTemplates/instanceTemplate
            - https://www.googleapis.com/compute/v1/projects/{project_id}/regions/{region}/instanceTemplates/instanceTemplate

    Returns:
        Reservation object that represents the new reservation.
    """

    reservations_client = compute_v1.ReservationsClient()
    request = compute_v1.InsertReservationRequest()
    request.project = project_id
    request.zone = "us-central1-a"

    specific_reservation = compute_v1.AllocationSpecificSKUReservation()
    specific_reservation.count = 1
    specific_reservation.source_instance_template = template

    reservation = compute_v1.Reservation()
    reservation.name = reservation_name
    reservation.specific_reservation = specific_reservation

    request.reservation_resource = reservation
    operation = reservations_client.insert(request)
    wait_for_extended_operation(operation, "Reservation creation")

    return reservations_client.get(
        project=project_id, zone="us-central1-a", reservation=reservation_name
    )

REST

Para crear una reserva de un solo proyecto, envía una solicitud POST al método reservations.insert.

Para crear una reserva de un solo proyecto especificando una plantilla de instancia y sin incluir ninguna marca opcional, haz la siguiente solicitud POST:

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

{
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
  }
}

Haz los cambios siguientes:

PROJECT_ID: el ID del proyecto en el que quieres reservar recursos y en el que se encuentra la plantilla de instancia.
ZONE: la zona en la que se reservarán los recursos.
RESERVATION_NAME: el nombre de la reserva que se va a crear.
NUMBER_OF_VMS: número de máquinas virtuales que se van a reservar.
LOCATION: la ubicación de la plantilla de instancia. Se debe utilizar uno de los valores indicados a continuación.
- En el caso de una plantilla de instancia global, global.
- En el caso de una plantilla de instancia regional, regions/REGION. Sustituye REGION por la región en la que se encuentra la plantilla de instancia. Si especificas una plantilla de instancia regional, solo podrás reservar VMs en la misma región que la plantilla.
INSTANCE_TEMPLATE_NAME: nombre de una plantilla de instancia. Si la plantilla de instancia especifica un tipo de máquina A3 Mega, A3 High o A3 Edge, o bien una política de colocación compacta, debes incluir el campo specificReservationRequired en el cuerpo de la solicitud y asignarle el valor true. Esto indica que solo las VMs que se dirijan específicamente a esta reserva podrán consumirla. Para obtener más información, consulta Consumir VMs de una reserva específica.

Por ejemplo, para crear una reserva de diez VMs en la zona us-central1-a especificando una plantilla de instancia global, haz la siguiente solicitud POST:

POST https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/reservations

{
  "name": "my-reservation",
  "specificReservation": {
    "count": "10",
    "sourceInstanceTemplate": "projects/example-project/global/instanceTemplates/example-instance-template"
  }
}

También puede hacer lo siguiente:

Para especificar que solo las VMs que se dirijan específicamente a esta reserva puedan consumirla, incluya el campo specificReservationRequired en el cuerpo de la solicitud y asígnele el valor true.

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

{
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
  },
  "specificReservationRequired": true
}

Para permitir que los trabajos de entrenamiento personalizados o los trabajos de predicción de Vertex AI utilicen una reserva de VMs con GPU, incluye el campo serviceShareType y asigna el valor ALLOW_ALL.

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

{
  "name": "RESERVATION_NAME",
  "reservationSharingPolicy": {
    "serviceShareType": "ALLOW_ALL"
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
  }
}

Para permitir que Compute Engine elimine automáticamente la reserva, seleccione uno de los siguientes métodos:

Vista previa — The deleteAtTime and deleteAfterDuration fields

Esta función está sujetas a los "Términos de las Ofertas de Acceso Previo a la Disponibilidad General" de la sección Términos Generales de los Servicios de los Términos Específicos de los Servicios. Las funciones previas a la disponibilidad general están disponibles tal cual y pueden tener una compatibilidad y asistencia limitadas. Para obtener más información, consulta las descripciones de las fases de lanzamiento.
- Para eliminar la reserva en una fecha y hora concretas, haz una solicitud POST al método beta.reservations.insert. En el cuerpo de la solicitud, incluye el campo deleteAtTime.
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAtTime": "DELETE_AT_TIME",
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
  }
}
```
  Sustituye DELETE_AT_TIME por una fecha y una hora con el formato de una marca de tiempo RFC 3339, que debe ser la siguiente:
```
YYYY-MM-DDTHH:MM:SSOFFSET
```
  Haz los cambios siguientes:
  - YYYY-MM-DD: una fecha con el formato de año de 4 dígitos, mes de 2 dígitos y día del mes de 2 dígitos, separados por guiones (-).
  - HH:MM:SS: hora con formato de hora de 2 dígitos en formato de 24 horas, minutos de 2 dígitos y segundos de 2 dígitos, separados por dos puntos (:).
  - OFFSET: la zona horaria con el formato de una diferencia con respecto al tiempo universal coordinado (UTC). Por ejemplo, para usar la hora estándar del Pacífico (PST), especifica -08:00. También puede especificar Z para no usar ningún desplazamiento.
- Para eliminar la reserva después de un periodo específico, haz una POST solicitud al método beta.reservations.insert. En el cuerpo de la solicitud, incluye el campo deleteAfterDuration.
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAfterDuration": {
    "seconds": "DELETE_AFTER_DURATION"
  },
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
  }
}
```
  Sustituye DELETE_AFTER_DURATION por una duración en segundos. Por ejemplo, especifica 86400 para 86.400 segundos (1 día).

Especificar una VM

Solo puedes crear una reserva basada en una VM que esté en la misma zona que la VM.

Después de crear la reserva, puedes consumirla creando VMs con propiedades que coincidan con la VM de referencia. Para ello, tiene las siguientes opciones:

Crea y usa una plantilla de instancia de la siguiente manera:
1. Crea una plantilla de instancia basada en la VM de referencia sin anular las propiedades de la VM de referencia.
2. Crea VMs con la plantilla que acabas de crear de una de las siguientes formas:
  - Crear una sola VM
  - Crear un grupo de instancias gestionado zonal
Crea una VM basada en la VM de referencia y asegúrate de que las propiedades de la nueva VM y de la VM de referencia coincidan exactamente.

Para crear una reserva de un solo proyecto que use las propiedades de una VM, haz lo siguiente:

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

Ir a Reservas
Haz clic en Crear reserva.

Se abrirá la página Crear una reserva.
En Name (Nombre), escribe el nombre de la reserva.
En Región y Zona, selecciona dónde quieres reservar los recursos.
En la sección Tipo de uso compartido, haga clic en Local si aún no está seleccionado.
En la sección Uso con instancia de VM, selecciona una de las siguientes opciones:
- Para permitir que las VMs coincidentes consuman automáticamente esta reserva, selecciona Usar reserva automáticamente si aún no lo has hecho.
- Para consumir los recursos de esta reserva solo al crear VMs que coincidan y que se dirijan específicamente a esta reserva por su nombre, selecciona Seleccionar reserva específica.
  
  Nota: Si quieres especificar un tipo de máquina A3 mega, A3 high o A3 edge, o una política de asignación compacta en la reserva, debes seleccionar Seleccionar reserva específica. De lo contrario, se producirán errores.
En Número de instancias de VM, introduce el número de VMs que quieras reservar.
En la sección Configuración de la máquina, haga lo siguiente:
1. Selecciona Usar una máquina virtual disponible.
2. En VM existente, seleccione la VM cuyas propiedades quiera usar para crear la reserva.
Opcional: Para especificar una política de emplazamiento compacta para una reserva que cumpla los requisitos, vaya a la sección Política de emplazamiento de grupo, haga clic en la lista Seleccionar o crear una política de emplazamiento de grupo y, a continuación, haga una de las siguientes acciones:
- Para crear una política de posición compacta que se especifique en esta reserva, haz lo siguiente:
  
  Importante: Con este método, solo puedes crear una política de colocación compacta con un valor de distancia máxima no especificado. Si quiere especificar una nueva política de posición compacta con un valor de distancia máxima de 3 o 2, debe crear una política de posición compacta por separado y seleccionar la política de posición compacta que ya tenga.
  1. Haga clic en Crear política de emplazamiento de grupo.
    
    Aparecerá el panel Crear una política de emplazamiento de grupo.
  2. En Nombre de la política, escriba el nombre que quiera asignar a la política.
  3. Haz clic en Crear.
    
    La creación de la política de colocación compacta puede tardar unos segundos en completarse.
- De lo contrario, selecciona una política de colocación compacta.
En la sección Eliminación automática, puedes habilitar la opción de eliminación automática para que Compute Engine elimine automáticamente la reserva en una fecha y hora concretas. Eliminar reservas automáticamente puede ser útil para evitar cargos innecesarios cuando dejes de usar la reserva.
Para crear la reserva, haz clic en Crear.

Se abrirá la página Reservas. La creación de la reserva puede tardar hasta un minuto en completarse.

Especificar propiedades directamente

Para crear una reserva de un solo proyecto especificando las propiedades directamente, selecciona una de las siguientes opciones:

Consola

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

Ir a Reservas
En la pestaña Reservas bajo demanda (opción predeterminada), haz clic en Crear reserva.

Se abrirá la página Crear una reserva.
En Name (Nombre), escribe el nombre de la reserva.
En Región y Zona, selecciona dónde quieres reservar los recursos.
En la sección Tipo de uso compartido, haga clic en Local si aún no está seleccionado.
Opcional: Para permitir que los trabajos de entrenamiento personalizado o los trabajos de predicción de Vertex AI consuman una reserva de VMs con GPU, en la sección Servicios de Google Cloud, selecciona Compartir reserva.
En la sección Uso con instancia de VM, selecciona una de las siguientes opciones:
- Para permitir que las VMs coincidentes consuman automáticamente esta reserva, selecciona Usar reserva automáticamente si aún no lo has hecho.
- Para consumir los recursos de esta reserva solo al crear VMs que coincidan y que se dirijan específicamente a esta reserva por su nombre, selecciona Seleccionar reserva específica.
  
  Nota: Si quieres especificar un tipo de máquina A3 mega, A3 high o A3 edge, o una política de asignación compacta en la reserva, debes seleccionar Seleccionar reserva específica. De lo contrario, se producirán errores.
En Número de instancias de VM, introduce el número de VMs que quieras reservar.
En la sección Configuración de la máquina, selecciona Especificar tipo de máquina y, a continuación, indica lo siguiente:
1. En Familia de máquinas, Serie y Tipo de máquina, selecciona una familia, una serie y un tipo de máquina.
2. Opcional: Para especificar una plataforma de CPU mínima o adjuntar GPUs a VMs N1, haz lo siguiente:
  1. Para desplegar la sección Plataforma de CPU y GPU, haz clic en la flecha de desplegar.
  2. Opcional: Para especificar una plataforma de CPU mínima, en Plataforma de CPU, selecciona una opción.
  3. Opcional: Para asociar GPUs a máquinas virtuales N1, haz clic en Añadir GPU. A continuación, en Tipo de GPU y Número de GPUs, selecciona el tipo y el número de GPUs que quieras asociar a cada VM N1.
Opcional: Para asociar discos SSD locales a un tipo de máquina que no incluya discos SSD locales de forma predeterminada, haz lo siguiente:
1. En Número de discos, selecciona el número de discos SSD locales que quieras adjuntar.
2. En Tipo de interfaz, selecciona la interfaz de disco de los discos SSD locales.
Opcional: Para especificar una política de emplazamiento compacta para una reserva que cumpla los requisitos, en la sección Política de emplazamiento de grupo, haga clic en la lista Seleccionar o crear una política de emplazamiento de grupo y, a continuación, siga uno de estos pasos:
- Para crear una política de emplazamiento compacto que se especifique en esta reserva, haga lo siguiente:
  
  Importante: Con este método, solo puedes crear una política de colocación compacta con un valor de distancia máxima no especificado. Si quiere especificar una nueva política de posición compacta con un valor de distancia máxima de 3 o 2, debe crear una política de posición compacta por separado y seleccionar la política de posición compacta que ya tenga.
  1. Haga clic en Crear política de emplazamiento de grupo.
    
    Aparecerá el panel Crear una política de emplazamiento de grupo.
  2. En Nombre de la política, escriba el nombre que quiera asignar a la política.
  3. Haz clic en Crear.
    
    Crear la política de colocación compacta puede tardar unos segundos.
- De lo contrario, selecciona una política de colocación compacta.
En la sección Eliminación automática, puedes habilitar la opción de eliminación automática para que Compute Engine elimine automáticamente la reserva en una fecha y hora concretas. Eliminar automáticamente las reservas puede ser útil para evitar cargos innecesarios cuando dejes de consumir la reserva.
Para crear la reserva, haz clic en Crear.

Se abrirá la página Reservas. La creación de la reserva de un solo proyecto puede tardar hasta un minuto.

gcloud

Para crear una reserva de un solo proyecto, usa el comando gcloud compute reservations create.

Para crear una reserva de un solo proyecto especificando las propiedades directamente y sin incluir ninguna marca opcional, ejecuta el siguiente comando:

gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

Haz los cambios siguientes:

RESERVATION_NAME: el nombre de la reserva que se va a crear.
MACHINE_TYPE: un tipo de máquina que se usará en cada VM. Si especificas un tipo de máquina A3 Mega, A3 High o A3 Edge, debes incluir la marca --require-specific-reservation. Esto indica que solo las máquinas virtuales que se dirijan específicamente a la reserva podrán consumirla. Para obtener más información, consulta Consumir VMs de una reserva específica.
NUMBER_OF_VMS: número de máquinas virtuales que se van a reservar.
ZONE: la zona en la que se reservarán los recursos.

Por ejemplo, para crear una reserva en la zona us-central1-a para diez VMs que usen un tipo de máquina predefinido N2 con 4 vCPUs, ejecuta el siguiente comando:

gcloud compute reservations create my-reservation \
    --machine-type=n2-standard-4 \
    --vm-count=10 \
    --zone=us-central1-a

También puede hacer lo siguiente:

Para asociar GPUs a tus VMs N1 reservadas, incluye la marca --accelerator.
```
gcloud compute reservations create RESERVATION_NAME \
    --accelerator=count=NUMBER_OF_ACCELERATORS,type=ACCELERATOR_TYPE \
    --machine-type=MACHINE_TYPE \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
Haz los cambios siguientes:
- NUMBER_OF_ACCELERATORS: número de GPUs que se van a añadir por máquina virtual reservada.
- ACCELERATOR_TYPE: un modelo de GPU compatible con máquinas virtuales N1. Comprueba que el modelo de GPU que has elegido esté disponible en la zona en la que quieras reservar recursos. De lo contrario, no se podrá crear la reserva.
Para conectar discos SSD locales a un tipo de máquina que no incluya discos SSD locales de forma predeterminada, incluye la marca --local-ssd. Solo puedes conectar discos SSD locales de 375 GB.
```
gcloud compute reservations create RESERVATION_NAME \
    --local-ssd=count=NUMBER_OF_LOCAL_SSD_DISKS,size=375,interface=INTERFACE_TYPE \
    --machine-type=MACHINE_TYPE \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
Haz los cambios siguientes:
- NUMBER_OF_LOCAL_SSD_DISKS: número de discos SSD locales que se van a adjuntar.
- INTERFACE_TYPE: el tipo de interfaz de disco que quieres que use cada disco SSD local y que admita el tipo de máquina que has especificado. Se debe utilizar uno de los valores indicados a continuación.
  - Para la interfaz de disco NVMe: nvme
  - Para la interfaz de disco SCSI: scsi
Para que las VMs reservadas usen una plataforma de CPU mínima específica en lugar de la plataforma de CPU predeterminada de la zona, incluye la marca --min-cpu-platform.
```
gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --min-cpu-platform="MIN_CPU_PLATFORM" \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
Sustituye MIN_CPU_PLATFORM por una plataforma de CPU mínima. Para asegurarte de que una plataforma de CPU está disponible en la zona en la que vas a reservar recursos, consulta las plataformas de CPU disponibles por zona.

Para especificar que solo las VMs que se dirijan específicamente a esta reserva puedan consumirla, incluya la marca --require-specific-reservation.

gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --require-specific-reservation \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

Para especificar una política de colocación compacta para reducir la latencia de red entre las VMs, incluye la marca --resource-policies=policy.
```
gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --resource-policies=policy=COMPACT_PLACEMENT_POLICY_NAME \
    --require-specific-reservation \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
Sustituye COMPACT_PLACEMENT_POLICY_NAME por el nombre de una política de emplazamiento compacta que ya tengas. Además, para evitar errores al crear una reserva de un solo proyecto que especifique una política de colocación compacta, asegúrese de especificar lo siguiente:
- Un tipo de máquina admitido y el número máximo de VMs para las políticas de colocación compacta.
- Una zona de la región en la que se encuentra la política de colocación compacta.
- La bandera de --require-specific-reservation. Esto indica que solo las máquinas virtuales que se dirijan específicamente a la reserva podrán consumirla.
Para permitir que las tareas de entrenamiento personalizadas o las tareas de predicción de Vertex AI consuman una reserva de VMs con GPU, incluye la marca --reservation-sharing-policy con el valor ALLOW_ALL.
```
gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --reservation-sharing-policy=ALLOW_ALL \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
Para permitir que Compute Engine elimine automáticamente la reserva, seleccione uno de los siguientes métodos:

Vista previa — The --delete-at-time and --delete-after-duration flags

Esta función está sujetas a los "Términos de las Ofertas de Acceso Previo a la Disponibilidad General" de la sección Términos Generales de los Servicios de los Términos Específicos de los Servicios. Las funciones previas a la disponibilidad general están disponibles tal cual y pueden tener una compatibilidad y asistencia limitadas. Para obtener más información, consulta las descripciones de las fases de lanzamiento.
- Para eliminar la reserva en una fecha y hora concretas, usa el comando gcloud beta compute reservations create con la marca --delete-at-time.
```
gcloud beta compute reservations create RESERVATION_NAME \
    --delete-at-time=DELETE_AT_TIME \
    --machine-type=MACHINE_TYPE \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
  Sustituye DELETE_AT_TIME por una fecha y una hora con el formato de una marca de tiempo RFC 3339, que debe ser la siguiente:
```
YYYY-MM-DDTHH:MM:SSOFFSET
```
  Haz los cambios siguientes:
  - YYYY-MM-DD: una fecha con el formato de año de 4 dígitos, mes de 2 dígitos y día del mes de 2 dígitos, separados por guiones (-).
  - HH:MM:SS: hora con formato de hora de 2 dígitos en formato de 24 horas, minutos de 2 dígitos y segundos de 2 dígitos, separados por dos puntos (:).
  - OFFSET: la zona horaria con el formato de una diferencia con respecto al tiempo universal coordinado (UTC). Por ejemplo, para usar la hora estándar del Pacífico (PST), especifica -08:00. También puede especificar Z para no usar ningún desplazamiento.
- Para eliminar la reserva después de un periodo específico, usa el comando gcloud beta compute reservations create con la marca --delete-after-duration.
```
gcloud beta compute reservations create RESERVATION_NAME \
    --delete-after-duration=DELETE_AFTER_DURATION \
    --machine-type=MACHINE_TYPE \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
  Sustituye DELETE_AFTER_DURATION por una duración en días, horas, minutos o segundos. Por ejemplo, especifica 30m para 30 minutos o 1d2h3m4s para 1 día, 2 horas, 3 minutos y 4 segundos.

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

// Creates the reservation with accelerated image
func createBaseReservation(w io.Writer, projectID, zone, reservationName string) 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 err
	}
	defer reservationsClient.Close()

	// Creating reservation based on direct properties
	req := &computepb.InsertReservationRequest{
		Project: projectID,
		ReservationResource: &computepb.Reservation{
			Name: proto.String(reservationName),
			Zone: proto.String(zone),
			SpecificReservation: &computepb.AllocationSpecificSKUReservation{
				Count: proto.Int64(2),
				// Properties, which allows customising instances
				InstanceProperties: &computepb.AllocationSpecificSKUAllocationReservedInstanceProperties{
					// Attaching GPUs to the reserved VMs
					// Read more: https://cloud.google.com/compute/docs/gpus#n1-gpus
					GuestAccelerators: []*computepb.AcceleratorConfig{
						{
							AcceleratorCount: proto.Int32(1),
							AcceleratorType:  proto.String("nvidia-tesla-t4"),
						},
					},
					// Including local SSD disks
					LocalSsds: []*computepb.AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk{
						{
							DiskSizeGb: proto.Int64(375),
							Interface:  proto.String("NVME"),
						},
					},
					MachineType: proto.String("n1-standard-2"),
					// Specifying minimum CPU platform
					// Read more: https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform
					MinCpuPlatform: proto.String("Intel Skylake"),
				},
			},
		},
		Zone: zone,
	}

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

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Reservation created\n")

	return nil
}

Java

import com.google.cloud.compute.v1.AcceleratorConfig;
import com.google.cloud.compute.v1.AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk;
import com.google.cloud.compute.v1.AllocationSpecificSKUAllocationReservedInstanceProperties;
import com.google.cloud.compute.v1.AllocationSpecificSKUReservation;
import com.google.cloud.compute.v1.Operation;
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.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateReservation {

  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 disk.
    String zone = "us-central1-a";
    // Name of the reservation you want to create.
    String reservationName = "YOUR_RESERVATION_NAME";
    // Number of instances in the reservation.
    int numberOfVms = 3;

    createReservation(projectId, reservationName, numberOfVms, zone);
  }

  // Creates reservation with optional flags
  public static Reservation createReservation(
      String projectId, String reservationName, int numberOfVms, String zone)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Create the reservation with optional properties:
    // Machine type of the instances in the reservation.
    String machineType = "n1-standard-2";
    // Number of accelerators to be attached to the instances in the reservation.
    int numberOfAccelerators = 1;
    // Accelerator type to be attached to the instances in the reservation.
    String acceleratorType = "nvidia-tesla-t4";
    // Minimum CPU platform to be attached to the instances in the reservation.
    String minCpuPlatform = "Intel Skylake";
    // Local SSD size in GB to be attached to the instances in the reservation.
    int localSsdSize = 375;
    // Local SSD interfaces to be attached to the instances in the reservation.
    String localSsdInterface1 = "NVME";
    String localSsdInterface2 = "SCSI";
    boolean specificReservationRequired = true;
    // 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()) {
      Reservation reservation =
          Reservation.newBuilder()
              .setName(reservationName)
              .setZone(zone)
              .setSpecificReservationRequired(specificReservationRequired)
              .setSpecificReservation(
                  AllocationSpecificSKUReservation.newBuilder()
                      // Set the number of instances
                      .setCount(numberOfVms)
                      // Set instance properties
                      .setInstanceProperties(
                          AllocationSpecificSKUAllocationReservedInstanceProperties.newBuilder()
                              .setMachineType(machineType)
                              .setMinCpuPlatform(minCpuPlatform)
                              .addGuestAccelerators(
                                  AcceleratorConfig.newBuilder()
                                      .setAcceleratorCount(numberOfAccelerators)
                                      .setAcceleratorType(acceleratorType)
                                      .build())
                              .addLocalSsds(
                            AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk
                                      .newBuilder()
                                      .setDiskSizeGb(localSsdSize)
                                      .setInterface(localSsdInterface1)
                                      .build())
                              .addLocalSsds(
                            AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk
                                      .newBuilder()
                                      .setDiskSizeGb(localSsdSize)
                                      .setInterface(localSsdInterface2)
                                      .build())
                              .build())
                      .build())
              .build();

      Operation response =
          reservationsClient.insertAsync(projectId, zone, reservation).get(7, TimeUnit.MINUTES);

      if (response.hasError()) {
        return null;
      }
      return reservationsClient.get(projectId, zone, reservationName);
    }
  }
}

Node.js

// Import the Compute library
const computeLib = require('@google-cloud/compute');
const compute = computeLib.protos.google.cloud.compute.v1;

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

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The ID of the project where you want to reserve resources.
const projectId = await reservationsClient.getProjectId();
// The zone in which to reserve resources.
const zone = 'us-central1-a';
// The name of the reservation to create.
// reservationName = 'reservation-01';
// The number of VMs to reserve.
const vmsNumber = 3;
// Machine type to use for each VM.
const machineType = 'n1-standard-4';

async function callCreateComputeReservationFromProperties() {
  // Create specific reservation for 3 VMs that each use an N1 predefined machine type with 4 vCPUs.
  const specificReservation = new compute.AllocationSpecificSKUReservation({
    count: vmsNumber,
    instanceProperties: {
      machineType,
      // To have the reserved VMs use a specific minimum CPU platform instead of the zone's default CPU platform.
      minCpuPlatform: 'Intel Skylake',
      // If you want to attach GPUs to your reserved N1 VMs, update and uncomment guestAccelerators if needed.
      // guestAccelerators: [
      //   {
      //     // The number of GPUs to add per reserved VM.
      //     acceleratorCount: 1,
      //     // Supported GPU model for N1 VMs. Ensure that your chosen GPU model is available in the zone,
      //     // where you want to reserve resources.
      //     acceleratorType: 'nvidia-tesla-t4',
      //   },
      // ],
      // If you want to add local SSD disks to each reserved VM, update and uncomment localSsds if needed.
      // You can specify up to 24 Local SSD disks. Each Local SSD disk is 375 GB.
      // localSsds: [
      //   {
      //     diskSizeGb: 375,
      //     // The type of interface you want each Local SSD disk to use. Specify one of the following values: NVME or SCSI.
      //     // Make sure that the machine type you specify for the reserved VMs supports the chosen disk interfaces.
      //     interface: 'NVME',
      //   },
      // ],
    },
  });

  // Create a reservation.
  const reservation = new compute.Reservation({
    name: reservationName,
    zone,
    specificReservation,
    // To specify that only VMs that specifically target this reservation can consume it,
    // set specificReservationRequired field to true.
    specificReservationRequired: true,
  });

  const [response] = await reservationsClient.insert({
    project: projectId,
    reservationResource: reservation,
    zone,
  });

  let operation = response.latestResponse;

  // Wait for the create reservation operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await zoneOperationsClient.wait({
      operation: operation.name,
      project: projectId,
      zone: operation.zone.split('/').pop(),
    });
  }

  console.log(`Reservation: ${reservationName} created.`);
}

await callCreateComputeReservationFromProperties();

Python

from __future__ import annotations

import sys
from typing import Any

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


def create_compute_reservation(
    project_id: str,
    zone: str = "us-central1-a",
    reservation_name="your-reservation-name",
) -> compute_v1.Reservation:
    """Creates a compute reservation in GCP.
    Args:
        project_id (str): The ID of the Google Cloud project.
        zone (str): The zone to create the reservation.
        reservation_name (str): The name of the reservation to create.
    Returns:
        Reservation object that represents the new reservation.
    """

    instance_properties = compute_v1.AllocationSpecificSKUAllocationReservedInstanceProperties(
        machine_type="n1-standard-1",
        # Optional. Specifies the minimum CPU platform for the VM instance.
        min_cpu_platform="Intel Ivy Bridge",
        # Optional. Specifies amount of local ssd to reserve with each instance.
        local_ssds=[
            compute_v1.AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk(
                disk_size_gb=375, interface="NVME"
            ),
            compute_v1.AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk(
                disk_size_gb=375, interface="SCSI"
            ),
        ],
        # Optional. Specifies the GPUs allocated to each instance.
        # guest_accelerators=[
        #     compute_v1.AcceleratorConfig(
        #         accelerator_count=1, accelerator_type="nvidia-tesla-t4"
        #     )
        # ],
    )

    reservation = compute_v1.Reservation(
        name=reservation_name,
        specific_reservation=compute_v1.AllocationSpecificSKUReservation(
            count=3,  # Number of resources that are allocated.
            # If you use source_instance_template, you must exclude the instance_properties field.
            # It can be a full or partial URL.
            # source_instance_template="projects/[PROJECT_ID]/global/instanceTemplates/my-instance-template",
            instance_properties=instance_properties,
        ),
    )

    # Create a client
    client = compute_v1.ReservationsClient()

    operation = client.insert(
        project=project_id,
        zone=zone,
        reservation_resource=reservation,
    )
    wait_for_extended_operation(operation, "Reservation creation")

    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

Terraform

Para crear una reserva de un solo proyecto, usa el recurso de Terraform google_compute_reservation.

Por ejemplo, para crear una reserva de un solo proyecto para un tipo de máquina predefinido N2 con 2 vCPUs, usa el siguiente recurso:


resource "google_compute_reservation" "default" {
  name = "gce-reservation-local"
  zone = "us-central1-a"

  /**
   * To specify a single-project reservation, omit the share_settings block
   * (default) or set the share_type field to LOCAL.
   */
  share_settings {
    share_type = "LOCAL"
  }

  specific_reservation {
    count = 1
    instance_properties {
      machine_type = "n2-standard-2"
    }
  }

  /**
   * To let VMs with affinity for any reservation consume this reservation, omit
   * the specific_reservation_required field (default) or set it to false.
   */
  specific_reservation_required = false
}

Para obtener más información sobre cómo usar Terraform, consulta Usar Terraform con Google Cloud.

REST

Para crear una reserva de un solo proyecto, envía una solicitud POST al método reservations.insert.

Para crear una reserva de un solo proyecto especificando las propiedades directamente y sin incluir ningún campo opcional, haz la siguiente solicitud POST:

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

{
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}

Haz los cambios siguientes:

PROJECT_ID: el ID del proyecto en el que quieres reservar recursos.
ZONE: la zona en la que se reservarán los recursos.
RESERVATION_NAME: el nombre de la reserva que se va a crear.
NUMBER_OF_VMS: número de máquinas virtuales que se van a reservar.
MACHINE_TYPE: un tipo de máquina que se usará en cada VM. Si especificas un tipo de máquina A3 Mega, A3 High o A3 Edge, debes incluir el campo specificReservationRequired en el cuerpo de la solicitud y asignarle el valor true. Esto indica que solo las máquinas virtuales que se dirijan específicamente a la reserva podrán consumirla. Para obtener más información, consulta Consumir VMs de una reserva específica.

Por ejemplo, para crear una reserva en la zona us-central1-a para diez VMs que usen un tipo de máquina predefinido N2 con 4 vCPUs, haz la siguiente solicitud POST:

POST https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/reservations

{
  "name": "my-reservation",
  "specificReservation": {
    "count": "10",
    "instanceProperties": {
      "machineType": "n2-standard-4",
    }
  }
}

También puede hacer lo siguiente:

Para asociar GPUs a tus VMs N1 reservadas, incluye el campo guestAccelerators en el cuerpo de la solicitud.
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "guestAccelerators": [
        {
          "acceleratorCount": NUMBER_OF_ACCELERATORS,
          "acceleratorType": "ACCELERATOR_TYPE"
        }
      ],
      "machineType": "MACHINE_TYPE"
    }
  }
}
```
Haz los cambios siguientes:
- NUMBER_OF_ACCELERATORS: número de GPUs que se van a añadir por máquina virtual reservada.
- ACCELERATOR_TYPE: un modelo de GPU compatible con máquinas virtuales N1. Comprueba que el modelo de GPU que has elegido esté disponible en la zona en la que quieras reservar recursos. De lo contrario, no se podrá crear la reserva.
Para asociar discos SSD locales a un tipo de máquina que no incluya discos SSD locales de forma predeterminada, incluye el campo localSsds en el cuerpo de la solicitud. Solo puedes adjuntar discos SSD locales de 375 GB.

Por ejemplo, para asociar dos discos SSD locales al tipo de máquina que quieras reservar, haz una solicitud como la siguiente:
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "localSsds": [
        {
          "diskSizeGb": "375",
          "interface": "INTERFACE_TYPE"
        },
        {
          "diskSizeGb": "375",
          "interface": "INTERFACE_TYPE"
        }
      ],
      "machineType": "MACHINE_TYPE"
    }
  }
}
```
Sustituye INTERFACE_TYPE por el tipo de interfaz de disco que quieras que use cada disco SSD local y que admita el tipo de máquina que hayas especificado. Se debe utilizar uno de los valores indicados a continuación.
- Para la interfaz de disco NVMe: NVME
- Para la interfaz de disco SCSI: SCSI
Para que las VMs reservadas usen una plataforma de CPU mínima específica en lugar de la plataforma de CPU predeterminada de la zona, incluya el campo minCpuPlatform en el cuerpo de la solicitud.
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE",
      "minCpuPlatform": "MIN_CPU_PLATFORM"
    }
  }
}
```
Sustituye MIN_CPU_PLATFORM por una plataforma de CPU mínima. Para asegurarte de que una plataforma de CPU está disponible en la zona en la que vas a reservar recursos, consulta las plataformas de CPU disponibles por zona.
Para especificar una política de colocación compacta y reducir la latencia de red entre tus VMs reservadas, incluye el campo resourcePolicies en el cuerpo de la solicitud.
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "resourcePolicies": {
    "policy" : "projects/example-project/regions/REGION/resourcePolicies/COMPACT_PLACEMENT_POLICY_NAME"
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  },
  "specificReservationRequired": true
}
```
Haz los cambios siguientes:
- REGION: la región en la que se encuentra la política de colocación compacta. Solo puedes crear la reserva en la región de la política de emplazamiento.
- COMPACT_PLACEMENT_POLICY_NAME: el nombre de una política de posición compacta.
Además, para evitar errores al crear una reserva de un solo proyecto que especifique una política de colocación compacta, asegúrate de especificar lo siguiente:
- Un tipo de máquina compatible con las políticas de colocación compacta.
- El campo specificReservationRequired se ha definido como true. Esto indica que solo las máquinas virtuales que se dirijan específicamente a esta reserva podrán consumirla.

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

{
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  },
  "specificReservationRequired": true
}

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

{
  "name": "RESERVATION_NAME",
  "reservationSharingPolicy": {
    "serviceShareType": "ALLOW_ALL"
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}

Para permitir que Compute Engine elimine automáticamente la reserva, seleccione uno de los siguientes métodos:

Vista previa — The deleteAtTime and deleteAfterDuration fields

Esta función está sujetas a los "Términos de las Ofertas de Acceso Previo a la Disponibilidad General" de la sección Términos Generales de los Servicios de los Términos Específicos de los Servicios. Las funciones previas a la disponibilidad general están disponibles tal cual y pueden tener una compatibilidad y asistencia limitadas. Para obtener más información, consulta las descripciones de las fases de lanzamiento.
- Para eliminar la reserva en una fecha y hora concretas, haz una solicitud POST al método beta.reservations.insert. En el cuerpo de la solicitud, incluye el campo deleteAtTime.
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAtTime": "DELETE_AT_TIME",
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}
```
  Sustituye DELETE_AT_TIME por una fecha y una hora con el formato de una marca de tiempo RFC 3339, que debe ser la siguiente:
```
YYYY-MM-DDTHH:MM:SSOFFSET
```
  Haz los cambios siguientes:
  - YYYY-MM-DD: una fecha con el formato de año de 4 dígitos, mes de 2 dígitos y día del mes de 2 dígitos, separados por guiones (-).
  - HH:MM:SS: hora con formato de hora de 2 dígitos en formato de 24 horas, minutos de 2 dígitos y segundos de 2 dígitos, separados por dos puntos (:).
  - OFFSET: la zona horaria con el formato de una diferencia con respecto al tiempo universal coordinado (UTC). Por ejemplo, para usar la hora estándar del Pacífico (PST), especifica -08:00. También puede especificar Z para no usar ningún desplazamiento.
- Para eliminar la reserva después de un periodo específico, haz una POST solicitud al método beta.reservations.insert. En el cuerpo de la solicitud, incluye el campo deleteAfterDuration.
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAfterDuration": {
    "seconds": "DELETE_AFTER_DURATION"
  },
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}
```
  Sustituye DELETE_AFTER_DURATION por una duración en segundos. Por ejemplo, especifica 86400 para 86.400 segundos (1 día).

Solución de problemas

Consulta cómo solucionar problemas al crear reservas.

Siguientes pasos

Consulta cómo ver tus reservas.
Consulta cómo asociar reservas a compromisos.
Consulta cómo consumir reservas.
Consulta cómo monitorizar el consumo de reservas.

Crear una reserva para un solo proyecto Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Antes de empezar

Console

gcloud

Terraform

REST

Roles obligatorios

Permisos obligatorios

Crear una reserva para un solo proyecto

Especificar una plantilla de instancia

Consola

gcloud

Go

Java

Node.js

Python

REST

Especificar una VM

Especificar propiedades directamente

Consola

gcloud

Go

Java

Node.js

Python

Terraform

REST

Solución de problemas

Siguientes pasos

Crear una reserva para un solo proyecto