Crear una reserva para un solo proyecto

Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Consola

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

   Ir a Reservas

2. En la pestaña Reservas bajo demanda (predeterminada), haga clic en add_box Crear reserva .

   Se abre la página Crear una reserva .

3. Para Nombre , ingrese un nombre para su reserva.

4. Para Región y Zona , seleccione dónde desea reservar recursos.

5. En la sección Tipo de recurso compartido , seleccione Local si aún no está seleccionado.

6. Opcional: para permitir que una reserva de máquinas virtuales GPU sea consumida por trabajos de entrenamiento personalizados o trabajos de predicción en Vertex AI, en la sección Servicios de Google Cloud , seleccione Compartir reserva .

7. En la sección Usar con instancia de VM , seleccione una de las siguientes opciones:

   • Para permitir que las máquinas virtuales coincidentes consuman automáticamente esta reserva, seleccione Usar reserva automáticamente si aún no está seleccionada.

   • Para consumir los recursos de esta reserva solo al crear máquinas virtuales coincidentes que se dirijan específicamente a esta reserva por nombre, seleccione Seleccionar reserva específica .

8. En Número de instancias de VM , ingrese la cantidad de VM que desea reservar.

9. En la sección Configuración de la máquina , haga lo siguiente:

   1. Para especificar las propiedades de sus máquinas virtuales desde una plantilla de instancia existente, seleccione Usar plantilla de instancia .

   2. En el campo Plantilla de instancia , seleccione la plantilla de instancia de su elección. Si selecciona una plantilla de instancia regional, solo podrá reservar recursos dentro de la región de la plantilla de instancia.

10. En la sección Eliminación automática , puedes habilitar la opción de eliminación automática para permitir que Compute Engine elimine automáticamente la reserva en una fecha y hora específicas. Eliminar reservas automáticamente puede ser útil para evitar cargos innecesarios cuando dejas de consumir la reserva.

11. Para crear la reserva, haga clic en Crear .

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

nube de gcloud

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

Para crear una reserva de proyecto único especificando una plantilla de instancia y sin incluir ningún indicador opcional, ejecute el siguiente comando:

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

Reemplace lo siguiente:

• RESERVATION_NAME : el nombre de la reserva a crear.

• PROJECT_ID : el ID del proyecto donde desea reservar recursos y donde existe la plantilla de instancia.

• LOCATION : la ubicación de la plantilla de instancia. Especifique uno de los siguientes valores:

  • Para una plantilla de instancia global: global .

  • Para una plantilla de instancia regional: regions/ REGION . Reemplace REGION con la región donde se encuentra la plantilla de instancia. Si especifica una plantilla de instancia regional, solo podrá reservar máquinas virtuales dentro de la misma región que la región de la plantilla.

• INSTANCE_TEMPLATE_NAME : el nombre de una plantilla de instancia existente. Si la plantilla de instancia especifica un tipo de máquina A3 Mega, A3 High o A3 Edge o una política de ubicación compacta, debe incluir la marca --require-specific-reservation . Esto indica que solo las máquinas virtuales que apuntan específicamente a la reserva pueden consumirla. Para obtener más información, consulte Consumir máquinas virtuales de una reserva específica .

• NUMBER_OF_VMS : la cantidad de máquinas virtuales que se reservarán.

• ZONE : la zona en la que reservar recursos.

Por ejemplo, para crear una reserva para diez máquinas virtuales en la zona us-central1-a especificando una plantilla de instancia global, ejecute el siguiente comando:

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

Opcionalmente, puede realizar una o más de las siguientes acciones:

• Para especificar que solo las máquinas virtuales que apuntan específicamente a esta reserva puedan consumirla, incluya la marca --require-specific-reservation .

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

