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

Crear una reserva compartida

En este documento, se explica cómo crear reservas compartidas, que son reservas compartidas en varios proyectos y administrar qué proyectos de tu organización pueden consumirlas.

El proyecto que creó la reserva (proyecto de propietario) y los proyectos con los que se comparte la reserva (proyectos de consumidores) pueden usar una reserva compartida. Usa las reservas compartidas si tu organización tiene varios proyectos que necesitan instancias de máquina virtual (VM) con las mismas propiedades reservadas. Mediante las reservas compartidas, puedes mejorar el uso de tus reservas y reducir la cantidad de reservas que necesitas crear y administrar. Si quieres obtener información sobre las reservas, consulta Reservas para recursos zonales de Compute Engine.

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

Si tienes compromisos de 1 o 3 años en el proyecto actual, tus recursos reservados reciben de forma automática los descuentos por compromiso de uso aplicables (CUD). También puedes crear y adjuntar una reserva a un compromiso cuando compras el compromiso. Para obtener más información, consulta Adjunta reservas a compromisos.
Para crear una reserva que únicamente pueda usar un solo proyecto, consulta Crea una reserva para un solo proyecto.

Antes de comenzar

Revisa los requisitos y las y las restricciones para las reservas.
Revisa los requisitos de cuota y las y las restricciones para las reservas.
Asegúrate de que el proyecto que usas para crear reservas compartidas haya sido agregado a la lista de entidades permitidas de la restricción de la política de la organización Proyectos de propietario de las reservas compartidas (compute.sharedReservationsOwnerProjects) por un administrador de políticas de la organización. Esta lista de entidades permitidas está vacía de forma predeterminada, por lo que no puedes crear reservas compartidas hasta que tu organización otorgue este permiso a uno o más proyectos. Para obtener más detalles sobre cómo ver y editar la restricción de la política de la organización, consulta Permite y restringe la creación y la modificación de reservas compartidas para los proyectos en este documento.
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

Para obtener los permisos que necesitas para crear reservas compartidas, pídele a tu administrador que te otorgue los siguientes roles de IAM:

Administrador de Compute (roles/compute.admin) en el proyecto
Para ver y editar las políticas de la organización: Administrador de políticas de la organización (roles/orgpolicy.policyAdmin) en la organización.

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

Estos roles predefinidos contienen los permisos necesarios para crear reservas compartidas. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

Se requieren los siguientes permisos para crear reservas compartidas:

compute.reservations.create en el proyecto
Para ver las políticas de la organización, usa orgpolicy.policy.get en la organización.
Para editar las políticas de la organización, haz lo siguiente: orgpolicy.policy.set en la organización
Para especificar una plantilla de instancias: usa compute.instanceTemplates.useReadOnly en la plantilla de instancias

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

Prácticas recomendadas

Cuando crees reservas compartidas, se recomiendan las siguientes prácticas recomendadas. Si las sigues, puedes ayudar a optimizar la administración y el uso de las reservas compartidas en tu organización.

Haz que el proyecto de propietario cree la reserva compartida, pero no la consuma.
- Para distribuir los gastos entre los proyectos, se recomienda que solo los proyectos de consumidor consuman una reserva compartida. El proyecto propietario solo debe usarse para crear la reserva compartida.
- Cuando se crea una reserva compartida, el proyecto propietario debe tener una cuota suficiente para el total de recursos que se reservarán. Luego, después de crear la reserva, el proyecto propietario debe tener una cuota para cualquier recurso reservado que desee consumir. Si deseas obtener más información, consulta Requisitos de cuota adicionales para las reservas compartidas.
Minimiza la cantidad de proyectos en tu organización a los que les permites crear reservas compartidas. Puedes controlar esto a través de la restricción de la política de la organización Proyectos de propietario de las reservas compartidas (compute.sharedReservationsOwnerProjects).
- Solo puedes enumerar las reservas que creó cada proyecto. Esto significa que las reservas compartidas solo se enumeran en el proyecto de propietario (no puedes enumerar las reservas compartidas con cada proyecto o todas las reservas compartidas en cada organización), por lo que tener solo algunos proyectos de propietario facilita la supervisión y la administración de tus reservas compartidas.
- Limita el uso compartido de una reserva compartida a algunos proyectos solo para administrar la cuota de tus recursos reservados con mayor facilidad.
- Para obtener más información, consulta Permite y restringe la creación y la modificación de reservas compartidas para los proyectos.
Minimiza la cantidad de reservas compartidas independientes con propiedades de VM idénticas.
- Una organización puede tener hasta 100 reservas compartidas para cada combinación única de propiedades de VM. Como resultado, minimizar la cantidad de reservas compartidas con propiedades de VM idénticas que creas ayuda a mitigar este límite.
- Tener menos reservas compartidas mejora la administración.
Solo comparte las reservas entre proyectos con la misma cuenta de Facturación de Cloud.
- Limita cada reserva compartida para que solo se comparta con proyectos de consumidor que tengan la misma cuenta de Facturación de Cloud que el proyecto del propietario. Esto te facilita ver si se consumió una reserva y cómo se facturaba.
- Si habilitaste el uso compartido de CUD y eres apto para recibir CUD a nivel de la cuenta de Facturación de Cloud, limita los CUD que recibas para tus reservas consumidas tus reservas compartidas a la cuenta de Facturación de Cloud de ese compromiso. Esto te permite mantener una facturación coherente en todos los proyectos que crean y consumen reservas compartidas.
Para las solicitudes de reserva futuras, revisa con cuidado el recuento total de VMs que solicitas.
- Si creas una solicitud de reserva futura, asegúrate de solicitar un recuento total de VMs que tengan en cuenta todos los siguientes elementos:
  - Todas las VMs reservadas que coincidan que ya existirán en la fecha futura.
  - Todas las VMs sin reservar que coincidan que ya existirán en la fecha futura.
  - Cualquier reserva según demanda que no esté en uso y que ya exista en la fecha futura.
  - El aumento en el uso que deseas reservar en la fecha futura
  Por ejemplo, supongamos que necesitas 10 VMs adicionales en la fecha futura y ya tendrás los siguientes recursos en la fecha futura:
  - 40 VMs reservadas que coinciden
  - 50 VMs sin reservar que coinciden
  o
  - 40 VMs reservadas que coinciden
  - 50 reservas según demanda sin usar que coinciden
  Debido a que el uso existente en la fecha futura ya agrega hasta 90 VMs y reservas coincidentes, y necesitas diez VMs adicionales, debes especificar un recuento total de 100 en la solicitud de reserva futura.
  
  Nota: Si creas reservas según demanda adicionales después de enviar la solicitud de reserva futura y antes de la fecha futura, estas se consideran en el recuento total.
  
  Si después de la fecha futura agregas más reservas bajo demanda, esas reservas se agregan al recuento total anterior. Por ejemplo, si después de la fecha futura reservas otras diez VMs, tienes 110 reservas.
  
  Para obtener más información, consulta Recuenta y aprovisiona recursos reservados.

