Criar uma reserva para um projeto único

Neste documento, há informações sobre como criar uma reserva de um projeto único, que pode ser consumida apenas por instâncias de máquina virtual (VM) no mesmo projeto. Para saber mais sobre reservas, consulte Reservas para recursos zonais do Compute Engine.

Para outros métodos de criação de reservas, consulte as seguintes páginas:

  • Se você tiver um compromisso de um ou três anos no projeto atual, seus recursos reservados receberão automaticamente todos os descontos por uso contínuo aplicáveis. Também é possível criar e anexar uma reserva a um compromisso ao comprá-lo. Para saber mais, consulte Anexar reservas a compromissos.

  • Para criar uma reserva que possa ser usada por vários projetos, consulte Criar uma reserva compartilhada.

Antes de começar

  • Revise os requisitos e restrições para reservas.
  • Configure a autenticação, caso ainda não tenha feito isso. A autenticação é o processo de verificação da sua identidade para acesso a serviços e APIs do Google Cloud. Para executar códigos ou amostras de um ambiente de desenvolvimento local, autentique-se no Compute Engine selecionando uma das seguintes opções:

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

    Console

    When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

    gcloud

    1. Install the Google Cloud CLI, then initialize it by running the following command: 

      gcloud init
    2. Set a default region and zone.

      3. Terraform

      Para usar os exemplos do Terraform nesta página em um ambiente de desenvolvimento local, instale e inicialize a gcloud CLI e, em seguida, configure o Application Default Credentials com suas credenciais de usuário.

      1. Install the Google Cloud CLI.

      2. To initialize the gcloud CLI, run the following command: 

        gcloud init

      3. If you're using a local shell, then create local authentication credentials for your user account: 

        gcloud auth application-default login

        You don't need to do this if you're using Cloud Shell.

      Confira mais informações em Set up authentication for a local development environment.

      REST

      Para usar as amostras da API REST nesta página em um ambiente de desenvolvimento local, use as credenciais fornecidas para gcloud CLI.

        Install the Google Cloud CLI, then initialize it by running the following command: 

        gcloud init

      Para mais informações, consulte Autenticar para usar REST na documentação de autenticação do Google Cloud.

Funções exigidas

Para receber as permissões necessárias a fim de criar reservas de projeto único, peça ao administrador para conceder a você o papel do IAM de Administrador do Compute (roles/compute.admin) no projeto. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esse papel predefinido contém as permissões necessárias para criar reservas de um projeto único. Para conferir as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As seguintes permissões são necessárias para criar reservas de projeto único:

  • compute.reservations.create no projeto
  • Para especificar um modelo de instância: compute.instanceTemplates.useReadOnly no modelo de instância

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

Criar uma reserva de projeto único

Para consumir uma reserva, uma VM precisa ter propriedades que correspondam exatamente a essa reserva. Para especificar as propriedades das VMs que você quer reservar, selecione uma das seguintes seções neste documento:

  • Recomendado: Especificar um modelo de instância

    Nesta seção, explicamos como usar um modelo de instância para definir as propriedades de uma reserva. Ao usar um modelo de instância, é possível definir as propriedades de uma reserva e as VMs que podem consumir a reserva no mesmo lugar.

  • Especificar uma VM atual

    Esta seção explica como usar uma VM atual para definir as propriedades de uma reserva. Ao usar as propriedades de uma VM existente, é possível consumir a reserva criando VMs com propriedades que correspondem à VM de referência.

  • Especificar propriedades diretamente

    Nesta seção, explicamos como definir diretamente as propriedades de uma reserva. Esse método exige que você verifique manualmente se as propriedades das VMs e reservas são exatamente correspondentes. Qualquer propriedade não correspondente impede o consumo.

Por padrão, uma reserva pode ser consumida automaticamente por qualquer VM com propriedades correspondentes. Se você quiser controlar o consumo de reservas, siga um ou mais de um destes procedimentos:

