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

Crear una reserva compartida

En este documento se explica cómo crear reservas compartidas, que son reservas que se comparten entre varios proyectos, y cómo gestionar qué proyectos de tu organización pueden usar las reservas compartidas.

La reserva compartida puede usarla el proyecto que la aloja (proyecto propietario) y los proyectos con los que se comparte (proyectos de consumidor). Usa reservas compartidas si tu organización tiene varios proyectos que necesitan instancias de máquina virtual (VM) con las mismas propiedades reservadas. Si usas reservas compartidas, puedes mejorar la utilización de tus reservas y reducir el número de reservas que tienes que crear y gestionar. Para obtener más información sobre las reservas, consulta Reservas 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 solo pueda usar un proyecto, consulta Crear una reserva para un solo proyecto.
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.
Consulte los requisitos de cuota y las restricciones de las reservas compartidas.
Asegúrate de que el administrador de políticas de la organización haya añadido el proyecto que usas para crear reservas compartidas a la lista de permitidos de la restricción de la política de la organización Proyectos propietarios de reservas compartidas (compute.sharedReservationsOwnerProjects). Esta lista de permitidos está vacía de forma predeterminada, por lo que no puedes crear reservas compartidas hasta que tu organización conceda este permiso a uno o varios proyectos. Para obtener más información sobre cómo ver y editar la restricción de la política de organización, consulta el artículo Permitir y restringir que los proyectos creen y modifiquen reservas compartidas de este documento.
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.
Go

Para usar las Go muestras 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.
Java

Para usar las Java muestras 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.
Node.js

Para usar las Node.js muestras 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.
Python

Para usar las Python muestras 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 compartidas, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos:

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

Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

Estos roles predefinidos contienen los permisos necesarios para crear reservas compartidas. Para ver los permisos exactos que se necesitan, despliega la sección Permisos necesarios:

Permisos obligatorios

Para crear reservas compartidas, se necesitan los siguientes permisos:

compute.reservations.create del proyecto
Para ver las políticas de organización, sigue estos pasos: orgpolicy.policy.get en la organización
Para editar las políticas de organización, sigue estos pasos: orgpolicy.policy.set en la organización
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.

Prácticas recomendadas

Cuando crees reservas compartidas, te recomendamos que sigas estas prácticas recomendadas. Si los sigues, podrás optimizar la gestión y el uso de las reservas compartidas de tu organización.

El proyecto propietario debe crear la reserva compartida, pero no consumirla.
- Para repartir los gastos entre los proyectos, se recomienda que solo los proyectos de consumidor utilicen una reserva compartida. El proyecto propietario solo se debe usar para crear la reserva compartida.
- Al crear una reserva compartida, el proyecto propietario debe tener suficiente cuota para el total de los recursos que se van a reservar. Después de crear la reserva, el proyecto propietario debe tener cuota para los recursos reservados que quiera consumir. Para obtener más información, consulta los requisitos de cuota adicionales para las reservas compartidas.
Minimiza el número de proyectos de tu organización a los que permites crear reservas compartidas. Puedes controlar este comportamiento mediante la restricción de la política de organización Shared Reservations Owner Projects (compute.sharedReservationsOwnerProjects).
- Solo puedes mostrar las reservas creadas por cada proyecto. Esto significa que las reservas compartidas solo se muestran en el proyecto propietario. No puedes ver las reservas compartidas con cada proyecto ni todas las reservas compartidas de cada organización. Por lo tanto, si solo tienes unos pocos proyectos propietarios, te resultará más fácil monitorizar y gestionar tus reservas compartidas.
- Limita el uso compartido de una reserva compartida a unos pocos proyectos para gestionar más fácilmente la cuota de los recursos reservados.
- Para obtener más información, consulta Permitir y restringir que los proyectos creen y modifiquen reservas compartidas.
Minimiza el número de reservas compartidas independientes con propiedades de máquina virtual idénticas.
- Una organización puede tener hasta 100 reservas compartidas por cada combinación única de propiedades de máquina virtual. Por lo tanto, minimizar el número de reservas compartidas que crees con propiedades de VM idénticas te ayudará a mitigar este límite.
- Si hay menos reservas compartidas, será más fácil gestionarlas.
Solo se pueden compartir reservas entre proyectos que tengan 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 propietario. De este modo, te resultará más fácil ver si se ha utilizado una reserva y cómo se ha facturado.
  Precaución: Si tienes una reserva compartida y también tienes UCD compartida habilitada en la cuenta de facturación de Cloud de tu compromiso, Google te recomienda que compartas tu reserva solo con los proyectos vinculados a la cuenta de facturación de Cloud del compromiso. De lo contrario, cuando los proyectos ajenos a la cuenta de facturación de Cloud consuman esa reserva compartida, su uso no será apto para los descuentos por uso continuado basados en recursos compartidos de esta cuenta de facturación de Cloud y se les aplicarán las tarifas bajo demanda.