Permite y restringe la creación y la modificación de reservas compartidas para los proyectos

De forma predeterminada, no se permite a los proyectos crear o cambiar reservas compartidas en una organización. Agrega proyectos a la restricción de la política de la organización Proyectos de propietario de las reservas compartidas (compute.sharedReservationsOwnerProjects) para permitirles crear y cambiar reservas compartidas. Para obtener más información sobre las restricciones de las políticas de la organización, consulta Introducción al servicio de las políticas de la organización.

Sigue estos pasos para ver y cambiar la restricción de la política de la organización Proyectos de propietario de las reservas compartidas (compute.sharedReservationsOwnerProjects).

Visualiza la restricción de la política de la organización de reservas compartidas

Para ver qué proyectos tienen permiso para crear y cambiar reservas compartidas, usa la consola de Google Cloud o la CLI de gcloud.

Console

Sigue los pasos para ver las políticas de la organización mediante la restricción Proyectos de propietario de las reservas compartidas.

gcloud

Para ver a qué proyectos permite la restricción compute.sharedReservationsOwnerProjects crear y cambiar reservas compartidas, haz lo siguiente:

Descarga la política para tu organización como un archivo llamado policy.yaml mediante el comando gcloud resource-manager org-policies describe:
```
gcloud resource-manager org-policies describe compute.sharedReservationsOwnerProjects --organization=ORGANIZATION_ID > policy.yaml
```
Reemplaza ORGANIZATION_ID por el ID de organización de tu organización.
Usa un editor de texto para abrir el archivo policy.yaml y ver la restricción compute.sharedReservationsOwnerProjects. Los proyectos que tienen permiso para crear y cambiar reservas compartidas se enumeran en allowedValues:
```
...
constraint: constraints/compute.sharedReservationsOwnerProjects
listPolicy:
  allowedValues:
  - projects/PROJECT_NUMBER_1
  - projects/PROJECT_NUMBER_2
  - projects/PROJECT_NUMBER_3
...
```
En el ejemplo anterior, PROJECT_NUMBER_1, PROJECT_NUMBER_2 y PROJECT_NUMBER_3 son los números de proyecto de los únicos proyectos de tu organización que tienen permiso para crear reservas compartidas.
Borra el archivo policy.yaml (opcional).
- Si usas una terminal de Linux o macOS, usa el siguiente comando:
```
rm policy.yaml
```
- Si usas una terminal de Windows, usa el siguiente comando:
```
del policy.yaml
```

Edita la restricción de la política de la organización de reservas compartidas

Para cambiar los proyectos que tienen permiso para crear y cambiar reservas compartidas, usa la consola de Google Cloud o la CLI de gcloud.

Console

Sigue los pasos para personalizar las políticas para restricciones de listas con la restricción Proyectos de propietario de las reservas compartidas.

gcloud

Para cambiar a qué proyectos permite la restricción compute.sharedReservationsOwnerProjects crear y cambiar reservas compartidas, usa uno de los siguientes métodos:

Para otorgar permiso a un solo proyecto para crear y cambiar reservas compartidas, usa el comando gcloud resource-manager org-policies allow. Puedes repetir este comando para cada proyecto al que le quieras otorgar este permiso.
```
gcloud resource-manager org-policies allow compute.sharedReservationsOwnerProjects projects/PROJECT_NUMBER \
    --organization=ORGANIZATION_ID
```
Reemplaza lo siguiente:
- PROJECT_NUMBER: El número del proyecto (no el ID del proyecto) de un proyecto de tu organización que deseas permitir que cree y modifique reservas compartidas.
- ORGANIZATION_ID: el ID de organización de tu organización.
Para otorgar o revocar los permisos para varios proyectos para crear y cambiar reservas compartidas, reemplaza la restricción de la política de la organización:
1. Para descargar la política para tu organización como un archivo llamado policy.yaml, usa el comando gcloud resource-manager org-policies describe:
```
gcloud resource-manager org-policies describe compute.sharedReservationsOwnerProjects --organization=ORGANIZATION_ID > policy.yaml
```
  Reemplaza ORGANIZATION_ID por el ID de organización de tu organización.
2. Usa un editor de texto para cambiar el archivo policy.yaml de manera que la restricción compute.sharedReservationsOwnerProjects enumere todos los proyectos a los que deseas otorgarles permisos para crear y cambiar reservas compartidas en allowedValues.
  - Por cada proyecto al que desees otorgar el permiso para crear y cambiar reservas compartidas, agrega el proyecto en una línea nueva en allowedValues.
  - Para cada proyecto al que le quieras revocar el permiso para crear y cambiar reservas compartidas, borra la línea para ese proyecto.
  Cuando termines, asegúrate de que el archivo policy.yaml sea similar al que aparece a continuación:
```
...
constraint: constraints/compute.sharedReservationsOwnerProjects
listPolicy:
  allowedValues:
  - projects/PROJECT_NUMBER_1
  - projects/PROJECT_NUMBER_2
  - projects/PROJECT_NUMBER_3
...
```
  En el ejemplo anterior, PROJECT_NUMBER_1, PROJECT_NUMBER_2 y PROJECT_NUMBER_3 son los números de proyecto (no los ID del proyecto) de todos los proyectos de tu organización a los que deseas otorgarles permisos para crear y cambiar reservas compartidas.
3. Guarda el archivo policy.yaml y cierra el editor de texto.
4. Para actualizar la política para tu organización con los cambios, usa el comando gcloud resource-manager org-policies set-policy:
```
gcloud resource-manager org-policies set-policy --organization=ORGANIZATION_ID policy.yaml
```
  Reemplaza ORGANIZATION_ID por el ID de organización de tu organización.
5. Borra el archivo policy.yaml (opcional).
  - Si usas una terminal de Linux o macOS, usa el siguiente comando:
```
rm policy.yaml
```
  - Si usas una terminal de Windows, usa el siguiente comando:
```
del policy.yaml
```

Es posible que debas esperar unos minutos para que se aplique la edición.

Crear una reserva compartida

En esta sección, se explica cómo crear reservas compartidas. Después de crear una reserva compartida, solo el propietario del proyecto puede modificarla, sin embargo, el propietario o cualquier consumidor del proyecto pueden consumir los recursos para una reserva compartida.

Para consumir una reserva, una VM debe tener propiedades que coincidan de forma exacta con esa reserva. Para especificar las propiedades de las VMs que deseas reservar, elige una de las siguientes secciones de este documento:

Recomendado: Especifica una plantilla de instancias