Além disso, é possível especificar uma política de posicionamento compacta ao criar uma reserva de projeto único. Uma política de posicionamento compacto especifica que as VMs precisam estar localizadas o mais próximas possível uma da outra para reduzir a latência da rede.

Especificar um modelo de instância

Para evitar erros ao criar uma reserva especificando um modelo de instância, verifique o seguinte:

  • Crie a reserva na mesma região e zona que os recursos no modelo de instância. Todos os recursos regionais ou zonais especificados em um modelo de instância, como um tipo de máquina ou um Persistent Disk, restringem o uso do modelo aos locais em que esses recursos estão. Por exemplo, se o modelo de instância especificar um volume do Persistent Disk na zona us-central1-a, só será possível criar a reserva na mesma zona. Para verificar se um modelo já existente especifica algum recurso que o vincule a uma região ou zona específica, veja os detalhes do modelo e procure referências a esses recursos regionais ou zonais dentro dele.

  • Se o modelo de instância especificar uma política de posicionamento compacto, verifique se o modelo especifica um tipo de máquina com suporte para políticas de posicionamento compactas. Caso contrário, a criação da reserva falhará.

Para criar uma reserva de projeto único especificando um modelo de instância, selecione uma das seguintes opções:

Console

  1. No console do Google Cloud, acesse a página Reservas.

    Acessar "Reservas"

  2. Na guia Reservas on demand (padrão), clique em Criar reserva.

    A página Criar uma reserva é aberta.

  3. Em Nome, insira um nome para o provedor.

  4. Para Região e Zona, selecione onde você quer reservar recursos.

  5. Na seção Tipo de compartilhamento, selecione Local, caso ainda não esteja selecionado.

  6. Opcional: para permitir que uma reserva de VMs de GPU seja consumida por jobs de treinamento personalizado ou jobs de previsão na Vertex AI, na seção Serviços do Google Cloud, selecione Compartilhar reserva.

  7. Na seção Usar com instância de VM, selecione uma das seguintes opções:

    • Para permitir que VMs correspondentes consumam essa reserva automaticamente, selecione Usar reserva automaticamente, se ainda não estiver selecionado.

    • Para consumir os recursos desta reserva apenas ao criar VMs correspondentes que visam especificamente essa reserva por nome, clique em Selecionar reserva específica.

  8. Em Número de instâncias de VM, insira o número de VMs que você quer reservar.

  9. Na seção Configuração da máquina, faça o seguinte:

    1. Para especificar as propriedades das VMs com base em um modelo de instância, selecione Usar modelo de instância.

    2. No campo Modelo de instância, selecione o modelo de instância de sua escolha. Se você selecionar um modelo de instância regional, só poderá reservar recursos na região do modelo de instância.

  10. Na seção Exclusão automática, é possível ativar a opção para permitir que o Compute Engine exclua automaticamente a reserva em uma data e hora específicas. A exclusão automática de reservas pode ser útil para evitar cobranças desnecessárias quando você para de consumir a reserva.

  11. Para criar a reserva, clique em Criar.

    A página Reservas abre. A criação da reserva de projeto único pode levar até um minuto para ser concluída.

gcloud

Para criar uma reserva de projeto único, use o comando gcloud compute reservations create.

Para criar uma reserva de projeto único especificando um modelo de instância e sem incluir flags opcionais, execute o seguinte 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

Substitua:

  • RESERVATION_NAME: o nome da reserva a ser criada.

  • PROJECT_ID: o ID do projeto em que você quer reservar recursos e onde o modelo de instância existe.

  • LOCATION: o local do modelo de instância. Especifique um dos seguintes valores:

    • Para um modelo de instância global: global

    • Para um modelo de instância regional: regions/REGION. Substitua REGION pela região em que o modelo de instância está. Se você selecionar um modelo de instância regional, só poderá reservar na mesma região que a do modelo.

  • INSTANCE_TEMPLATE_NAME: o nome de um modelo de instância. Se o modelo de instância especificar um tipo de máquina A3 ou uma política de posicionamento compacto, inclua a flag --require-specific-reservation. Isso indica que apenas VMs que segmentam especificamente a reserva podem efetivá-la. Para mais informações, consulte Efetivar VMs de uma reserva específica.

  • NUMBER_OF_VMS: o número de VMs a serem reservadas.

  • ZONE: a zona em que os recursos serão reservados.