En las próximas solicitudes de reserva, revisa detenidamente el número total de máquinas virtuales que solicites.
- Si vas a crear una solicitud de reserva futura, asegúrate de solicitar un número total de VMs que tenga en cuenta lo siguiente:
  - Todas las VMs reservadas coincidentes que ya existan en la fecha futura.
  - Todas las VMs no reservadas que coincidan y que ya existan en la fecha futura.
  - Las reservas bajo demanda no utilizadas que ya existan en la fecha futura.
  - El aumento del uso que quieres reservar para la fecha futura.
  Por ejemplo, supongamos que necesitas 10 máquinas virtuales adicionales en una fecha futura y que ya tendrás los siguientes recursos en esa fecha:
  - 40 máquinas virtuales reservadas coincidentes
  - 50 VMs no reservadas coincidentes
  o
  - 40 máquinas virtuales reservadas coincidentes
  - 50 reservas bajo demanda no utilizadas coincidentes
  Como el uso que tienes en la fecha futura ya suma 90 VMs y reservas coincidentes, y necesitas 10 VMs más, debes especificar un total de 100 en tu solicitud de reserva futura.
  
  Nota: Si creas reservas bajo demanda adicionales después de enviar la solicitud de reserva futura y antes de la fecha futura, se contarán en el total.
  
  Si después de la fecha futura añades más reservas bajo demanda, se añadirán al total anterior. Por ejemplo, si después de la fecha futura reservas otras diez VMs, tendrás 110 reservas.
  
  Para obtener más información, consulta Contar y aprovisionar recursos reservados.

Permitir y restringir que los proyectos creen y modifiquen reservas compartidas

De forma predeterminada, ningún proyecto puede crear ni modificar reservas compartidas en una organización. Añade proyectos a la restricción de la política de organización Proyectos propietarios de reservas compartidas (compute.sharedReservationsOwnerProjects) para permitirles crear y modificar reservas compartidas. Para obtener más información sobre las restricciones de las políticas de la organización, consulta la introducción al servicio de políticas de la organización.

Sigue estos pasos para ver y editar la restricción de política de organización Shared Reservations Owner Projects (compute.sharedReservationsOwnerProjects).

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

Para ver qué proyectos tienen permiso para crear y modificar reservas compartidas, usa la Google Cloud consola o la interfaz de línea de comandos de gcloud.

Consola

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

gcloud

Para ver qué proyectos permite crear y modificar reservas compartidas la restricción compute.sharedReservationsOwnerProjects:

Descarga la política de tu organización como un archivo llamado policy.yaml con el comando gcloud resource-manager org-policies describe:
```
gcloud resource-manager org-policies describe compute.sharedReservationsOwnerProjects --organization=ORGANIZATION_ID > policy.yaml
```
Sustituye 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 pueden crear y modificar reservas compartidas se indican en su allowedValues:
```
...
constraint: constraints/compute.sharedReservationsOwnerProjects
listPolicy:
  allowedValues:
  - projects/PROJECT_NUMBER_1
  - projects/PROJECT_NUMBER_2
  - projects/PROJECT_NUMBER_3
...
```
donde 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 pueden crear reservas compartidas.
Opcional: Elimina el archivo policy.yaml.
- Si usas un terminal Linux o macOS, usa el siguiente comando:
```
rm policy.yaml
```
- Si usas un terminal de Windows, usa el siguiente comando:
```
del policy.yaml
```

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