En esta sección, se explica cómo usar una plantilla de instancias para definir las propiedades de una reserva compartida. Con una plantilla de instancias, puedes definir las propiedades de una reserva y las VMs que pueden consumirla en el mismo lugar. Sin embargo, debido a que las plantillas son específicas del proyecto, no puedes usar la misma plantilla para crear VMs que puedan consumir la reserva fuera del proyecto que creó esa reserva. Para los proyectos con los que se comparte una reserva compartida, debes crear plantillas similares o VMs mediante la especificación directa de las propiedades.
Especifica una VM existente

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

En esta sección, se explica cómo definir directamente las propiedades de una reserva compartida. Este método requiere que te asegures de forma manual de que las propiedades de las VMs y las reservas coincidan exactamente; las propiedades no coincidentes impiden el consumo.

De forma predeterminada, las VMs con propiedades que coincidan con una reserva pueden consumirla de forma automática. Si quieres controlar el consumo de reservas, haz una o más de las siguientes acciones:

Crea una reserva que solo puedan consumir las VMs que se orientan a ella, como se explica en las siguientes secciones de este documento. Luego, configura las VMs para que consuman esa reserva específica.
Configura las VMs que no pueden consumir ninguna reserva.

Especifica una plantilla de instancias

Antes de crear una reserva mediante la especificación de una plantilla de instancias, asegúrate de lo siguiente:

Una plantilla de instancias contiene una configuración específica del proyecto, por lo que solo puedes acceder a ella y usarla dentro del mismo proyecto. Si creas una reserva compartida especificando una plantilla de instancias, no puedes usar la misma plantilla para crear VMs que puedan consumir la reserva fuera del proyecto que creó la reserva.
Crea tu reserva en la misma región y zona que los recursos dentro de la plantilla de instancias. Cualquier recurso zonal o regional especificado en una plantilla de instancias (como un tipo de máquina o un volumen de Persistent Disk) restringe el uso de la plantilla en las ubicaciones en las que existen esos recursos. Por ejemplo, si tu plantilla de instancias especifica un volumen de Persistent Disk existente en la zona us-central1-a, solo puedes crear tu reserva en la misma zona. Para verificar si una plantilla existente especifica algún recurso que vincula la plantilla a una región o zona específica, consulta los detalles de la plantilla y busca referencias a recursos regionales o zonales dentro.

Para crear una reserva compartida a través de la especificación de una plantilla de instancias, elige una de las siguientes opciones:

Console

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

Ir a Reservas

Aparecerá la página Reservas.
Haz clic en Crear reserva.

Aparecerá la página Crear una reserva.
En Nombre, ingresa un nombre para tu reserva.
En Región y Zona, selecciona dónde deseas reservar los recursos.
En la sección Tipo de fuente, haz lo siguiente:
1. Para especificar una reserva compartida, selecciona Compartido.
2. Haz clic en Agregar proyectos y elige los proyectos de la organización actual del proyecto con el que quieres compartir la reserva. Puedes seleccionar hasta 100 proyectos de consumidor.
Opcional: Para permitir que una reserva de VMs con GPU sea consumida por trabajos de entrenamiento personalizados o trabajos de predicción en Vertex AI, en la sección Servicios de Google Cloud, selecciona Compartir reserva.
En la sección Usar con instancia de VM, selecciona una de las siguientes opciones:
- Para permitir que las instancias de VM coincidentes usen de forma automática esta reserva, selecciona Usar reserva de forma automática si aún no está seleccionada.
- Para consumir los recursos de esta reserva solo cuando creas VMs coincidentes que se dirigen de forma específica a esta reserva por nombre, elige Seleccionar reserva específica.
  
  Nota: Si tu plantilla de instancia especifica un tipo de máquina A3, debes elegir Seleccionar reserva específica. De lo contrario, tendrás errores.
En Cantidad de instancias de VM, ingresa la cantidad de VMs que deseas reservar.
En la sección Configuración de la máquina, selecciona Usar plantilla de instancias y, luego, elige la plantilla que prefieras. Si seleccionas una plantilla de instancias regional, solo puedes reservar recursos dentro de la misma región que la región de la plantilla.
En la sección Eliminación automática, puedes habilitar la opción de eliminación automática para permitir que Compute Engine borre la reserva en una fecha y hora específicas de forma automática. La eliminación automática de reservas puede ser útil para evitar cargos innecesarios cuando dejas de consumir la reserva.
Para crear la reserva, haz clic en Crear.

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

gcloud

Para crear una reserva compartida, usa el comando gcloud compute reservations create con las marcas --share-setting=projects y --share-with.

Para crear una reserva compartida con la especificación de una plantilla de instancias sin marcas opcionales, ejecuta el siguiente comando:

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

Reemplaza lo siguiente:

RESERVATION_NAME: Es el nombre de la reserva que se creará.
PROJECT_ID: Es el ID del proyecto en el que deseas reservar los recursos y donde existe la plantilla de instancias.
CONSUMER_PROJECT_IDS: una lista separada por comas de IDs de proyectos que pueden consumir esta reserva, por ejemplo project-1,project-2. Puedes incluir hasta 100 proyectos de consumidor. Estos proyectos deben estar en la misma organización que el proyecto de propietario. No incluyas el proyecto de propietario. De forma predeterminada, ya se puede consumir la reserva.
LOCATION: la ubicación de la plantilla de instancias. Especifica uno de los siguientes valores:
- Para una plantilla de instancias global: global.
- Para una plantilla de instancias regional: regions/REGION. Reemplaza REGION por la región en la que se encuentra la plantilla de instancias. Si especificas una plantilla de instancias regional, solo puedes reservar VMs dentro de la misma región que la región de la plantilla.
INSTANCE_TEMPLATE_NAME: Es nombre de una plantilla de instancias existente. Si la plantilla de instancias especifica un tipo de máquina A3, debes incluir la marca --require-specific-reservation. Esto indica que solo las VMs que se dirigen a esta reserva de forma específica pueden consumirla. Para obtener más información, consulta Consume las VMs de una reserva específica.
NUMBER_OF_VMS: La cantidad de VMs que se reservarán.
ZONE: Es la zona en la que se reservarán los recursos.

Por ejemplo, para crear una reserva con la especificación de una plantilla de instancias global en la zona us-central1-a, comparte la reserva con los proyectos project-1 y project-2 y reserva diez VMs que usen un tipo predefinido de máquina N2 con 4 CPU virtuales, ejecuta el siguiente comando:

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

De manera opcional, puedes hacer una o más de las siguientes acciones:

Para especificar que solo las VMs que se dirigen a esta reserva de forma específica pueden consumirla, incluye la marca --require-specific-reservation.

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

Para permitir que una reserva de VMs de GPU sea consumida por trabajos de entrenamiento personalizados o por trabajos de predicción en Vertex AI, usa el comando gcloud beta compute reservations create con la marca --reservation-sharing-policy=ALLOW_ALL.