• Para permitir que una reserva de máquinas virtuales GPU sea consumida por trabajos de entrenamiento personalizados o trabajos de predicción en Vertex AI, incluya el indicador --reservation-sharing-policy establecido en ALLOW_ALL .

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

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

  • Para eliminar 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 \
        --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
        --vm-count=NUMBER_OF_VMS \
        --zone=ZONE
    

    Reemplace DELETE_AT_TIME con una fecha y hora formateadas como marca de tiempo RFC 3339 , que debe ser la siguiente: none YYYY-MM-DD T HH:MM:SS OFFSET

    Reemplace lo siguiente:

    • YYYY-MM-DD : una fecha con 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 : una hora formateada como hora de 2 dígitos usando una hora de 24 horas, minutos de 2 dígitos y segundos de 2 dígitos, separados por dos puntos ( : ).

    • OFFSET : la zona horaria formateada como un desplazamiento de la hora universal coordinada (UTC) . Por ejemplo, para utilizar la hora estándar del Pacífico (PST), especifique -08:00 . Como alternativa, para no utilizar ningún desplazamiento, especifique Z .

  • Para eliminar 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 \
        --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
        --vm-count=NUMBER_OF_VMS \
        --zone=ZONE
    

    Reemplace DELETE_AFTER_DURATION con una duración en días, horas, minutos o segundos. Por ejemplo, especifique 30m para 30 minutos o 1d2h3m4s para 1 día, 2 horas, 3 minutos y 4 segundos.

Ir

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

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

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

	return nil
}

Java