Por exemplo, para criar uma reserva para dez VMs na zona us-central1-a especificando um modelo de instância global, execute o seguinte comando:

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

Também é possível realizar uma ou mais das seguintes ações:

  • Para especificar que apenas VMs que segmentam especificamente esta reserva podem consumi-la, inclua a flag --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 uma reserva de VMs de GPU seja consumida por jobs de treinamento personalizado ou jobs de previsão na Vertex AI, use o comando gcloud beta compute reservations create com a flag --reservation-sharing-policy=ALLOW_ALL.

    gcloud beta 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 o Compute Engine exclua automaticamente a reserva, selecione um dos seguintes métodos:

    • Para excluir a reserva em uma data e hora específicas, use o comando gcloud beta compute reservations create com a flag --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

      Substitua DELETE_AT_TIME por uma data e hora formatadas como um carimbo de data/hora RFC 3339, que precisa ser o seguinte: none YYYY-MM-DDTHH:MM:SSOFFSET

      Substitua:

      • YYYY-MM-DD: uma data formatada como um ano de quatro dígitos, um mês de dois dígitos e um dia de dois dígitos, separados por hífens (-).

      • HH:MM:SS: um horário formatado como uma hora de dois dígitos usando um horário de 24 horas, minutos de dois dígitos e segundos de dois dígitos, separados por dois pontos (:).

      • OFFSET: o fuso horário formatado como um ajuste de Tempo Universal Coordenado (UTC). Por exemplo, para usar o horário padrão do Pacífico (PST), especifique -08:00. Outra possibilidade é não usar ajuste: especifique Z.

    • Para excluir a reserva após uma duração específica, use o comando gcloud beta compute reservations create com a flag --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

      Substitua DELETE_AFTER_DURATION por uma duração em dias, horas, minutos ou segundos. Por exemplo, especifique 30m para 30 minutos ou 1d2h3m4s para 1 dia, 2 horas, 3 minutos e 4 segundos.

Go

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

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

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

	return nil
}

Java 

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

public class CreateReservationForInstanceTemplate {

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

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

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

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

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

Node.js 

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

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

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

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

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

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

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

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

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

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

  let operation = response.latestResponse;

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

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

await callCreateComputeReservationInstanceTemplate();

Python 

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

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

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

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

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

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

REST

Para criar uma reserva de projeto único, faça uma solicitação POST para o método reservations.insert.

Para criar uma reserva de projeto único especificando um modelo de instância e sem incluir flags opcionais, faça a seguinte solicitação 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"
  }
}

Substitua:

  • PROJECT_ID: o ID do projeto em que você quer reservar recursos e onde o modelo de instância existe.

  • ZONE: a zona em que os recursos serão reservados.

  • RESERVATION_NAME: o nome da reserva a ser criada.

  • NUMBER_OF_VMS: o número de VMs a serem reservadas.

  • LOCATION: o local do modelo de instância. Especifique um dos seguintes valores:

    • Para um modelo de instância global: global

    • Para um modelo de instância regional: regions/REGION. Substitua REGION pela região em que o modelo de instância está. Se você selecionar um modelo de instância regional, só poderá reservar na mesma região que a do modelo.

  • INSTANCE_TEMPLATE_NAME: o nome de um modelo de instância. Se o modelo de instância especificar um tipo de máquina A3 ou uma política de posicionamento compacta, inclua o campo specificReservationRequired no corpo da solicitação e defina o campo como true. Isso indica que apenas VMs que segmentam especificamente essa reserva podem efetivá-la. Para mais informações, consulte Efetivar VMs de uma reserva específica.