Para editar los proyectos que pueden crear y modificar reservas compartidas, usa la Google Cloud consola o la interfaz de línea de comandos de gcloud.

Consola

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

gcloud

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

Para conceder permiso a un solo proyecto para crear y modificar reservas compartidas, usa el comando gcloud resource-manager org-policies allow. Puedes repetir este comando con cada proyecto al que quieras conceder este permiso.
```
gcloud resource-manager org-policies allow compute.sharedReservationsOwnerProjects projects/PROJECT_NUMBER \
    --organization=ORGANIZATION_ID
```
Haz los cambios siguientes:
- PROJECT_NUMBER: el número de proyecto (no el ID del proyecto) de un proyecto de tu organización al que quieras permitirle crear y modificar reservas compartidas.
- ORGANIZATION_ID: el ID de organización de tu organización.
Para conceder o revocar los permisos de varios proyectos para crear y modificar reservas compartidas, sustituye la restricción de la política de la organización:
1. Para descargar la política de 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
```
  Sustituye ORGANIZATION_ID por el ID de organización de tu organización.
2. Utilice un editor de texto para modificar el archivo policy.yaml de forma que la restricción compute.sharedReservationsOwnerProjects incluya todos los proyectos que quiera que puedan crear y modificar reservas compartidas en su allowedValues.
  - Por cada proyecto al que quieras conceder el permiso para crear y modificar reservas compartidas, añade el proyecto en una línea nueva debajo de allowedValues.
  - En cada proyecto en el que quieras revocar el permiso para crear y modificar reservas compartidas, elimina la línea correspondiente.
  Cuando hayas terminado, comprueba que el archivo policy.yaml tenga un aspecto similar al siguiente:
```
...
constraint: constraints/compute.sharedReservationsOwnerProjects
listPolicy:
  allowedValues:
  - projects/PROJECT_NUMBER_1
  - projects/PROJECT_NUMBER_2
  - projects/PROJECT_NUMBER_3
...
```
  donde PROJECT_NUMBER_1, PROJECT_NUMBER_2 y PROJECT_NUMBER_3 son los números de proyecto (no los IDs de proyecto) de todos los proyectos de tu organización que quieras que puedan crear y modificar reservas compartidas.
3. Guarda el archivo policy.yaml y cierra el editor de texto.
4. Para actualizar la política de 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
```
  Sustituye ORGANIZATION_ID por el ID de organización de tu organización.
5. Opcional: Elimina el archivo policy.yaml.
  - Si usas un terminal Linux o macOS, usa el siguiente comando:
```
rm policy.yaml
```
  - Si usas un terminal de Windows, usa el siguiente comando:
```
del policy.yaml
```

Es posible que tengas que esperar unos minutos para que se aplique el cambio.

Crear una reserva compartida

En esta sección se explica cómo crear reservas compartidas. Una vez que hayas creado una reserva compartida, solo podrá modificarla el proyecto propietario, pero los recursos de una reserva compartida podrán usarse en el proyecto propietario o en cualquier proyecto consumidor.

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 compartida. Si usas una plantilla de instancia, puedes definir las propiedades de una reserva y las VMs que pueden usarla en el mismo lugar. Sin embargo, como las plantillas son específicas de cada proyecto, no puedes usar la misma plantilla para crear VMs que puedan consumir la reserva fuera del proyecto que la creó. En los proyectos con los que se comparte la reserva, debes crear plantillas similares o crear VMs especificando las propiedades directamente.
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 compartida. Con este método, debes asegurarte manualmente de que las propiedades de tus VMs y reservas coincidan exactamente, ya que 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 las reservas, haz una o varias de las siguientes acciones:

Crea una reserva que solo puedan usar las VMs que la tengan como destino 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.

Especificar una plantilla de instancia

Antes de crear una reserva especificando una plantilla de instancia, asegúrate de lo siguiente:

Una plantilla de instancia contiene ajustes específicos del proyecto, por lo que solo puedes acceder a ella y usarla en el mismo proyecto. Si creas una reserva compartida especificando una plantilla de instancia, no podrás usar la misma plantilla para crear VMs que puedan consumir la reserva fuera del proyecto que la creó.
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.