import com.google.cloud.compute.v1.AllocationSpecificSKUReservation;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Reservation;
import com.google.cloud.compute.v1.ReservationsClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateReservationForInstanceTemplate {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the zone in which you want to create the reservation.
    String zone = "us-central1-a";
    // Name of the reservation you want to create.
    String reservationName = "YOUR_RESERVATION_NAME";
    // The number of virtual machines you want to create.
    int numberOfVms = 3;
    // The URI of the instance template with GLOBAL location
    // to be used for creating the reservation.
    String instanceTemplateUri =
        "projects/YOUR_PROJECT_ID/global/instanceTemplates/YOUR_INSTANCE_TEMPLATE_NAME";
    // The URI of the instance template with REGIONAL location
    // to be used for creating the reservation. For us-central1 region in this case.
    // String instanceTemplateUri =
    // "projects/YOUR_PROJECT_ID/regions/us-central1/instanceTemplates/YOUR_INSTANCE_TEMPLATE_NAME"

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

  // Creates a reservation in a project for the instance template.
  public static Reservation createReservationForInstanceTemplate(
      String projectId, String reservationName, String instanceTemplateUri,
      int numberOfVms, String zone)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (ReservationsClient reservationsClient = ReservationsClient.create()) {
      Reservation reservation =
          Reservation.newBuilder()
              .setName(reservationName)
              .setZone(zone)
              .setSpecificReservation(
                  AllocationSpecificSKUReservation.newBuilder()
                      // Set the number of instances
                      .setCount(numberOfVms)
                      // Set the instance template to be used for creating the reservation.
                      .setSourceInstanceTemplate(instanceTemplateUri)
                      .build())
              .build();

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

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

Nodo.js

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

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

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

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

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

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

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

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

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

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

  let operation = response.latestResponse;

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

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

await callCreateComputeReservationInstanceTemplate();

Pitón

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

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

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

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

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

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

DESCANSAR

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

Para crear una reserva de un solo proyecto especificando una plantilla de instancia y sin incluir ningún indicador opcional, realice la siguiente solicitud POST :

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

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

Reemplace lo siguiente:

• PROJECT_ID : el ID del proyecto donde desea reservar recursos y donde existe la plantilla de instancia.

• ZONE : la zona en la que reservar recursos.

• RESERVATION_NAME : el nombre de la reserva a crear.

• NUMBER_OF_VMS : la cantidad de máquinas virtuales que se reservarán.

• LOCATION : la ubicación de la plantilla de instancia. Especifique uno de los siguientes valores:

  • Para una plantilla de instancia global: global .

  • Para una plantilla de instancia regional: regions/ REGION . Reemplace REGION con la región donde se encuentra la plantilla de instancia. Si especifica una plantilla de instancia regional, solo podrá reservar máquinas virtuales dentro de la misma región que la región de la plantilla.

• INSTANCE_TEMPLATE_NAME : el nombre de una plantilla de instancia existente. Si la plantilla de instancia especifica un tipo de máquina A3 Mega, A3 High o A3 Edge o una política de ubicación compacta, debe incluir el campo specificReservationRequired en el cuerpo de la solicitud y establecer el campo en true . Esto indica que solo las máquinas virtuales que apuntan específicamente a esta reserva pueden consumirla. Para obtener más información, consulte Consumir máquinas virtuales de una reserva específica .

Por ejemplo, para crear una reserva para diez máquinas virtuales en la zona us-central1-a especificando una plantilla de instancia global, realice la siguiente solicitud POST :

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

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

Opcionalmente, puede realizar una o más de las siguientes acciones:

• Para especificar que solo las máquinas virtuales que apuntan específicamente a esta reserva puedan consumirla, incluya el specificReservationRequired en el cuerpo de la solicitud y establezca el campo en true .

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
  
  {
    "name": "RESERVATION_NAME",
    "specificReservation": {
      "count": "NUMBER_OF_VMS",
      "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
    },
    "specificReservationRequired": true
  }
  

• Para permitir que una reserva de máquinas virtuales GPU sea consumida por trabajos de entrenamiento personalizados o trabajos de predicción en Vertex AI, incluya el campo serviceShareType y configúrelo en ALLOW_ALL .

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
  
  {
    "name": "RESERVATION_NAME",
    "reservationSharingPolicy": {
      "serviceShareType": "ALLOW_ALL"
    },
    "specificReservation": {
      "count": "NUMBER_OF_VMS",
      "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
    }
  }
  

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

  • Para eliminar la reserva en una fecha y hora específica, realice una solicitud POST al método beta.reservations.insert . En el cuerpo de la solicitud, incluya el campo deleteAtTime .

    POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations
    
    {
      "deleteAtTime": "DELETE_AT_TIME",
      "name": "RESERVATION_NAME",
      "specificReservation": {
        "count": "NUMBER_OF_VMS",
        "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
      }
    }
    

    Reemplace DELETE_AT_TIME con una fecha y hora formateadas como marca de tiempo RFC 3339 , que debe ser la siguiente:

    YYYY-MM-DDTHH:MM:SSOFFSET
    

    Reemplace lo siguiente:

    • YYYY-MM-DD : una fecha con 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 : una hora formateada como hora de 2 dígitos usando una hora de 24 horas, minutos de 2 dígitos y segundos de 2 dígitos, separados por dos puntos ( : ).

    • OFFSET : la zona horaria formateada como un desplazamiento de la hora universal coordinada (UTC) . Por ejemplo, para utilizar la hora estándar del Pacífico (PST), especifique -08:00 . Como alternativa, para no utilizar ningún desplazamiento, especifique Z .

  • Para eliminar la reserva después de una duración específica, realice una solicitud POST al método beta.reservations.insert . En el cuerpo de la solicitud, incluya el campo deleteAfterDuration .

    POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations
    
    {
      "deleteAfterDuration": {
        "seconds": "DELETE_AFTER_DURATION"
      },
      "name": "RESERVATION_NAME",
      "specificReservation": {
        "count": "NUMBER_OF_VMS",
        "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
      }
    }
    

    Reemplace DELETE_AFTER_DURATION con una duración en segundos. Por ejemplo, especifique 86400 durante 86 400 segundos (1 día).

Consola

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

   Ir a Reservas

2. En la pestaña Reservas bajo demanda (predeterminada), haga clic en add_box Crear reserva .

   Se abre la página Crear una reserva .

3. Para Nombre , ingrese un nombre para su reserva.

4. Para Región y Zona , seleccione dónde desea reservar recursos.

5. En la sección Tipo de recurso compartido , haga clic en Local si aún no está seleccionado.

6. Opcional: para permitir que una reserva de máquinas virtuales GPU sea consumida por trabajos de entrenamiento personalizados o trabajos de predicción en Vertex AI, en la sección Servicios de Google Cloud , seleccione Compartir reserva .

7. En la sección Usar con instancia de VM , seleccione una de las siguientes opciones:

   • Para permitir que las máquinas virtuales coincidentes consuman automáticamente esta reserva, seleccione Usar reserva automáticamente si aún no está seleccionada.

   • Para consumir los recursos de esta reserva solo al crear máquinas virtuales coincidentes que se dirijan específicamente a esta reserva por nombre, seleccione Seleccionar reserva específica .

8. En Número de instancias de VM , ingrese la cantidad de VM que desea reservar.

9. En la sección Configuración de la máquina , seleccione Especificar tipo de máquina y luego especifique lo siguiente:

   1. Para Familia de máquinas , Serie y Tipo de máquina , seleccione 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 GPU a máquinas virtuales N1, haga lo siguiente:

      1. Para expandir la sección Plataforma CPU y GPU , haga clic en la flecha de expansión expand_more .

      2. Opcional: Para especificar una plataforma de CPU mínima, en Plataforma de CPU , seleccione una opción.

      3. Opcional: para conectar GPU a máquinas virtuales N1, haga clic en add Agregar GPU . Luego, para Tipo de GPU y Número de GPU , seleccione el tipo y la cantidad de GPU que desea conectar a cada VM N1.

10. Opcional: Para conectar discos SSD locales a un tipo de máquina que no incluye discos SSD locales de forma predeterminada , haga lo siguiente:

    1. Para Número de discos , seleccione la cantidad de discos SSD locales que desea conectar.

    2. Para Tipo de interfaz , seleccione la interfaz del disco para los discos SSD locales.

11. Opcional: para especificar una política de ubicación compacta para una reserva que cumpla con los requisitos , en la sección Política de ubicación de grupo , haga clic en la lista Seleccionar o crear una política de ubicación de grupo y luego realice una de las siguientes acciones:

    • Para crear una política de ubicación compacta para especificar en esta reserva, haga lo siguiente:

      1. Haga clic en Crear política de ubicación de grupo .

         Aparece el panel Crear una política de ubicación de grupo .

      2. Para Nombre de política , ingrese un nombre para su política.

      3. Haga clic en Crear .

         La creación de la política de ubicación compacta puede tardar unos segundos en completarse.

    • De lo contrario, seleccione una política de ubicación compacta existente.

12. En la sección Eliminación automática , puedes habilitar la opción de eliminación automática para permitir que Compute Engine elimine automáticamente la reserva en una fecha y hora específicas. Eliminar reservas automáticamente puede ser útil para evitar cargos innecesarios cuando dejas de consumir la reserva.

13. Para crear la reserva, haga clic en Crear .

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

nube de gcloud

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

Para crear una reserva de un solo proyecto especificando propiedades directamente y sin incluir ningún indicador opcional, ejecute el siguiente comando:

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

Reemplace lo siguiente:

• RESERVATION_NAME : el nombre de la reserva a crear.

• MACHINE_TYPE : un tipo de máquina a utilizar para cada VM. Si 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 apuntan específicamente a la reserva pueden consumirla. Para obtener más información, consulte Consumir máquinas virtuales de una reserva específica .

• NUMBER_OF_VMS : la cantidad de máquinas virtuales que se reservarán.

• ZONE : la zona en la que reservar recursos.

Por ejemplo, para crear una reserva en la zona us-central1-a para diez máquinas virtuales, cada una de las cuales usa un tipo de máquina predefinido N2 con 4 vCPU, ejecute el siguiente comando:

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

Opcionalmente, puede realizar una o más de las siguientes acciones:

• Para conectar GPU a sus máquinas virtuales N1 reservadas, incluya el indicador --accelerator .

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

  Reemplace lo siguiente:

  • NUMBER_OF_ACCELERATORS : la cantidad de GPU que se agregarán por VM reservada.

  • ACCELERATOR_TYPE : un modelo de GPU compatible con máquinas virtuales N1 . Asegúrese de que el modelo de GPU elegido esté disponible en la zona donde desea reservar recursos. De lo contrario, la creación de la reserva fallará.

• Para conectar discos SSD locales a un tipo de máquina que no incluye discos SSD locales de forma predeterminada , incluya la marca --local-ssd . Sólo 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
  

  Reemplace lo siguiente:

  • NUMBER_OF_LOCAL_SSD_DISKS : la cantidad de discos SSD locales que se conectarán.

  • INTERFACE_TYPE : el tipo de interfaz de disco que desea que utilice cada disco SSD local y que admite el tipo de máquina especificado . Especifique uno de los siguientes valores:

    • Para la interfaz de disco NVME: nvme

    • Para la interfaz de disco SCSI: scsi

• Para que las máquinas virtuales reservadas utilicen una plataforma de CPU mínima específica en lugar de la plataforma de CPU predeterminada de la zona, incluya la marca --min-cpu-platform .

  gcloud compute reservations create RESERVATION_NAME \
      --machine-type=MACHINE_TYPE \
      --min-cpu-platform="MIN_CPU_PLATFORM" \
      --vm-count=NUMBER_OF_VMS \
      --zone=ZONE
  

  Reemplace MIN_CPU_PLATFORM con una plataforma de CPU mínima. Para asegurarse de que haya una plataforma de CPU disponible en la zona donde está reservando recursos, vea las plataformas de CPU disponibles por zona .

• Para especificar que solo las máquinas virtuales que apuntan específicamente a esta reserva puedan consumirla, incluya la marca --require-specific-reservation .

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

• Para especificar una política de ubicación compacta para una latencia de red más baja entre las máquinas virtuales, incluya la marca --resource-policies=policy .

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

  Reemplace COMPACT_PLACEMENT_POLICY_NAME con el nombre de una política de ubicación compacta existente. Además, para evitar errores al crear una reserva de proyecto único que especifica una política de ubicación compacta, asegúrese de especificar lo siguiente:

  • Un tipo de máquina compatible y una cantidad máxima de máquinas virtuales para políticas de ubicación compacta.

  • Una zona dentro de la región donde se ubica la política de colocación compacta.

  • El indicador --require-specific-reservation . Esto indica que solo las máquinas virtuales que apuntan específicamente a la reserva pueden consumirla.

• Para permitir que una reserva de máquinas virtuales GPU sea consumida por trabajos de entrenamiento personalizados o trabajos de predicción en Vertex AI, incluya el indicador --reservation-sharing-policy establecido en ALLOW_ALL .

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

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

  • Para eliminar 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 \
        --vm-count=NUMBER_OF_VMS \
        --zone=ZONE
    

    Reemplace DELETE_AT_TIME con una fecha y hora formateadas como marca de tiempo RFC 3339 , que debe ser la siguiente:

    YYYY-MM-DDTHH:MM:SSOFFSET
    

    Reemplace lo siguiente:

    • YYYY-MM-DD : una fecha con 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 : una hora formateada como hora de 2 dígitos usando una hora de 24 horas, minutos de 2 dígitos y segundos de 2 dígitos, separados por dos puntos ( : ).

    • OFFSET : la zona horaria formateada como un desplazamiento de la hora universal coordinada (UTC) . Por ejemplo, para utilizar la hora estándar del Pacífico (PST), especifique -08:00 . Como alternativa, para no utilizar ningún desplazamiento, especifique Z .

  • Para eliminar 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 \
        --vm-count=NUMBER_OF_VMS \
        --zone=ZONE
    

    Reemplace DELETE_AFTER_DURATION con una duración en días, horas, minutos o segundos. Por ejemplo, especifique 30m para 30 minutos o 1d2h3m4s para 1 día, 2 horas, 3 minutos y 4 segundos.

Ir

import (
	"context"
	"fmt"
	"io"

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

// Creates the reservation with accelerated image
func createBaseReservation(w io.Writer, projectID, zone, reservationName string) error {
	// projectID := "your_project_id"
	// zone := "us-west3-a"
	// reservationName := "your_reservation_name"

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

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

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

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

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

	return nil
}

Java

import com.google.cloud.compute.v1.AcceleratorConfig;
import com.google.cloud.compute.v1.AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk;
import com.google.cloud.compute.v1.AllocationSpecificSKUAllocationReservedInstanceProperties;
import com.google.cloud.compute.v1.AllocationSpecificSKUReservation;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Reservation;
import com.google.cloud.compute.v1.ReservationsClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateReservation {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the zone in which you want to create the disk.
    String zone = "us-central1-a";
    // Name of the reservation you want to create.
    String reservationName = "YOUR_RESERVATION_NAME";
    // Number of instances in the reservation.
    int numberOfVms = 3;

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

  // Creates reservation with optional flags
  public static Reservation createReservation(
      String projectId, String reservationName, int numberOfVms, String zone)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Create the reservation with optional properties:
    // Machine type of the instances in the reservation.
    String machineType = "n1-standard-2";
    // Number of accelerators to be attached to the instances in the reservation.
    int numberOfAccelerators = 1;
    // Accelerator type to be attached to the instances in the reservation.
    String acceleratorType = "nvidia-tesla-t4";
    // Minimum CPU platform to be attached to the instances in the reservation.
    String minCpuPlatform = "Intel Skylake";
    // Local SSD size in GB to be attached to the instances in the reservation.
    int localSsdSize = 375;
    // Local SSD interfaces to be attached to the instances in the reservation.
    String localSsdInterface1 = "NVME";
    String localSsdInterface2 = "SCSI";
    boolean specificReservationRequired = true;
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (ReservationsClient reservationsClient = ReservationsClient.create()) {
      Reservation reservation =
          Reservation.newBuilder()
              .setName(reservationName)
              .setZone(zone)
              .setSpecificReservationRequired(specificReservationRequired)
              .setSpecificReservation(
                  AllocationSpecificSKUReservation.newBuilder()
                      // Set the number of instances
                      .setCount(numberOfVms)
                      // Set instance properties
                      .setInstanceProperties(
                          AllocationSpecificSKUAllocationReservedInstanceProperties.newBuilder()
                              .setMachineType(machineType)
                              .setMinCpuPlatform(minCpuPlatform)
                              .addGuestAccelerators(
                                  AcceleratorConfig.newBuilder()
                                      .setAcceleratorCount(numberOfAccelerators)
                                      .setAcceleratorType(acceleratorType)
                                      .build())
                              .addLocalSsds(
                            AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk
                                      .newBuilder()
                                      .setDiskSizeGb(localSsdSize)
                                      .setInterface(localSsdInterface1)
                                      .build())
                              .addLocalSsds(
                            AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk
                                      .newBuilder()
                                      .setDiskSizeGb(localSsdSize)
                                      .setInterface(localSsdInterface2)
                                      .build())
                              .build())
                      .build())
              .build();

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

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

Nodo.js

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

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

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

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

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

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

  let operation = response.latestResponse;

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

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

await callCreateComputeReservationFromProperties();

Pitón

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

    # Create a client
    client = compute_v1.ReservationsClient()

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

    reservation = client.get(
        project=project_id, zone=zone, reservation=reservation_name
    )

    print("Name: ", reservation.name)
    print("STATUS: ", reservation.status)
    print(reservation.specific_reservation)
    # Example response:
    # Name:  your-reservation-name
    # STATUS:  READY
    # count: 3
    # instance_properties {
    #   machine_type: "n1-standard-1"
    #   local_ssds {
    #     disk_size_gb: 375
    #     interface: "NVME"
    #   }
    # ...

    return reservation

Terraformar

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

Por ejemplo, para crear una reserva de proyecto único para un tipo de máquina predefinida N2 con 2 vCPU, utilice el siguiente recurso:

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

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

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

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

Para obtener más información sobre cómo utilizar Terraform, consulte Uso de Terraform con Google Cloud .

DESCANSAR

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

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

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

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

Reemplace lo siguiente:

• PROJECT_ID : el ID del proyecto donde desea reservar recursos.

• ZONE : la zona en la que reservar recursos.

• RESERVATION_NAME : el nombre de la reserva a crear.

• NUMBER_OF_VMS : la cantidad de máquinas virtuales que se reservarán.

• MACHINE_TYPE : un tipo de máquina a utilizar para cada VM. Si especifica un tipo de máquina A3 Mega, A3 High o A3 Edge, debe incluir el campo specificReservationRequired en el cuerpo de la solicitud y establecer el campo en true . Esto indica que solo las máquinas virtuales que apuntan específicamente a la reserva pueden consumirla. Para obtener más información, consulte Consumir máquinas virtuales de una reserva específica .

Por ejemplo, para crear una reserva en la zona us-central1-a para diez máquinas virtuales, cada una de las cuales usa un tipo de máquina predefinido N2 con 4 vCPU, realice la siguiente solicitud POST :

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

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

Opcionalmente, puede realizar una o más de las siguientes acciones:

• Para conectar GPU a sus máquinas virtuales N1 reservadas, incluya el campo guestAccelerators en el cuerpo de la solicitud.

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
  
  {
    "name": "RESERVATION_NAME",
    "specificReservation": {
      "count": "NUMBER_OF_VMS",
      "instanceProperties": {
        "guestAccelerators": [
          {
            "acceleratorCount": NUMBER_OF_ACCELERATORS,
            "acceleratorType": "ACCELERATOR_TYPE"
          }
        ],
        "machineType": "MACHINE_TYPE"
      }
    }
  }
  

  Reemplace lo siguiente:

  • NUMBER_OF_ACCELERATORS : la cantidad de GPU que se agregarán por VM reservada.

  • ACCELERATOR_TYPE : un modelo de GPU compatible con máquinas virtuales N1 . Asegúrese de que el modelo de GPU elegido esté disponible en la zona donde desea reservar recursos. De lo contrario, la creación de la reserva fallará.

• Para conectar discos SSD locales a un tipo de máquina que no incluye discos SSD locales de forma predeterminada , incluya el campo localSsds en el cuerpo de la solicitud. Sólo puedes conectar discos SSD locales de 375 GB.

  Por ejemplo, para conectar dos discos SSD locales al tipo de máquina que desea reservar, realice una solicitud de la siguiente manera:

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
  
  {
    "name": "RESERVATION_NAME",
    "specificReservation": {
      "count": "NUMBER_OF_VMS",
      "instanceProperties": {
        "localSsds": [
          {
            "diskSizeGb": "375",
            "interface": "INTERFACE_TYPE"
          },
          {
            "diskSizeGb": "375",
            "interface": "INTERFACE_TYPE"
          }
        ],
        "machineType": "MACHINE_TYPE"
      }
    }
  }
  

  Reemplace INTERFACE_TYPE con el tipo de interfaz de disco que desea que utilice cada disco SSD local y que admita el tipo de máquina especificado . Especifique uno de los siguientes valores:

  • Para la interfaz de disco NVME: NVME

  • Para la interfaz de disco SCSI: SCSI

• Para que las máquinas virtuales reservadas utilicen una plataforma de CPU mínima específica en lugar de la plataforma de CPU predeterminada de la zona, incluya el campo minCpuPlatform en el cuerpo de la solicitud.

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
  
  {
    "name": "RESERVATION_NAME",
    "specificReservation": {
      "count": "NUMBER_OF_VMS",
      "instanceProperties": {
        "machineType": "MACHINE_TYPE",
        "minCpuPlatform": "MIN_CPU_PLATFORM"
      }
    }
  }
  

  Reemplace MIN_CPU_PLATFORM con una plataforma de CPU mínima. Para asegurarse de que haya una plataforma de CPU disponible en la zona donde está reservando recursos, vea las plataformas de CPU disponibles por zona .

• Para especificar una política de ubicación compacta para reducir la latencia de la red entre sus máquinas virtuales reservadas, incluya el campo resourcePolicies en el cuerpo de la solicitud.

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
  
  {
    "name": "RESERVATION_NAME",
    "resourcePolicies": {
      "policy" : "projects/example-project/regions/REGION/resourcePolicies/COMPACT_PLACEMENT_POLICY_NAME"
    },
    "specificReservation": {
      "count": "NUMBER_OF_VMS",
      "instanceProperties": {
        "machineType": "MACHINE_TYPE"
      }
    },
    "specificReservationRequired": true
  }
  

  Reemplace lo siguiente:

  • REGION : la región donde se encuentra la política de colocación compacta. Solo puede crear la reserva dentro de la región de la política de ubicación.

  • COMPACT_PLACEMENT_POLICY_NAME : el nombre de una política de ubicación compacta existente.

  Además, para evitar errores al crear una reserva de proyecto único que especifica una política de ubicación compacta, asegúrese de especificar lo siguiente:

  • Un tipo de máquina compatible para políticas de ubicación compacta.

  • El campo specificReservationRequired establecido en true . Esto indica que solo las máquinas virtuales que apuntan específicamente a esta reserva pueden consumirla.

• Para especificar que solo las máquinas virtuales que apuntan específicamente a esta reserva puedan consumirla, incluya el specificReservationRequired en el cuerpo de la solicitud y establezca el campo en true .

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
  
  {
    "name": "RESERVATION_NAME",
    "specificReservation": {
      "count": "NUMBER_OF_VMS",
      "instanceProperties": {
        "machineType": "MACHINE_TYPE"
      }
    },
    "specificReservationRequired": true
  }
  

• Para permitir que una reserva de máquinas virtuales GPU sea consumida por trabajos de entrenamiento personalizados o trabajos de predicción en Vertex AI, incluya el campo serviceShareType y configúrelo en ALLOW_ALL .

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
  
  {
    "name": "RESERVATION_NAME",
    "reservationSharingPolicy": {
      "serviceShareType": "ALLOW_ALL"
    },
    "specificReservation": {
      "count": "NUMBER_OF_VMS",
      "instanceProperties": {
        "machineType": "MACHINE_TYPE"
      }
    }
  }
  

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

  • Para eliminar la reserva en una fecha y hora específica, realice una solicitud POST al método beta.reservations.insert . En el cuerpo de la solicitud, incluya el campo deleteAtTime .

    POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations
    
    {
      "deleteAtTime": "DELETE_AT_TIME",
      "name": "RESERVATION_NAME",
      "specificReservation": {
        "count": "NUMBER_OF_VMS",
        "instanceProperties": {
          "machineType": "MACHINE_TYPE"
        }
      }
    }
    

    Reemplace DELETE_AT_TIME con una fecha y hora formateadas como marca de tiempo RFC 3339 , que debe ser la siguiente:

    YYYY-MM-DDTHH:MM:SSOFFSET
    

    Reemplace lo siguiente:

    • YYYY-MM-DD : una fecha con 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 : una hora formateada como hora de 2 dígitos usando una hora de 24 horas, minutos de 2 dígitos y segundos de 2 dígitos, separados por dos puntos ( : ).

    • OFFSET : la zona horaria formateada como un desplazamiento de la hora universal coordinada (UTC) . Por ejemplo, para utilizar la hora estándar del Pacífico (PST), especifique -08:00 . Como alternativa, para no utilizar ningún desplazamiento, especifique Z .

  • Para eliminar la reserva después de una duración específica, realice una solicitud POST al método beta.reservations.insert . En el cuerpo de la solicitud, incluya el campo deleteAfterDuration .

    POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations
    
    {
      "deleteAfterDuration": {
        "seconds": "DELETE_AFTER_DURATION"
      },
      "name": "RESERVATION_NAME",
      "specificReservation": {
        "count": "NUMBER_OF_VMS",
        "instanceProperties": {
          "machineType": "MACHINE_TYPE"
        }
      }
    }
    

    Reemplace DELETE_AFTER_DURATION con una duración en segundos. Por ejemplo, especifique 86400 durante 86.400 segundos (1 día).