Por exemplo, para criar uma reserva para dez VMs na zona us-central1-a especificando um modelo de instância global, faça a seguinte solicitação 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"
  }
}

Também é possível realizar uma ou mais das seguintes ações:

  • Para especificar que apenas VMs que segmentam especificamente esta reserva possam consumi-la, inclua o campo specificReservationRequired no corpo da solicitação e defina-o como 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 uma reserva de VMs de GPU seja consumida por jobs de treinamento personalizado ou jobs de previsão na Vertex AI, faça uma solicitação POST para o método beta.reservations.insert. No corpo da solicitação, inclua o campo serviceShareType e defina-o como ALLOW_ALL.

    POST https://compute.googleapis.com/compute/beta/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 o Compute Engine exclua automaticamente a reserva, selecione um dos seguintes métodos:

    • Para excluir a reserva em uma data e hora específicas, faça uma solicitação POST para o método beta.reservations.insert. No corpo da solicitação, inclua o 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"
  }
}

      Substitua DELETE_AT_TIME por uma data e hora formatadas como um carimbo de data/hora RFC 3339, que precisa ser o seguinte:

      YYYY-MM-DDTHH:MM:SSOFFSET

      Substitua:

      • YYYY-MM-DD: uma data formatada como um ano de quatro dígitos, um mês de dois dígitos e um dia de dois dígitos, separados por hífens (-).

      • HH:MM:SS: um horário formatado como uma hora de dois dígitos usando um horário de 24 horas, minutos de dois dígitos e segundos de dois dígitos, separados por dois pontos (:).

      • OFFSET: o fuso horário formatado como um ajuste de Tempo Universal Coordenado (UTC). Por exemplo, para usar o horário padrão do Pacífico (PST), especifique -08:00. Outra possibilidade é não usar ajuste: especifique Z.

    • Para excluir a reserva após uma duração específica, faça uma solicitação POST para o método beta.reservations.insert. No corpo da solicitação, inclua o 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"
  }
}

      Substitua DELETE_AFTER_DURATION por uma duração em segundos. Por exemplo, especifique 86400 para 86.400 segundos (1 dia).

Especificar uma VM

Só é possível criar uma reserva com base em uma VM existente na mesma zona que a VM.

Depois de criar a reserva, é possível consumi-la criando VMs com propriedades que correspondem à VM de referência. Para fazer isso, siga um destes procedimentos:

Para criar uma reserva de projeto único que use as propriedades de uma VM existente, faça o seguinte:

  1. No console do Google Cloud, acesse a página Reservas.

    Acessar "Reservas"

  2. Clique em Criar reserva.

    A página Criar uma reserva é aberta.

  3. Em Nome, insira um nome para o provedor.

  4. Para Região e Zona, selecione onde você quer reservar recursos.

  5. Na seção Tipo de compartilhamento, clique em Local, caso ainda não esteja selecionado.

  6. Na seção Usar com instância de VM, selecione uma das seguintes opções:

    • Para permitir que VMs correspondentes consumam essa reserva automaticamente, selecione Usar reserva automaticamente, se ainda não estiver selecionado.

    • Para consumir os recursos desta reserva apenas ao criar VMs correspondentes que visam especificamente essa reserva por nome, clique em Selecionar reserva específica.

  7. Em Número de instâncias de VM, insira o número de VMs que você quer reservar.

  8. Na seção Configuração da máquina, faça o seguinte:

    1. Selecione Usar VM atual.

    2. Em VM existente, selecione as propriedades que você quer usar para criar a reserva.

  9. Opcional: para especificar uma política de posicionamento compacto para uma reserva que atenda aos requisitos, na seção Política de posicionamento em grupo, clique na lista Selecionar ou criar uma política de posicionamento em grupo e faça uma das seguintes ações:

    • Para criar uma política de posicionamento compacta a ser especificada nessa reserva, faça o seguinte:

      1. Clique em Criar política de posição em grupo.

        O painel Criar uma política de posicionamento em grupo é exibido.

      2. Em Nome da política, digite um nome para a política.

      3. Clique em Criar.

        A criação da política de posicionamento compacto pode levar alguns segundos para ser concluída.

    • Caso contrário, selecione uma política de posicionamento compacto atual.

  10. Na seção Exclusão automática, é possível ativar a opção para permitir que o Compute Engine exclua automaticamente a reserva em uma data e hora específicas. A exclusão automática de reservas pode ser útil para evitar cobranças desnecessárias quando você para de consumir a reserva.

  11. Para criar a reserva, clique em Criar.

    A página Reservas abre. A criação da reserva pode levar até um minuto para ser concluída.