Vista previa — The --reservation-sharing-policy flag

Esta función está sujeta a las "Condiciones de las Ofertas de Fase Previa a la DG" de la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Las funciones de fase previa a la DG están disponibles “tal cual” y podrían tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.
```
gcloud beta compute reservations create RESERVATION_NAME \
    --reservation-sharing-policy=ALLOW_ALL \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
Para permitir que Compute Engine borre automáticamente la reserva, selecciona uno de los siguientes métodos:

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

Esta función está sujeta a las "Condiciones de las Ofertas de Fase Previa a la DG" de la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Las funciones de fase previa a la DG están disponibles “tal cual” y podrían tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.
- Para borrar la reserva en una fecha y hora específicas, 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 \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
  Reemplaza DELETE_AT_TIME por una fecha y hora con formato de marca de tiempo RFC 3339, que debe ser de la siguiente manera:
```
YYYY-MM-DDTHH:MM:SSOFFSET
```
  Reemplaza lo siguiente:
  - YYYY-MM-DD: una fecha con formato de un año de 4 dígitos, un mes de 2 dígitos y un día de 2 dígitos del mes separado por guiones (-).
  - HH:MM:SS: una hora con formato de hora de 2 dígitos con un formato de 24 horas, minutos de 2 dígitos y segundos de 2 dígitos separados por dos puntos (:).
  - OFFSET: la zona horaria con formato como una compensación del horario universal coordinado (UTC). Por ejemplo, para usar la hora estándar del Pacífico (PST), especifica -08:00. Como alternativa, para no usar compensación, especifica Z.
- Para borrar la reserva después de una duración específica, 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 \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
  Reemplaza 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"

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

// Creates shared reservation from given template in particular zone
func createSharedReservation(w io.Writer, client ClientInterface, projectID, baseProjectId, zone, reservationName, sourceTemplate string) error {
	// client, err := compute.NewReservationsRESTClient(ctx)
	// projectID := "your_project_id". Destination of sharing.
	// baseProjectId := "your_project_id2". Project where the reservation will be created.
	// zone := "us-west3-a"
	// reservationName := "your_reservation_name"
	// sourceTemplate: 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()

	shareSettings := map[string]*computepb.ShareSettingsProjectConfig{
		projectID: {ProjectId: proto.String(projectID)},
	}

	req := &computepb.InsertReservationRequest{
		Project: baseProjectId,
		ReservationResource: &computepb.Reservation{
			Name: proto.String(reservationName),
			Zone: proto.String(zone),
			SpecificReservation: &computepb.AllocationSpecificSKUReservation{
				Count:                  proto.Int64(2),
				SourceInstanceTemplate: proto.String(sourceTemplate),
			},
			ShareSettings: &computepb.ShareSettings{
				ProjectMap: shareSettings,
				ShareType:  proto.String("SPECIFIC_PROJECTS"),
			},
		},
		Zone: zone,
	}

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

	if op != nil {
		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 com.google.cloud.compute.v1.ShareSettings;
import com.google.cloud.compute.v1.ShareSettingsProjectConfig;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateSharedReservation {
  private final ReservationsClient reservationsClient;

  // Constructor to inject the ReservationsClient
  public CreateSharedReservation(ReservationsClient reservationsClient) {
    this.reservationsClient = reservationsClient;
  }

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // The ID of the project where you want to reserve resources
    // and where the instance template exists.
    // By default, no projects are allowed to create or modify shared reservations
    // in an organization. Add projects to the Shared Reservations Owner Projects
    // (compute.sharedReservationsOwnerProjects) organization policy constraint
    // to allow them to create and modify shared reservations.
    // For more information visit this page:
    // https://cloud.google.com/compute/docs/instances/reservations-shared#shared_reservation_constraint
    String projectId = "YOUR_PROJECT_ID";
    // Zone in which the reservation resides.
    String zone = "us-central1-a";
    // Name of the reservation to be created.
    String reservationName = "YOUR_RESERVATION_NAME";
    // The URI of the global instance template to be used for creating the reservation.
    String instanceTemplateUri = String.format(
        "projects/%s/global/instanceTemplates/YOUR_INSTANCE_TEMPLATE_NAME", projectId);
    // Number of instances for which capacity needs to be reserved.
    int vmCount = 3;
    // In your main method, create ReservationsClient
    ReservationsClient client = ReservationsClient.create();
    // Create an instance of your class, passing in the client
    CreateSharedReservation creator = new CreateSharedReservation(client);

    creator.createSharedReservation(projectId, zone, reservationName, instanceTemplateUri, vmCount);
  }

  // Creates a shared reservation with the given name in the given zone.
  public void createSharedReservation(
      String projectId, String zone,
      String reservationName, String instanceTemplateUri, int vmCount)
      throws ExecutionException, InterruptedException, TimeoutException {

    ShareSettings shareSettings = ShareSettings.newBuilder()
        .setShareType(String.valueOf(ShareSettings.ShareType.SPECIFIC_PROJECTS))
        // The IDs of projects that can consume this reservation. You can include up to 100
        // consumer projects. These projects must be in the same organization as
        // the owner project. Don't include the owner project. By default, it is already allowed
        // to consume the reservation.
        .putProjectMap("CONSUMER_PROJECT_ID_1", ShareSettingsProjectConfig.newBuilder().build())
        .putProjectMap("CONSUMER_PROJECT_ID_2", ShareSettingsProjectConfig.newBuilder().build())
        .build();

    // Create the reservation.
    Reservation reservation =
        Reservation.newBuilder()
            .setName(reservationName)
            .setZone(zone)
            .setSpecificReservationRequired(true)
            .setShareSettings(shareSettings)
            .setSpecificReservation(
                AllocationSpecificSKUReservation.newBuilder()
                    .setCount(vmCount)
                    .setSourceInstanceTemplate(instanceTemplateUri)
                    .build())
            .build();

    // Wait for the create reservation operation to complete.
    Operation response =
        this.reservationsClient.insertAsync(projectId, zone, reservation).get(3, TimeUnit.MINUTES);

    if (response.hasError()) {
      System.out.println("Reservation creation failed!" + response);
      return;
    }
    System.out.println("Reservation created. Operation Status: " + response.getStatus());
  }
}

Node.js

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

/**
 * TODO(developer): Uncomment reservationsClient and zoneOperationsClient before running the sample.
 */
// Instantiate a reservationsClient
// reservationsClient = new computeLib.ReservationsClient();
// Instantiate a zoneOperationsClient
// zoneOperationsClient = new computeLib.ZoneOperationsClient();

/**
 * TODO(developer): Update 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.
const reservationName = 'reservation-01';
// The number of VMs to reserve.
const vmsNumber = 3;
// The name of an existing instance template.
const instanceTemplateName = 'global-instance-template-name';
// The location of the instance template.
const location = 'global';

async function callCreateComputeSharedReservation() {
  // 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 share settings. Share reservation with one customer project.
  const shareSettings = new compute.ShareSettings({
    shareType: 'SPECIFIC_PROJECTS',
    projectMap: {
      // The IDs of projects that can consume this reservation. You can include up to 100 consumer projects.
      // These projects must be in the same organization as the owner project.
      // Don't include the owner project. By default, it is already allowed to consume the reservation.
      consumer_project_id: {
        projectId: 'consumer_project_id',
      },
    },
  });

  // Create a reservation.
  const reservation = new compute.Reservation({
    name: reservationName,
    specificReservation,
    specificReservationRequired: true,
    shareSettings,
  });

  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.`);
  return response;
}