Para crear una reserva compartida 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

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

Aparecerá 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, haz lo siguiente:
1. Para especificar una reserva compartida, selecciona Compartida.
2. Haz clic en Añadir proyectos y, a continuación, selecciona los proyectos de la organización del proyecto actual con los que quieras compartir la reserva. Puedes seleccionar hasta 100 proyectos de consumidor.
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 instancias de VM coincidentes usen 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, 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 Usar plantilla de instancia y, a continuación, elige la plantilla de instancia que quieras. Si seleccionas una plantilla de instancia regional, solo podrás reservar recursos en la misma región que la plantilla.
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 compartida puede tardar hasta un minuto.

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 especificando una plantilla de instancia y sin incluir ninguna marca opcional, 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

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.
CONSUMER_PROJECT_IDS: una lista separada por comas de IDs de proyectos que pueden usar esta reserva. Por ejemplo, project-1,project-2. Puedes incluir hasta 100 proyectos de consumidor. Estos proyectos deben pertenecer a la misma organización que el proyecto propietario. No incluyas el proyecto propietario. De forma predeterminada, ya se permite consumir la reserva.
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, debe 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 especificando una plantilla de instancia 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 de máquina predefinido N2 con 4 vCPUs, 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

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 \
    --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 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 \
    --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 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 \
    --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
```
  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 \
    --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
```
  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"

	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.InsertReservationRequest;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
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 {

  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 to reserve resources.
    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/%s", projectId, "YOUR_INSTANCE_TEMPLATE_NAME");
    // Number of instances for which capacity needs to be reserved.
    int vmCount = 3;

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

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

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (ReservationsClient reservationsClient = ReservationsClient.create()) {
      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_1", ShareSettingsProjectConfig.newBuilder().build())
              .putProjectMap("CONSUMER_PROJECT_2", ShareSettingsProjectConfig.newBuilder().build())
              .build();

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

      InsertReservationRequest request =
              InsertReservationRequest.newBuilder()
                      .setProject(projectId)
                      .setZone(zone)
                      .setReservationResource(reservationResource)
                      .build();

      Operation response = reservationsClient.insertAsync(request)
              .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        throw new Error("Reservation creation failed!!" + response);
      }
      return 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, envía una solicitud POST al método reservations.insert. En el cuerpo de la solicitud, incluye lo siguiente:

El campo projectMap.
El campo shareType se ha definido como SPECIFIC_PROJECTS.

Por ejemplo, para crear una reserva compartida especificando una plantilla de instancia sin incluir ningún campo opcional 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"
  }
}

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.
CONSUMER_PROJECT_ID_1 y CONSUMER_PROJECT_ID_2: los IDs de los proyectos que pueden usar esta reserva. Puedes incluir hasta 100 proyectos de consumidor. Estos proyectos deben pertenecer a la misma organización que el proyecto propietario. No incluyas el proyecto propietario. De forma predeterminada, ya se permite consumir la reserva.
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, 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 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"
  }
}

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.

Por ejemplo, para crear una reserva específica indicando una plantilla de instancia y compartirla con dos proyectos de consumidor, haz una solicitud como la siguiente:

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 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"
  },
  "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 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.
  
  Por ejemplo, para crear una reserva especificando una plantilla de instancia, eliminar automáticamente la reserva en una fecha y hora concretas, y compartir la reserva con dos proyectos de consumidor, haz una solicitud como la siguiente:
```
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"
  }
}
```
  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.
  
  Por ejemplo, para crear una reserva especificando una plantilla de instancia, eliminar automáticamente la reserva después de un periodo concreto y compartir la reserva con dos proyectos de consumidor, haz una solicitud como la siguiente:
```
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"
  }
}
```
  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 compartida basada en una VM que ya exista en el mismo proyecto y 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.
  
  Nota: No puedes crear una plantilla de instancia basada en la VM de referencia fuera del proyecto de la VM. En los proyectos con los que se comparte la reserva, debe crear plantillas de instancia similares.
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 con propiedades que coincidan exactamente con la VM de referencia de la siguiente manera:
- En el proyecto 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 manualmente de que sus propiedades coincidan con las de la VM de referencia.

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

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, haz lo siguiente:
1. Para especificar una reserva compartida, selecciona Compartida.
2. Haz clic en Añadir proyectos y, a continuación, selecciona los proyectos de la organización del proyecto actual con los que quieras compartir la reserva. Puedes seleccionar hasta 100 proyectos de consumidor.
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 la VM de referencia especifica un tipo de máquina A3 mega, A3 high o A3 edge, debes seleccionar Seleccionar reserva específica. De lo contrario, no podrás crear la reserva.
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.
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 compartida 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.
Haz clic en Crear reserva.

Aparecerá 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, haz lo siguiente:
1. Para especificar una reserva compartida, selecciona Compartida.
2. Haz clic en Añadir proyectos y, a continuación, selecciona los proyectos de la organización del proyecto actual con los que quieras compartir la reserva. Puedes seleccionar hasta 100 proyectos de consumidor.
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 usen esta reserva automáticamente, selecciona Usar reserva automáticamente (opción predeterminada).
- 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 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.
3. 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.
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 compartida puede tardar hasta un minuto.

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 especificando las propiedades directamente y sin incluir ninguna marca opcional, 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

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.
CONSUMER_PROJECT_IDS: una lista separada por comas de IDs de proyectos que pueden usar esta reserva. Por ejemplo, project-1,project-2. Puedes incluir hasta 100 proyectos de consumidor. Estos proyectos deben pertenecer a la misma organización que el proyecto propietario. No incluyas el proyecto propietario. De forma predeterminada, ya se permite consumir la reserva.
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 cada una y compartir la reserva con los proyectos project-1 y project-2, 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

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 \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --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" \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --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 \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

gcloud 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 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 \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --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 \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --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.

Terraform

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

Asigna el valor SPECIFIC_PROJECTS al campo share_type.
En el bloque project_map, especifica los IDs de proyecto de los proyectos con los que quieras compartir esta reserva.

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

REST

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

El campo projectMap.
El campo shareType se ha definido como SPECIFIC_PROJECTS.

Por ejemplo, para crear una reserva compartida sin incluir 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"
    }
  }
}

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.
CONSUMER_PROJECT_ID_1 y CONSUMER_PROJECT_ID_2: los IDs de los proyectos que pueden usar esta reserva. Puedes incluir hasta 100 proyectos de consumidor. Estos proyectos deben pertenecer a la misma organización que el proyecto propietario. No incluyas el proyecto propietario. De forma predeterminada, ya se permite consumir la reserva.
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.

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

También puede hacer lo siguiente:

Para asociar GPUs a tus VMs 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 adjuntar GPUs a cualquier VM N1 reservada, haz una solicitud como la siguiente:

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

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 quieres reservar y especificar dos proyectos consumidores, haz una solicitud como la siguiente:

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_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.

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

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

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 orienten específicamente a esta reserva puedan consumirla, incluya el campo specificReservationRequired en el cuerpo de la solicitud y defínalo como true.

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

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
}

POST https://compute.googleapis.com/compute/v1/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 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.
  
  Por ejemplo, para crear una reserva, especificar la fecha y la hora en las que se debe eliminar y compartirla con dos proyectos de consumidor, haz una solicitud como la siguiente:
```
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"
    }
  }
}
```
  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.
  
  Por ejemplo, para crear una reserva que Compute Engine elimine después de un periodo específico y compartirla con dos proyectos de consumidor, haz una solicitud como la siguiente:
```
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"
    }
  }
}
```
  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 compartida Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Antes de empezar

Console

gcloud

Terraform

Go

Java

Node.js

Python

REST

Roles obligatorios

Permisos obligatorios

Prácticas recomendadas

Permitir y restringir que los proyectos creen y modifiquen reservas compartidas

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

Consola

gcloud

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

Consola

gcloud

Crear una reserva compartida

Especificar una plantilla de instancia

Consola

gcloud

Go

Java

Node.js

Python

REST

Especificar una VM

Especificar propiedades directamente

Consola

gcloud

Terraform

REST

Solución de problemas

Siguientes pasos

Crear una reserva compartida