Especificar propriedades diretamente

Para criar uma reserva de projeto único especificando propriedades diretamente, selecione uma das seguintes opções:

Console

  1. No console do Google Cloud, acesse a página Reservas.

    Acessar "Reservas"

  2. Na guia Reservas on demand (padrão), clique em Criar reserva.

    A página Criar uma reserva é aberta.

  3. Em Nome, insira um nome para o provedor.

  4. Para Região e Zona, selecione onde você quer reservar recursos.

  5. Na seção Tipo de compartilhamento, clique em Local, caso ainda não esteja selecionado.

  6. Opcional: para permitir que uma reserva de VMs de GPU seja consumida por jobs de treinamento personalizado ou jobs de previsão na Vertex AI, na seção Serviços do Google Cloud, selecione Compartilhar reserva.

  7. Na seção Usar com instância de VM, selecione uma das seguintes opções:

    • Para permitir que VMs correspondentes consumam essa reserva automaticamente, selecione Usar reserva automaticamente, se ainda não estiver selecionado.

    • Para consumir os recursos desta reserva apenas ao criar VMs correspondentes que visam especificamente essa reserva por nome, clique em Selecionar reserva específica.

  8. Em Número de instâncias de VM, insira o número de VMs que você quer reservar.

  9. Na seção Configuração da máquina, selecione Especificar tipo de máquina e especifique o seguinte:

    1. Em Família de máquinas, Série e Tipo de máquina, selecione uma família, uma série e um tipo de máquina.

    2. Opcional: para especificar uma plataforma mínima de CPU ou anexar GPUs a VMs N1, faça o seguinte:

      1. Para expandir a seção Plataforma de CPU e GPU, clique na seta de expansão .

      2. Opcional: para especificar uma plataforma mínima de CPU, selecione uma opção em Plataforma de CPU.

      3. Opcional: para anexar GPUs a VMs N1, clique em Adicionar GPU. Em seguida, para Tipo de GPU e Número de GPUs, selecione o tipo e o número de GPUs a serem anexados a cada VM N1.

    3. Opcional: para adicionar discos SSD locais, faça o seguinte:

      1. Em Número de discos, selecione o número de discos SSD locais para cada VM.

      2. Em Tipo de interface, selecione a interface para os discos SSD locais.

    4. Opcional: para especificar uma política de posicionamento compacto para uma reserva que atenda aos requisitos, clique na lista Selecionar ou criar uma política de posição em grupo e faça uma das seguintes ações:

      • Para criar uma política de posicionamento compacto a ser especificada nessa reserva, siga estas etapas:

        1. Clique em Criar política de posição em grupo.

          O painel Criar uma política de posicionamento em grupo é exibido.

        2. Em Nome da política, digite um nome para a política.

        3. Clique em Criar.

          A criação da política de posicionamento compacto pode levar alguns segundos para ser concluída.

      • Caso contrário, selecione uma política de posicionamento compacto atual.

  10. Opcional: para especificar uma política de posicionamento compacto para uma reserva que atenda aos requisitos, na seção Política de posicionamento em grupo, clique na lista Selecionar ou criar uma política de posicionamento em grupo e faça uma das seguintes ações:

    • Para criar uma política de posicionamento compacta a ser especificada nessa reserva, faça o seguinte:

      1. Clique em Criar política de posição em grupo.

        O painel Criar uma política de posicionamento em grupo é exibido.

      2. Em Nome da política, digite um nome para a política.

      3. Clique em Criar.

        A criação da política de posicionamento compacto pode levar alguns segundos para ser concluída.

    • Caso contrário, selecione uma política de posicionamento compacto atual.

  11. Na seção Exclusão automática, é possível ativar a opção para permitir que o Compute Engine exclua automaticamente a reserva em uma data e hora específicas. A exclusão automática de reservas pode ser útil para evitar cobranças desnecessárias quando você para de consumir a reserva.

  12. Para criar a reserva, clique em Criar.

    A página Reservas abre. A criação da reserva de projeto único pode levar até um minuto para ser concluída.