return await callCreateComputeSharedReservation();

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_shared_reservation(
    project_id: str,
    zone: str = "us-central1-a",
    reservation_name="your-reservation-name",
    shared_project_id: str = "shared-project-id",
) -> 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.
        shared_project_id (str): The ID of the project that the reservation is shared with.
    Returns:
        Reservation object that represents the new reservation.
    """

    instance_properties = compute_v1.AllocationSpecificSKUAllocationReservedInstanceProperties(
        machine_type="n1-standard-1",
        # Optional. Specifies amount of local ssd to reserve with each instance.
        local_ssds=[
            compute_v1.AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk(
                disk_size_gb=375, interface="NVME"
            ),
        ],
    )

    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,
        ),
        share_settings=compute_v1.ShareSettings(
            share_type="SPECIFIC_PROJECTS",
            project_map={
                shared_project_id: compute_v1.ShareSettingsProjectConfig(
                    project_id=shared_project_id
                )
            },
        ),
    )

    # 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
    )
    shared_project = next(iter(reservation.share_settings.project_map.values()))

    print("Name: ", reservation.name)
    print("STATUS: ", reservation.status)
    print("SHARED PROJECT: ", shared_project)
    # Example response:
    # Name:  your-reservation-name
    # STATUS:  READY
    # SHARED PROJECT:  project_id: "123456789012"

    return reservation

REST

Para crear una reserva compartida, realiza una solicitud POST al método reservations.insert. En el cuerpo de la solicitud, incluye lo siguiente:

El campo projectMap
El campo shareType configurado como SPECIFIC_PROJECTS.

Por ejemplo, para crear una reserva compartida mediante la especificación de una plantilla de instancias sin campos opcionales y compartir la reserva con dos proyectos de consumidor, haz la siguiente solicitud POST:

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

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
  }
}

Reemplaza lo siguiente:

PROJECT_ID: Es el ID del proyecto en el que deseas reservar los recursos y donde existe la plantilla de instancias.
ZONE: Es la zona en la que se reservarán los recursos.
RESERVATION_NAME: Es el nombre de la reserva que se creará.
CONSUMER_PROJECT_ID_1 y CONSUMER_PROJECT_ID_2: los IDs de los proyectos que pueden consumir esta reserva. Puedes incluir hasta 100 proyectos de consumidor. Estos proyectos deben estar en la misma organización que el proyecto de propietario. No incluyas el proyecto de propietario. De forma predeterminada, ya está permitido consumir la reserva.
NUMBER_OF_VMS: La cantidad de VMs que se reservarán.
LOCATION: la ubicación de la plantilla de instancias. Especifica uno de los siguientes valores:
- Para una plantilla de instancias global: global.
- Para una plantilla de instancias regional: regions/REGION. Reemplaza REGION por la región en la que se encuentra la plantilla de instancias. Si especificas una plantilla de instancias regional, solo puedes reservar VMs dentro de la misma región que la región de la plantilla.
INSTANCE_TEMPLATE_NAME: Es nombre de una plantilla de instancias existente. Si la plantilla de instancias especifica un tipo de máquina A3, debes incluir el campo specificReservationRequired en el cuerpo de la solicitud y configurar el campo como true. Esto indica que solo las VMs que se dirigen a esta reserva de forma específica pueden consumirla. Para obtener más información, consulta Consume las VMs de una reserva específica.

Por ejemplo, para crear una reserva para diez VMs en la zona us-central1-a mediante la especificación de una plantilla de instancias global y compartir la reserva con los proyectos project-1 y project-2, haz la siguiente solicitud POST:

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

{
  "name": "my-reservation",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "project-1": {
        "projectId": "project-1"
      },
      "project-2": {
        "projectId": "project-2"
      }
    }
  },
  "specificReservation": {
    "count": "10",
    "sourceInstanceTemplate": "projects/example-project/global/instanceTemplates/example-instance-template"
  }
}

De manera opcional, puedes hacer una o más de las siguientes acciones:

Para especificar que solo las VMs que se dirigen a esta reserva de forma específica pueden consumirla, incluye el campo specificReservationRequired en el cuerpo de la solicitud y configúralo como true.

Por ejemplo, para crear una reserva específica mediante la especificación de una plantilla de instancias y compartirla con dos proyectos de consumidor, realiza una solicitud de la siguiente manera:

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

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
  },
  "specificReservationRequired": true
}

Para permitir que una reserva de VMs con GPU sea consumida por trabajos de entrenamiento personalizados o por trabajos de predicción en Vertex AI, realiza una solicitud POST al método beta.reservations.insert. En el cuerpo de la solicitud, incluye el campo serviceShareType y configúralo como ALLOW_ALL.

Vista previa — The reservationSharingPolicy field

Esta función está sujeta a las "Condiciones de las Ofertas de Fase Previa a la DG" de la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Las funciones de fase previa a la DG están disponibles “tal cual” y podrían tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "reservationSharingPolicy": {
    "serviceShareType": "ALLOW_ALL"
  },
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
  }
}
```
Para permitir que Compute Engine borre automáticamente la reserva, selecciona uno de los siguientes métodos:

Vista previa — The deleteAtTime and deleteAfterDuration fields

Esta función está sujeta a las "Condiciones de las Ofertas de Fase Previa a la DG" de la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Las funciones de fase previa a la DG están disponibles “tal cual” y podrían tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.
- Para borrar la reserva en una fecha y hora específicas, haz una solicitud POST al método beta.reservations.insert. En el cuerpo de la solicitud, incluye el campo deleteAtTime.
  
  Por ejemplo, para crear una reserva mediante la especificación de una plantilla de instancias, borrarla automáticamente en una fecha y hora específicas, y compartirla con dos proyectos de consumidor, realiza una solicitud de la siguiente manera:
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAtTime": "DELETE_AT_TIME",
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
  }
}
```
  Reemplaza DELETE_AT_TIME por una fecha y hora con formato de marca de tiempo RFC 3339, que debe ser de la siguiente manera:
```
YYYY-MM-DDTHH:MM:SSOFFSET
```
  Reemplaza lo siguiente:
  - YYYY-MM-DD: una fecha con formato de un año de 4 dígitos, un mes de 2 dígitos y un día de 2 dígitos del mes separado por guiones (-).
  - HH:MM:SS: una hora con formato de hora de 2 dígitos con un formato de 24 horas, minutos de 2 dígitos y segundos de 2 dígitos separados por dos puntos (:).
  - OFFSET: la zona horaria con formato como una compensación del horario universal coordinado (UTC). Por ejemplo, para usar la hora estándar del Pacífico (PST), especifica -08:00. Como alternativa, para no usar compensación, especifica Z.
- Para borrar la reserva después de una duración específica, haz una solicitud POST al método beta.reservations.insert. En el cuerpo de la solicitud, incluye el campo deleteAfterDuration.
  
  Por ejemplo, para crear una reserva mediante la especificación de una plantilla de instancias, borrarla automáticamente después de una duración específica y compartirla con dos proyectos de consumidor, realiza una solicitud de la siguiente manera:
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAfterDuration": {
    "seconds": "DELETE_AFTER_DURATION"
  },
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
  }
}
```
  Reemplaza DELETE_AFTER_DURATION por una duración en segundos. Por ejemplo, especifica 86400 para 86,400 segundos (1 día).

Especifica una VM existente

Solo puedes crear una reserva compartida basada en una VM existente en el mismo proyecto y zona que la VM.

Después de crear la reserva, puedes consumirla si creas VMs con propiedades que coincidan con la VM de referencia. Para ello, puedes optar por cualquiera de las siguientes opciones:

Crea y usa una plantilla de instancias de la siguiente manera:
1. Crea una plantilla de instancias basada en la VM de referencia sin anular las propiedades de la VM de referencia.
  
  Nota: No puedes crear una plantilla de instancias basada en la VM de referencia fuera del proyecto de la VM. Para los proyectos con los que se comparte la reserva, debes crear plantillas de instancias similares en esos proyectos.
2. Para crear VMs con la plantilla recién creada, haz una de las siguientes acciones o ambas:
  - Crea una sola VM
  - Crea un grupo de instancias administrado zonal (MIG).
Crea una VM con propiedades que coincidan exactamente con la VM de referencia de la siguiente manera:
- En el proyecto del propietario, crea una VM basada en la VM de referencia sin cambiar las propiedades de la VM que estás creando.
- En los proyectos de consumidor, crea una VM y asegúrate de que sus propiedades y las de la VM de referencia coincidan de forma manual.

Para crear una reserva compartida que use las propiedades de una VM existente, haz lo siguiente:

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

Ir a Reservas
En la pestaña Reservas según demanda (predeterminada), haz clic en Crear reserva.

Se abrirá la página Crear una reserva.
En Nombre, ingresa un nombre para tu reserva.
En Región y Zona, selecciona dónde deseas reservar los recursos.
En la sección Tipo de fuente, haz lo siguiente:
1. Para especificar una reserva compartida, selecciona Compartido.
2. Haz clic en Agregar proyectos y elige los proyectos de la organización actual del proyecto con el que quieres compartir la reserva. Puedes seleccionar hasta 100 proyectos de consumidor.
En la sección Usar con instancia de VM, selecciona una de las siguientes opciones:
- Para permitir que las VMs coincidentes consuman de forma automática esta reserva, selecciona Usar reserva de forma automática si aún no está seleccionada.
- Para consumir los recursos de esta reserva solo cuando creas VMs coincidentes que se dirigen de forma específica a esta reserva por nombre, elige Seleccionar reserva específica.
  
  Nota: Si la VM de referencia especifica un tipo de máquina A3, debes seleccionar Seleccionar reserva específica. De lo contrario, no podrás borrar la reserva.
En Cantidad de instancias de VM, ingresa la cantidad de VMs que deseas reservar.
En la sección Configuración de la máquina, haz lo siguiente:
1. Selecciona Usar VM existente.
2. En VM existente, selecciona la VM cuyas propiedades deseas usar para crear la reserva.
En la sección Eliminación automática, puedes habilitar la opción de eliminación automática para permitir que Compute Engine borre la reserva en una fecha y hora específicas de forma automática. La eliminación automática de reservas puede ser útil para evitar cargos innecesarios cuando dejas de consumir 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.

Especifica las propiedades directamente

Para crear una reserva compartida a través de la especificación directa de las propiedades, 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), haz clic en Crear reserva.
Haz clic en Crear reserva.

Aparecerá la página Crear una reserva.
En Nombre, ingresa un nombre para tu reserva.
En Región y Zona, selecciona dónde deseas reservar los recursos.
En la sección Tipo de fuente, haz lo siguiente:
1. Para especificar una reserva compartida, selecciona Compartido.
2. Haz clic en Agregar proyectos y elige los proyectos de la organización actual del proyecto con el que quieres compartir la reserva. Puedes seleccionar hasta 100 proyectos de consumidor.
Opcional: Para permitir que una reserva de VMs con GPU sea consumida por trabajos de entrenamiento personalizados o trabajos de predicción en Vertex AI, en la sección Servicios de Google Cloud, selecciona Compartir reserva.
En la sección Usar con instancia de VM, selecciona una de las siguientes opciones:
- Para permitir que las VMs coincidentes consuman de forma automática esta reserva, elige Usar reserva de forma automática (predeterminado).
- Para consumir los recursos de esta reserva solo cuando creas VMs coincidentes que se dirigen de forma específica a esta reserva por nombre, elige Seleccionar reserva específica.
  
  Nota: Si deseas especificar un tipo de máquina A3 en la reserva, debes elegir Seleccionar reserva específica. De lo contrario, tendrás errores.
En Cantidad de instancias de VM, ingresa la cantidad de VMs que deseas reservar.
En la sección Configuración de máquina, selecciona Especificar tipo de máquina y, luego, especifica lo siguiente:
1. En Familia de máquinas, Serie y Tipo de máquina, selecciona una familia de máquinas, una serie y un tipo de máquina.
2. Opcional: Para especificar una plataforma de CPU mínima o conectar GPUs a las VMs N1, haz lo siguiente:
  1. Para expandir la sección Plataforma de CPU y GPU, haz clic en la flecha de expansión .
  2. Opcional: Para especificar una plataforma de CPU mínima, selecciona una opción en Formulario de CPU.
  3. Opcional: Para conectar GPUs a las VMs N1, haz clic en Agregar GPU. Luego, en Tipo de GPU y Cantidad de GPU, selecciona el tipo y la cantidad de GPUs que se adjuntarán a cada VM N1.
3. Opcional: Para agregar discos SSD locales, haz lo siguiente:
  1. En Cantidad de discos, selecciona la cantidad de discos SSD locales para cada VM.
  2. En Tipo de interfaz, selecciona la interfaz para los discos SSD locales.
En la sección Eliminación automática, puedes habilitar la opción de eliminación automática para permitir que Compute Engine borre la reserva en una fecha y hora específicas de forma automática. La eliminación automática de reservas puede ser útil para evitar cargos innecesarios cuando dejas de consumir la reserva.
Para crear la reserva, haz clic en Crear.

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

gcloud

Para crear una reserva compartida, usa el comando gcloud compute reservations create con las marcas --share-setting=projects y --share-with.

Para crear una reserva compartida con la especificación directa de las propiedades y sin incluir marcas opcionales, ejecuta el siguiente comando:

gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

Reemplaza lo siguiente:

RESERVATION_NAME: Es el nombre de la reserva que se creará.
MACHINE_TYPE: Un tipo de máquina que se usará para cada VM. Si especificas un tipo de máquina A3, debes incluir la marca --require-specific-reservation. Esto indica que solo las VMs que se dirigen a esta reserva de forma específica pueden consumirla. Para obtener más información, consulta Consume las VMs de una reserva específica.
CONSUMER_PROJECT_IDS: una lista separada por comas de IDs de proyectos que pueden consumir esta reserva, por ejemplo project-1,project-2. Puedes incluir hasta 100 proyectos de consumidor. Estos proyectos deben estar en la misma organización que el proyecto de propietario. No incluyas el proyecto de propietario. De forma predeterminada, ya está permitido consumir esta reserva.
NUMBER_OF_VMS: La cantidad de VMs que se reservarán.
ZONE: Es 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, cada una con un tipo predefinido de máquina N2 con 4 CPU virtuales y compartir la reserva con los proyectos project-1 y project-2, haz lo siguiente: ejecuta el siguiente comando:

gcloud compute reservations create my-reservation \
    --machine-type=n2-standard-4 \
    --share-setting=projects \
    --share-with=project-1,project-2 \
    --vm-count=10 \
    --zone=us-central1-a

De manera opcional, puedes hacer una o más de las siguientes acciones:

Para adjuntar 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 \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
Reemplaza lo siguiente:
- NUMBER_OF_ACCELERATORS: Es la cantidad de GPU que se agregará por VM reservada.
- ACCELERATOR_TYPE: Un modelo de GPU compatible para las VMs N1. Asegúrate de que el modelo de GPU que elegiste esté disponible en la zona en la que deseas reservar los recursos. De lo contrario, la creación de la reserva fallará.
Para agregar uno o más discos SSD locales a cada VM reservada, incluye una o más marcas --local-ssd. Puedes especificar hasta 24 discos SSD locales. Cada disco SSD local es de 375 GB.

Por ejemplo, para especificar dos discos SSD locales cuando creas una reserva compartida, incluye dos marcas --local-ssd de la siguiente manera:
```
gcloud compute reservations create RESERVATION_NAME \
    --local-ssd=size=375,interface=INTERFACE_1 \
    --local-ssd=size=375,interface=INTERFACE_2 \
    --machine-type=MACHINE_TYPE \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
Reemplaza INTERFACE_1 y INTERFACE_2 por el tipo de interfaz que deseas que use cada disco SSD local. Especifica uno de los siguientes valores:
- Interfaces de disco NVMe: nvme
- Interfaces de disco SCSI: scsi
Asegúrate de que el tipo de máquina que especifiques para las VMs reservadas admita las interfaces de disco elegidas. De lo contrario, la creación de la reserva fallará. Para obtener más información, consulta cómo elegir una interfaz de disco.
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" \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
Reemplaza 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 reservas recursos, consulta las plataformas de CPU disponibles por zona.

Para especificar que solo las VMs que se dirigen a esta reserva de forma específica pueden consumirla, incluye la marca --require-specific-reservation.

gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --require-specific-reservation \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

Para permitir que una reserva de VMs de GPU sea consumida por trabajos de entrenamiento personalizados o por trabajos de predicción en Vertex AI, usa el comando gcloud beta compute reservations create con la marca --reservation-sharing-policy=ALLOW_ALL.

Vista previa — The --reservation-sharing-policy flag

Esta función está sujeta a las "Condiciones de las Ofertas de Fase Previa a la DG" de la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Las funciones de fase previa a la DG están disponibles “tal cual” y podrían tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.
```
gcloud beta compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --reservation-sharing-policy=ALLOW_ALL \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
Para permitir que Compute Engine borre automáticamente la reserva, selecciona uno de los siguientes métodos:

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

Esta función está sujeta a las "Condiciones de las Ofertas de Fase Previa a la DG" de la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Las funciones de fase previa a la DG están disponibles “tal cual” y podrían tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.
- Para borrar la reserva en una fecha y hora específicas, 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 \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
  Reemplaza DELETE_AT_TIME por una fecha y hora con formato de marca de tiempo RFC 3339, que debe ser de la siguiente manera:
```
YYYY-MM-DDTHH:MM:SSOFFSET
```
  Reemplaza lo siguiente:
  - YYYY-MM-DD: una fecha con formato de un año de 4 dígitos, un mes de 2 dígitos y un día de 2 dígitos del mes separado por guiones (-).
  - HH:MM:SS: una hora con formato de hora de 2 dígitos con un formato de 24 horas, minutos de 2 dígitos y segundos de 2 dígitos separados por dos puntos (:).
  - OFFSET: la zona horaria con formato como una compensación del horario universal coordinado (UTC). Por ejemplo, para usar la hora estándar del Pacífico (PST), especifica -08:00. Como alternativa, para no usar compensación, especifica Z.
- Para borrar la reserva después de una duración específica, 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 \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
  Reemplaza 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.

Terraform

Para crear una reserva, usa el recurso google_compute_reservation de Terraform. Para especificar una reserva compartida, define el bloque share_settings:

Configura el campo share_type como SPECIFIC_PROJECTS.
En el bloque project_map, especifica los ID del proyecto de los proyectos con los que deseas compartir esta reserva.

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

REST

Para crear una reserva compartida, realiza una solicitud POST al método reservations.insert. En el cuerpo de la solicitud, incluye lo siguiente:

El campo projectMap
El campo shareType configurado como SPECIFIC_PROJECTS.

Por ejemplo, para crear una reserva compartida sin ningún campo opcional y compartirla con dos proyectos de consumidor, haz la siguiente solicitud POST:

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

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}

Reemplaza lo siguiente:

PROJECT_ID: el ID del proyecto en el que deseas reservar los recursos.
ZONE: Es la zona en la que se reservarán los recursos.
RESERVATION_NAME: Es el nombre de la reserva que se creará.
CONSUMER_PROJECT_ID_1 y CONSUMER_PROJECT_ID_2: los IDs de los proyectos que pueden consumir esta reserva. Puedes incluir hasta 100 proyectos de consumidor. Estos proyectos deben estar en la misma organización que el proyecto de propietario. No incluyas el proyecto de propietario. De forma predeterminada, ya está permitido consumir la reserva.
NUMBER_OF_VMS: La cantidad de VMs que se reservarán.
MACHINE_TYPE: Un tipo de máquina que se usará para cada VM. Si especificas un tipo de máquina A3, debes incluir el campo specificReservationRequired en el cuerpo de la solicitud y configurar el campo como true. Esto indica que solo las VMs que se dirigen a esta reserva de forma específica pueden consumirla.

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

{
  "name": "my-reservation",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "project-1": {
        "projectId": "project-1"
      },
      "project-2": {
        "projectId": "project-2"
      }
    }
  },
  "specificReservation": {
    "count": "10",
    "instanceProperties": {
      "machineType": "n2-standard-4",
    }
  }
}

De manera opcional, puedes hacer una o más de las siguientes acciones:

Para conectar las GPUs a tus VM N1 reservadas, incluye el campo guestAccelerators en el cuerpo de la solicitud.

Por ejemplo, para crear una reserva compartida con dos proyectos de consumidor y conectar GPUs a cualquier VMs N1 reservada, realiza una solicitud de la siguiente manera:

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

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "guestAccelerators": [
        {
          "acceleratorCount": NUMBER_OF_ACCELERATORS,
          "acceleratorType": "ACCELERATOR_TYPE"
        }
      ],
      "machineType": "MACHINE_TYPE"
    }
  }
}

Reemplaza lo siguiente:

NUMBER_OF_ACCELERATORS: Es la cantidad de GPU que se agregará por VM reservada.
ACCELERATOR_TYPE: Un modelo de GPU compatible para las VMs N1. Asegúrate de que el modelo de GPU que elegiste esté disponible en la zona en la que deseas reservar los recursos. De lo contrario, la creación de la reserva fallará.

Para agregar uno o más discos SSDs locales a cada VM reservada, incluye el campo localSsds en el cuerpo de la solicitud. Puedes especificar hasta 24 discos SSD locales. Cada disco SSD local es de 375 GB.

Por ejemplo, para crear una reserva compartida y especificar dos discos SSD locales y dos proyectos de consumidor, realiza una solicitud de la siguiente manera:

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

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "localSsds": [
        {
          "diskSizeGb": "375",
          "interface": "INTERFACE_1"
        },
        {
          "diskSizeGb": "375",
          "interface": "INTERFACE_2"
        }
      ],
      "machineType": "MACHINE_TYPE"
    }
  }
}

Reemplaza INTERFACE_1 y INTERFACE_2 por el tipo de interfaz que deseas que use cada disco SSD local. Especifica uno de los siguientes valores:

Interfaces de disco NVMe: NVME
Interfaces de disco SCSI: SCSI

Asegúrate de que el tipo de máquina que especifiques para las VMs reservadas admita las interfaces de disco elegidas. De lo contrario, la creación de la reserva fallará. Para obtener más información, consulta cómo elegir una interfaz de disco.

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 el campo minCpuPlatform en el cuerpo de la solicitud.

Por ejemplo, para crear una reserva compartida y especificar una plataforma de CPU mínima y dos proyectos de consumidor, realiza una solicitud de la siguiente manera:

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

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE",
      "minCpuPlatform": "MIN_CPU_PLATFORM"
    }
  }
}

Reemplaza 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 reservas recursos, consulta las plataformas de CPU disponibles por zona.

Por ejemplo, para crear una reserva específica y compartirla con dos proyectos de consumidor, realiza una solicitud de la siguiente manera:

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

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  },
  "specificReservationRequired": true
}

Para permitir que una reserva de VMs con GPU sea consumida por trabajos de entrenamiento personalizados o por trabajos de predicción en Vertex AI, realiza una solicitud POST al método beta.reservations.insert. En el cuerpo de la solicitud, incluye el campo serviceShareType y configúralo como ALLOW_ALL.

Vista previa — The reservationSharingPolicy field

Esta función está sujeta a las "Condiciones de las Ofertas de Fase Previa a la DG" de la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Las funciones de fase previa a la DG están disponibles “tal cual” y podrían tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "reservationSharingPolicy": {
    "serviceShareType": "ALLOW_ALL"
  },
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}
```
Para permitir que Compute Engine borre automáticamente la reserva, selecciona uno de los siguientes métodos:

Vista previa — The deleteAtTime and deleteAfterDuration fields

Esta función está sujeta a las "Condiciones de las Ofertas de Fase Previa a la DG" de la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Las funciones de fase previa a la DG están disponibles “tal cual” y podrían tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.
- Para borrar la reserva en una fecha y hora específicas, haz una solicitud POST al método beta.reservations.insert. En el cuerpo de la solicitud, incluye el campo deleteAtTime.
  
  Por ejemplo, para crear una reserva y especificar una fecha y una hora para borrarla, y compartirla con dos proyectos de consumidor, realiza una solicitud de la siguiente manera:
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAtTime": "DELETE_AT_TIME",
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}
```
  Reemplaza DELETE_AT_TIME por una fecha y hora con formato de marca de tiempo RFC 3339, que debe ser de la siguiente manera:
```
YYYY-MM-DDTHH:MM:SSOFFSET
```
  Reemplaza lo siguiente:
  - YYYY-MM-DD: una fecha con formato de un año de 4 dígitos, un mes de 2 dígitos y un día de 2 dígitos del mes separado por guiones (-).
  - HH:MM:SS: una hora con formato de hora de 2 dígitos con un formato de 24 horas, minutos de 2 dígitos y segundos de 2 dígitos separados por dos puntos (:).
  - OFFSET: la zona horaria con formato como una compensación del horario universal coordinado (UTC). Por ejemplo, para usar la hora estándar del Pacífico (PST), especifica -08:00. Como alternativa, para no usar compensación, especifica Z.
- Para borrar la reserva después de una duración específica, haz una solicitud POST al método beta.reservations.insert. En el cuerpo de la solicitud, incluye el campo deleteAfterDuration.
  
  Por ejemplo, para crear una reserva que Compute Engine borrará después de una duración específica y compartirla con dos proyectos de consumidor, realiza una solicitud de la siguiente manera:
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAfterDuration": {
    "seconds": "DELETE_AFTER_DURATION"
  },
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}
```
  Reemplaza DELETE_AFTER_DURATION por una duración en segundos. Por ejemplo, especifica 86400 para 86,400 segundos (1 día).

Soluciona problemas

Obtén más información sobre cómo solucionar problemas de creación de reservas.

¿Qué sigue?

Obtén información sobre cómo ver tus reservas.
Obtén más información para adjuntar reservas a los compromisos.
Obtén información sobre cómo consumir reservas.
Obtén más información sobre cómo supervisar el consumo de reservas.