gcloud

Para criar uma reserva de projeto único, use o comando gcloud compute reservations create.

Para criar uma reserva de projeto único especificando propriedades diretamente e sem incluir flags opcionais, execute o seguinte comando:

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

Substitua:

  • RESERVATION_NAME: o nome da reserva a ser criada.

  • MACHINE_TYPE: um tipo de máquina a ser usado em cada VM. Se você especificar um tipo de máquina A3, inclua a flag --require-specific-reservation. Isso indica que apenas VMs que segmentam especificamente a reserva podem efetivá-la. Para mais informações, consulte Efetivar VMs de uma reserva específica.

  • NUMBER_OF_VMS: o número de VMs a serem reservadas.

  • ZONE: a zona em que os recursos serão reservados.

Por exemplo, para criar uma reserva na zona us-central1-a para dez VMs, cada uma usando um tipo de máquina predefinido N2 com quatro vCPUs, execute o seguinte comando:

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

Também é possível realizar uma ou mais das seguintes ações:

  • Para anexar GPUs às VMs N1 reservadas, inclua a flag --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

    Substitua:

  • Para adicionar um ou mais discos SSD locais a cada VM reservada, inclua uma ou mais flags --local-ssd. É possível especificar até 24 discos SSD locais. Cada SSD local tem 375 GB.

    Por exemplo, para especificar dois discos SSD locais ao criar uma reserva, inclua duas flags --local-ssd da seguinte maneira:

    gcloud compute reservations create RESERVATION_NAME \
    --local-ssd=size=375,interface=INTERFACE_1 \
    --local-ssd=size=375,interface=INTERFACE_2 \
    --machine-type=MACHINE_TYPE \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

    Substitua INTERFACE_1 e INTERFACE_2 pelo tipo de interface que você quer que cada SSD local use. Especifique um dos seguintes valores:

    • Interfaces de disco NVME: nvme

    • Interfaces de disco SCSI: scsi

    Verifique se o tipo de máquina especificado para as VMs reservadas é compatível com as interfaces de disco escolhidas. Caso contrário, a criação da reserva falhará. Para mais informações, veja como escolher uma interface de disco.

  • Para que as VMs reservadas usem uma plataforma mínima de CPU específica, em vez da plataforma de CPU padrão da zona, inclua a flag --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

    Substitua MIN_CPU_PLATFORM por uma plataforma de CPU mínima. Para garantir que uma plataforma de CPU esteja disponível na zona em que você está reservando recursos, confira as plataformas de CPU disponíveis por zona.

  • Para especificar que apenas VMs que segmentam especificamente esta reserva podem consumi-la, inclua a flag --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 uma política de posicionamento compacto para menor latência de rede entre as VMs, inclua a flag --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

    Substitua COMPACT_PLACEMENT_POLICY_NAME pelo nome de uma política de posicionamento compacto atual. Além disso, para evitar erros ao criar uma reserva de projeto único que especifica uma política de posicionamento compacta, especifique o seguinte:

    • Um tipo de máquina com suporte e o número máximo de VMs para políticas de posicionamento compactas.

    • Uma zona dentro da região em que a política de posicionamento compacto está localizada.

    • A sinalização --require-specific-reservation Isso indica que apenas VMs que segmentam especificamente a reserva podem consumi-la.

  • Para permitir que uma reserva de VMs de GPU seja consumida por jobs de treinamento personalizado ou jobs de previsão na Vertex AI, use o comando gcloud beta compute reservations create com a flag --reservation-sharing-policy=ALLOW_ALL.

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

  • Para permitir que o Compute Engine exclua automaticamente a reserva, selecione um dos seguintes métodos:

    • Para excluir a reserva em uma data e hora específicas, use o comando gcloud beta compute reservations create com a flag --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

      Substitua DELETE_AT_TIME por uma data e hora formatadas como um carimbo de data/hora RFC 3339, que precisa ser o seguinte:

      YYYY-MM-DDTHH:MM:SSOFFSET

      Substitua:

      • YYYY-MM-DD: uma data formatada como um ano de quatro dígitos, um mês de dois dígitos e um dia de dois dígitos, separados por hífens (-).

      • HH:MM:SS: um horário formatado como uma hora de dois dígitos usando um horário de 24 horas, minutos de dois dígitos e segundos de dois dígitos, separados por dois pontos (:).

      • OFFSET: o fuso horário formatado como um ajuste de Tempo Universal Coordenado (UTC). Por exemplo, para usar o horário padrão do Pacífico (PST), especifique -08:00. Outra possibilidade é não usar ajuste: especifique Z.

    • Para excluir a reserva após uma duração específica, use o comando gcloud beta compute reservations create com a flag --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

      Substitua DELETE_AFTER_DURATION por uma duração em dias, horas, minutos ou segundos. Por exemplo, especifique 30m para 30 minutos ou 1d2h3m4s para 1 dia, 2 horas, 3 minutos e 4 segundos.

Go

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

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

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

	return nil
}

Java 

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

public class CreateReservation {

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

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

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

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

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

Node.js 

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

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

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

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

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

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

  let operation = response.latestResponse;

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

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

await callCreateComputeReservationFromProperties();

Python 

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

    # Create a client
    client = compute_v1.ReservationsClient()

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

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

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

    return reservation

Terraform

Para criar uma reserva de projeto único, use o recurso google_compute_reservation do Terraform.

Por exemplo, para criar uma reserva de projeto único para um tipo de máquina predefinido N2 com duas vCPUs, use o seguinte 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 mais informações sobre como usar o Terraform, consulte Como usar o Terraform com o Google Cloud.

REST

Para criar uma reserva de projeto único, faça uma solicitação POST para o método reservations.insert.

Para criar uma reserva de projeto único especificando propriedades diretamente e sem incluir campos opcionais, faça a seguinte solicitação 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"
    }
  }
}

Substitua:

  • PROJECT_ID: o ID do projeto em que você quer reservar recursos.

  • ZONE: a zona em que os recursos serão reservados.

  • RESERVATION_NAME: o nome da reserva a ser criada.

  • NUMBER_OF_VMS: o número de VMs a serem reservadas.

  • MACHINE_TYPE: um tipo de máquina a ser usado em cada VM. Se você especificar um tipo de máquina A3, inclua o campo specificReservationRequired no corpo da solicitação e defina-o como true. Isso indica que apenas VMs que segmentam especificamente a reserva podem consumi-la. Para mais informações, consulte Consumir VMs de uma reserva específica.

Por exemplo, para criar uma reserva na zona us-central1-a para dez VMs, cada uma usando um tipo de máquina predefinido N2 com quatro vCPUs, faça a seguinte solicitação 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",
    }
  }
}

Também é possível realizar uma ou mais das seguintes ações:

  • Para anexar GPUs às VMs N1 reservadas, inclua o campo guestAccelerators no corpo da solicitação.

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

    Substitua:

  • Para adicionar um ou mais discos SSD locais a cada VM reservada, inclua o campo localSsds no corpo da solicitação. É possível especificar até 24 discos SSD locais. Cada SSD local tem 375 GB.

    Por exemplo, para especificar dois discos SSD locais ao criar uma reserva, faça uma solicitação da seguinte maneira:

    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_1"
        },
        {
          "diskSizeGb": "375",
          "interface": "INTERFACE_2"
        }
      ],
      "machineType": "MACHINE_TYPE"
    }
  }
}

    Substitua INTERFACE_1 e INTERFACE_2 pelo tipo de interface que você quer que cada SSD local use. Especifique um dos seguintes valores:

    • Interfaces de disco NVME: NVME

    • Interfaces de disco SCSI: SCSI

    Verifique se o tipo de máquina especificado para as VMs reservadas é compatível com as interfaces de disco escolhidas. Caso contrário, a criação da reserva falhará. Para mais informações, veja como escolher uma interface de disco.

  • Para que as VMs reservadas usem uma plataforma mínima de CPU específica, em vez da plataforma de CPU padrão da zona, inclua o campo minCpuPlatform no corpo da solicitação.

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

    Substitua MIN_CPU_PLATFORM por uma plataforma de CPU mínima. Para garantir que uma plataforma de CPU esteja disponível na zona em que você está reservando recursos, confira as plataformas de CPU disponíveis por zona.

  • Para especificar uma política de posicionamento compacta e reduzir a latência de rede entre as VMs reservadas, inclua o campo resourcePolicies no corpo da solicitação.

    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
}

    Substitua:

    • REGION: a região em que a política de posicionamento compacto está localizada. Só é possível criar a reserva na região da política de posicionamento.

    • COMPACT_PLACEMENT_POLICY_NAME: o nome de uma política de posicionamento compacto.

    Além disso, para evitar erros ao criar uma reserva de projeto único que especifica uma política de posicionamento compacta, especifique o seguinte:

    • Um tipo de máquina compatível com políticas de posicionamento compacto.

    • O campo specificReservationRequired definido como true. Isso indica que apenas VMs que segmentam especificamente essa reserva podem consumi-la.

  • Para especificar que apenas VMs que segmentam especificamente esta reserva podem consumi-la, inclua o campo specificReservationRequired no corpo da solicitação e defina-o como 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 uma reserva de VMs de GPU seja consumida por jobs de treinamento personalizado ou jobs de previsão na Vertex AI, faça uma solicitação POST para o método beta.reservations.insert. No corpo da solicitação, inclua o campo serviceShareType e defina-o como ALLOW_ALL.

    POST https://compute.googleapis.com/compute/beta/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 o Compute Engine exclua automaticamente a reserva, selecione um dos seguintes métodos:

    • Para excluir a reserva em uma data e hora específicas, faça uma solicitação POST para o método beta.reservations.insert. No corpo da solicitação, inclua o 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"
    }
  }
}

      Substitua DELETE_AT_TIME por uma data e hora formatadas como um carimbo de data/hora RFC 3339, que precisa ser o seguinte:

      YYYY-MM-DDTHH:MM:SSOFFSET

      Substitua:

      • YYYY-MM-DD: uma data formatada como um ano de quatro dígitos, um mês de dois dígitos e um dia de dois dígitos, separados por hífens (-).

      • HH:MM:SS: um horário formatado como uma hora de dois dígitos usando um horário de 24 horas, minutos de dois dígitos e segundos de dois dígitos, separados por dois pontos (:).

      • OFFSET: o fuso horário formatado como um ajuste de Tempo Universal Coordenado (UTC). Por exemplo, para usar o horário padrão do Pacífico (PST), especifique -08:00. Outra possibilidade é não usar ajuste: especifique Z.

    • Para excluir a reserva após uma duração específica, faça uma solicitação POST para o método beta.reservations.insert. No corpo da solicitação, inclua o 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"
    }
  }
}

      Substitua DELETE_AFTER_DURATION por uma duração em segundos. Por exemplo, especifique 86400 para 86.400 segundos (1 dia).

Solução de problemas

Saiba como resolver problemas de criação de reserva.

A seguir