Crie uma reserva para um único projeto

Este documento explica como criar uma reserva de projeto único, que só pode ser consumida por instâncias de máquinas virtuais (VMs) no mesmo projeto. Para saber mais sobre as reservas, consulte o artigo Reservas de recursos zonais do Compute Engine.

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

  • Para criar uma reserva que possa ser usada por vários projetos, consulte o artigo Crie uma reserva partilhada.

  • Para criar uma reserva quando comprar um compromisso baseado em recursos, consulte o artigo Compre compromissos com reservas anexadas. Os compromissos oferecem descontos, conhecidos como descontos de fidelidade (CUDs), nos custos de recursos a pedido em troca da compra de um nível mínimo de recursos ou de gastar um valor mínimo.

Antes de começar

  • Reveja os requisitos e as restrições para reservas.
  • Se ainda não o tiver feito, configure a autenticação. A autenticação valida a sua identidade para aceder a Google Cloud serviços e APIs. Para executar código ou exemplos a partir de um ambiente de desenvolvimento local, pode autenticar-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. Instale a CLI Google Cloud. Após a instalação, inicialize a CLI gcloud executando o seguinte comando: 

      gcloud init

      Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

    2. Set a default region and zone.

    Terraform

    Para usar os exemplos do Terraform nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as credenciais predefinidas da aplicação com as suas credenciais de utilizador.

      Instale a CLI Google Cloud.

      Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

      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.

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

    Para mais informações, consulte Set up authentication for a local development environment.

    REST

    Para usar os exemplos da API REST nesta página num ambiente de desenvolvimento local, usa as credenciais que fornece à CLI gcloud.

      Instale a CLI Google Cloud.

      Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

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

Funções necessárias

Para receber as autorizações de que precisa para criar reservas de projeto único, peça ao seu administrador para lhe conceder a função de IAM Administrador de computação (roles/compute.admin) no projeto. Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Esta função predefinida contém as autorizações necessárias para criar reservas de projeto único. Para ver as autorizações exatas que são necessárias, expanda a secção Autorizações necessárias:

Autorizações necessárias

São necessárias as seguintes autorizações 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

Também pode conseguir estas autorizações com funções personalizadas ou outras funções predefinidas.

Crie uma reserva de projeto único

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

  • Recomendado: Especifique um modelo de instância

    Esta secção explica como usar um modelo de instância para definir as propriedades de uma reserva. Ao usar um modelo de instância, pode definir as propriedades de uma reserva e as VMs que podem consumir a reserva no mesmo local.

  • Especifique uma VM existente

    Esta secção explica como usar uma VM existente para definir as propriedades de uma reserva. Ao usar as propriedades de uma VM existente, pode consumir a reserva criando VMs com propriedades que correspondam à VM de referência.

  • Especifique propriedades diretamente

    Esta secção explica como definir diretamente as propriedades de uma reserva. Este método requer que se certifique manualmente de que as propriedades das suas VMs e reservas correspondem exatamente. Quaisquer propriedades que não correspondam impedem o consumo.

Por predefinição, uma reserva pode ser consumida automaticamente por quaisquer VMs com propriedades que correspondam à mesma. Se quiser controlar o consumo de reservas, faça uma ou mais das seguintes ações:

Além disso, pode especificar uma política de posicionamento compacta quando cria uma reserva específica de um único projeto. Uma política de posicionamento compacta especifica que as VMs devem estar localizadas o mais perto possível umas das outras para reduzir a latência da rede.

Especifique um modelo de instância

Para evitar erros ao criar uma reserva especificando um modelo de instância, certifique-se do seguinte:

  • Crie a sua reserva na mesma região e zona que os recursos no modelo de instância. Todos os recursos regionais ou zonais especificados num modelo de instância, como um tipo de máquina ou um volume de disco persistente, restringem a utilização do modelo às localizações onde esses recursos existem. Por exemplo, se o modelo de instância especificar um volume de disco persistente existente na zona us-central1-a, só pode criar a reserva na mesma zona. Para verificar se um modelo existente especifica recursos que associam o modelo a uma região ou uma zona específica, veja os detalhes do modelo de instância e procure referências a recursos regionais ou zonais no respetivo interior.

  • Se o modelo de instância especificar uma política de posicionamento compacta, certifique-se de que o modelo especifica um tipo de máquina suportado para políticas de posicionamento compactas. Caso contrário, a criação da reserva falha.

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

Consola

  1. Na Google Cloud consola, aceda à página Reservas.

    Aceda a Reservas

  2. No separador Reservas a pedido (predefinição), clique em Criar reserva.

    É apresentada a página Criar uma reserva.

  3. Em Nome, introduza um nome para a reserva.

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

  5. Na secção Tipo de partilha, selecione Local se esta opção ainda não estiver selecionada.

  6. Opcional: para permitir que uma reserva de VMs de GPU seja consumida por tarefas de preparação personalizadas ou tarefas de previsão no Vertex AI, na secção Serviços Google Cloud, selecione Partilhar reserva.

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

    • Para permitir que as VMs correspondentes consumam automaticamente esta reserva, selecione Usar reserva automaticamente se ainda não estiver selecionada.

    • Para consumir os recursos desta reserva apenas quando criar VMs correspondentes que segmentem especificamente esta reserva por nome, selecione Selecionar reserva específica.

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

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

    1. Para especificar as propriedades das VMs a partir de um modelo de instância existente, selecione Usar modelo de instância.

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

  10. Na secção Eliminação automática, pode ativar a opção de eliminação automática para permitir que o Compute Engine elimine automaticamente a reserva numa data e hora específicas. A eliminação automática de reservas pode ser útil para evitar cobranças desnecessárias quando deixa de consumir a reserva.

  11. Para criar a reserva, clique em Criar.

    É apresentada a página Reservas. A criação da reserva de projeto único pode demorar até um minuto.

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 o seguinte:

  • RESERVATION_NAME: o nome da reserva a criar.

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

  • LOCATION: a localização 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 onde o modelo de instância está localizado. Se especificar um modelo de instância regional, só pode reservar VMs na mesma região que a região do modelo.

  • INSTANCE_TEMPLATE_NAME: o nome de um modelo de instância existente. Se o modelo de instância especificar um tipo de máquina A3 Mega, A3 High ou A3 Edge, ou uma política de posicionamento compacta, tem de incluir a flag --require-specific-reservation. Isto indica que apenas as VMs que segmentam especificamente a reserva podem consumi-la. Para mais informações, consulte o artigo Consuma VMs de uma reserva específica.

  • NUMBER_OF_VMS: o número de VMs a reservar.

  • ZONE: a zona na qual reservar recursos.

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

Opcionalmente, pode fazer uma ou mais das seguintes ações:

  • Para especificar que apenas as VMs que segmentam especificamente esta reserva a podem consumir, 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 tarefas de preparação personalizadas ou tarefas de previsão no Vertex AI, inclua a flag --reservation-sharing-policy definida como 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 o Compute Engine elimine automaticamente a reserva, selecione um dos seguintes métodos:

    • Para eliminar a reserva numa 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 uma hora formatadas como uma data/hora RFC 3339, que tem de ser da seguinte forma: none YYYY-MM-DDTHH:MM:SSOFFSET

      Substitua o seguinte:

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

      • HH:MM:SS: uma hora formatada como uma hora de 2 dígitos com um formato de 24 horas, minutos de 2 dígitos e segundos de 2 dígitos, separados por dois pontos (:).

      • OFFSET: o fuso horário formatado como um desvio de Tempo Universal Coordenado (UTC). Por exemplo, para usar a Hora Padrão do Pacífico (PST), especifique -08:00. Em alternativa, para não usar nenhum desvio, especifique Z.

    • Para eliminar 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.

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);
    }
  }
}

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 um pedido POST ao método reservations.insert.

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

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

  • ZONE: a zona na qual reservar recursos.

  • RESERVATION_NAME: o nome da reserva a criar.

  • NUMBER_OF_VMS: o número de VMs a reservar.

  • LOCATION: a localização 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 onde o modelo de instância está localizado. Se especificar um modelo de instância regional, só pode reservar VMs na mesma região que a região do modelo.

  • INSTANCE_TEMPLATE_NAME: o nome de um modelo de instância existente. Se o modelo de instância especificar um tipo de máquina A3 Mega, A3 High ou A3 Edge, ou uma política de posicionamento compacta, tem de incluir o campo specificReservationRequired no corpo do pedido e defini-lo como true. Isto indica que apenas as VMs que segmentam especificamente esta reserva a podem consumir. Para mais informações, consulte o artigo Consuma VMs de uma reserva específica.

Por exemplo, para criar uma reserva para dez VMs na zona us-central1-a, especifique um modelo de instância global e faça o seguinte pedido 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, pode fazer uma ou mais das seguintes ações:

  • Para especificar que apenas as VMs que segmentam especificamente esta reserva a podem usar, inclua o campo specificReservationRequired no corpo do pedido e defina o campo 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 tarefas de preparação personalizadas ou tarefas de previsão no Vertex AI, inclua o campo serviceShareType e defina-o como 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 o Compute Engine elimine automaticamente a reserva, selecione um dos seguintes métodos:

    • Para eliminar a reserva numa data e hora específicas, faça um POST pedido ao métodobeta.reservations.insert. No corpo do pedido, 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 uma hora formatadas como uma data/hora RFC 3339, que tem de ser a seguinte:

      YYYY-MM-DDTHH:MM:SSOFFSET

      Substitua o seguinte:

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

      • HH:MM:SS: uma hora formatada como uma hora de 2 dígitos com um formato de 24 horas, minutos de 2 dígitos e segundos de 2 dígitos, separados por dois pontos (:).

      • OFFSET: o fuso horário formatado como um desvio de Tempo Universal Coordenado (UTC). Por exemplo, para usar a Hora Padrão do Pacífico (PST), especifique -08:00. Em alternativa, para não usar nenhum desvio, especifique Z.

    • Para eliminar a reserva após uma duração específica, faça um POST pedido ao método.beta.reservations.insert No corpo do pedido, 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).

Especifique uma VM existente

Só pode criar uma reserva com base numa VM existente na mesma zona que a VM.

Depois de criar a reserva, pode consumi-la criando VMs com propriedades que correspondam à VM de referência. Pode fazê-lo através de uma das seguintes ações:

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

  1. Na Google Cloud consola, aceda à página Reservas.

    Aceda a Reservas

  2. Clique em Criar reserva.

    É apresentada a página Criar uma reserva.

  3. Em Nome, introduza um nome para a reserva.

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

  5. Na secção Tipo de partilha, clique em Local se esta opção ainda não estiver selecionada.

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

    • Para permitir que as VMs correspondentes consumam automaticamente esta reserva, selecione Usar reserva automaticamente, se ainda não estiver selecionada.

    • Para consumir os recursos desta reserva apenas quando criar VMs correspondentes que segmentem especificamente esta reserva por nome, selecione Selecionar reserva específica.

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

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

    1. Selecione Usar VM existente.

    2. Para VM existente, selecione a VM cujas propriedades quer usar para criar a reserva.

  9. Opcional: para especificar uma política de posicionamento compacta para uma reserva que cumpra os requisitos, na secção Política de posicionamento de grupo, clique na lista Selecionar ou criar uma política de posicionamento de grupo e, de seguida, faça uma das seguintes ações:

    • Para criar uma política de posicionamento compacta a especificar nesta reserva, faça o seguinte:

      1. Clique em Criar política de posicionamento de grupos.

        É apresentado o painel Crie uma política de posicionamento de grupos.

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

      3. Clique em Criar.

        A criação da política de posicionamento compacta pode demorar alguns segundos a ser concluída.

    • Caso contrário, selecione uma política de posicionamento compacta existente.

  10. Na secção Eliminação automática, pode ativar a opção de eliminação automática para permitir que o Compute Engine elimine automaticamente a reserva numa data e hora específicas. A eliminação automática de reservas pode ser útil para evitar cobranças desnecessárias quando deixa de consumir a reserva.

  11. Para criar a reserva, clique em Criar.

    É apresentada a página Reservas. A criação da reserva pode demorar até um minuto.

Especifique as propriedades diretamente

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

Consola

  1. Na Google Cloud consola, aceda à página Reservas.

    Aceda a Reservas

  2. No separador Reservas a pedido (predefinição), clique em Criar reserva.

    É apresentada a página Criar uma reserva.

  3. Em Nome, introduza um nome para a reserva.

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

  5. Na secção Tipo de partilha, clique em Local se esta opção ainda não estiver selecionada.

  6. Opcional: para permitir que uma reserva de VMs de GPU seja consumida por tarefas de preparação personalizadas ou tarefas de previsão no Vertex AI, na secção Serviços Google Cloud, selecione Partilhar reserva.

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

    • Para permitir que as VMs correspondentes consumam automaticamente esta reserva, selecione Usar reserva automaticamente se ainda não estiver selecionada.

    • Para consumir os recursos desta reserva apenas quando criar VMs correspondentes que segmentem especificamente esta reserva por nome, selecione Selecionar reserva específica.

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

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

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

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

      1. Para expandir a secção Plataforma de CPU e GPU, clique na seta do expansor.

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

      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 associar a cada VM N1.

  10. Opcional: para associar discos SSD local a um tipo de máquina que não inclui discos SSD local por predefinição, faça o seguinte:

    1. Para Número de discos, selecione o número de discos SSD locais a anexar.

    2. Para Tipo de interface, selecione a interface de disco para os discos SSD local.

  11. Opcional: para especificar uma política de posicionamento compacta para uma reserva que cumpra os requisitos, na secção Política de posicionamento de grupo, clique na lista Selecionar ou criar uma política de posicionamento de grupo e, de seguida, faça uma das seguintes ações:

    • Para criar uma política de posicionamento compacta a especificar nesta reserva, faça o seguinte:

      1. Clique em Criar política de posicionamento de grupos.

        É apresentado o painel Crie uma política de posicionamento de grupos.

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

      3. Clique em Criar.

        A criação da política de posicionamento compacta pode demorar alguns segundos a ser concluída.

    • Caso contrário, selecione uma política de posicionamento compacta existente.

  12. Na secção Eliminação automática, pode ativar a opção de eliminação automática para permitir que o Compute Engine elimine automaticamente a reserva numa data e hora específicas. A eliminação automática de reservas pode ser útil para evitar cobranças desnecessárias quando deixa de consumir a reserva.

  13. Para criar a reserva, clique em Criar.

    É apresentada a página Reservas. A criação da reserva de projeto único pode demorar até um minuto.

gcloud

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

Para criar uma reserva de projeto único especificando as 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 o seguinte:

  • RESERVATION_NAME: o nome da reserva a criar.

  • MACHINE_TYPE: um tipo de máquina a usar para cada VM. Se especificar um tipo de máquina A3 Mega, A3 High ou A3 Edge, tem de incluir a flag --require-specific-reservation. Isto indica que apenas as VMs que segmentam especificamente a reserva podem consumi-la. Para mais informações, consulte o artigo Consuma VMs de uma reserva específica.

  • NUMBER_OF_VMS: o número de VMs a reservar.

  • ZONE: a zona na qual reservar recursos.

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

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

Opcionalmente, pode fazer uma ou mais das seguintes ações:

  • Para anexar GPUs às suas 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 o seguinte:

  • Para anexar discos SSD local a um tipo de máquina que não inclui discos SSD local por predefinição, inclua a flag --local-ssd. Só pode anexar discos SSD locais 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

    Substitua o seguinte:

    • NUMBER_OF_LOCAL_SSD_DISKS: o número de discos SSD locais a anexar.

    • INTERFACE_TYPE: o tipo de interface de disco que quer que cada disco SSD local use e que o tipo de máquina especificado suporta. Especifique um dos seguintes valores:

      • Para a interface de disco NVME: nvme

      • Para a interface de disco SCSI: scsi

  • Para que as VMs reservadas usem uma plataforma de CPU mínima específica, em vez da plataforma de CPU predefinida da zona, inclua o sinalizador --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 se certificar de que uma plataforma de CPU está disponível na zona onde está a reservar recursos, veja as plataformas de CPU disponíveis por zona.

  • Para especificar que apenas as VMs que segmentam especificamente esta reserva a podem consumir, 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 compacta para uma latência de rede mais baixa entre 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 compacta existente. Além disso, para evitar erros ao criar uma reserva de projeto único que especifique uma política de posicionamento compacta, certifique-se de que especifica o seguinte:

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

    • Uma zona na região onde a política de posicionamento compacta está localizada.

    • A bandeira de --require-specific-reservation. Isto indica que apenas as VMs que segmentam especificamente a reserva podem consumi-la.

  • Para permitir que uma reserva de VMs de GPU seja consumida por tarefas de preparação personalizadas ou tarefas de previsão no Vertex AI, inclua a flag --reservation-sharing-policy definida como 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 o Compute Engine elimine automaticamente a reserva, selecione um dos seguintes métodos:

    • Para eliminar a reserva numa 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 uma hora formatadas como uma data/hora RFC 3339, que tem de ser a seguinte:

      YYYY-MM-DDTHH:MM:SSOFFSET

      Substitua o seguinte:

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

      • HH:MM:SS: uma hora formatada como uma hora de 2 dígitos com um formato de 24 horas, minutos de 2 dígitos e segundos de 2 dígitos, separados por dois pontos (:).

      • OFFSET: o fuso horário formatado como um desvio de Tempo Universal Coordenado (UTC). Por exemplo, para usar a Hora Padrão do Pacífico (PST), especifique -08:00. Em alternativa, para não usar nenhum desvio, especifique Z.

    • Para eliminar 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.

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);
    }
  }
}

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 do Terraform google_compute_reservation.

Por exemplo, para criar uma reserva de projeto único para um tipo de máquina predefinido N2 com 2 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 o artigo Usar o Terraform com Google Cloud.

REST

Para criar uma reserva de projeto único, faça um pedido POST ao método reservations.insert.

Para criar uma reserva de projeto único especificando propriedades diretamente e sem incluir campos opcionais, faça o seguinte POST pedido:

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 o seguinte:

  • PROJECT_ID: o ID do projeto onde quer reservar recursos.

  • ZONE: a zona na qual reservar recursos.

  • RESERVATION_NAME: o nome da reserva a criar.

  • NUMBER_OF_VMS: o número de VMs a reservar.

  • MACHINE_TYPE: um tipo de máquina a usar para cada VM. Se especificar um tipo de máquina A3 Mega, A3 High ou A3 Edge, tem de incluir o campo specificReservationRequired no corpo do pedido e definir o campo como true. Isto indica que apenas as VMs que segmentam especificamente a reserva podem consumi-la. Para mais informações, consulte o artigo Consuma VMs de uma reserva específica.

Por exemplo, para criar uma reserva na zona us-central1-a para dez VMs que usam cada uma um tipo de máquina predefinido N2 com 4 vCPUs, faça o seguinte pedido 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, pode fazer uma ou mais das seguintes ações:

  • Para anexar GPUs às suas VMs N1 reservadas, inclua o campo guestAccelerators no corpo do pedido.

    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 o seguinte:

  • Para associar discos SSD locais a um tipo de máquina que não inclui discos SSD locais por predefinição, inclua o campo localSsds no corpo do pedido. Só pode anexar discos SSD locais de 375 GB.

    Por exemplo, para associar dois discos SSD locais ao tipo de máquina que quer reservar, faça um pedido da seguinte forma:

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

    Substitua INTERFACE_TYPE pelo tipo de interface de disco que quer que cada disco SSD local use e que o tipo de máquina especificado suporta. Especifique um dos seguintes valores:

    • Para a interface de disco NVME: NVME

    • Para a interface de disco SCSI: SCSI

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

    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 se certificar de que uma plataforma de CPU está disponível na zona onde está a reservar recursos, veja as plataformas de CPU disponíveis por zona.

  • Para especificar uma política de posicionamento compacta para reduzir a latência da rede entre as suas VMs reservadas, inclua o campo resourcePolicies no corpo do pedido.

    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 o seguinte:

    • REGION: a região onde se encontra a política de posicionamento compacto. Só pode criar a reserva na região da política de posicionamento.

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

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

    • Um tipo de máquina suportado para políticas de posicionamento compactas.

    • O campo specificReservationRequired está definido como true. Isto indica que apenas as VMs que segmentam especificamente esta reserva a podem consumir.

  • Para especificar que apenas as VMs que segmentam especificamente esta reserva a podem usar, inclua o campo specificReservationRequired no corpo do pedido e defina o campo 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 tarefas de preparação personalizadas ou tarefas de previsão no Vertex AI, inclua o campo serviceShareType e defina-o como 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 o Compute Engine elimine automaticamente a reserva, selecione um dos seguintes métodos:

    • Para eliminar a reserva numa data e hora específicas, faça um POST pedido ao métodobeta.reservations.insert. No corpo do pedido, 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 uma hora formatadas como uma data/hora RFC 3339, que tem de ser a seguinte:

      YYYY-MM-DDTHH:MM:SSOFFSET

      Substitua o seguinte:

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

      • HH:MM:SS: uma hora formatada como uma hora de 2 dígitos com um formato de 24 horas, minutos de 2 dígitos e segundos de 2 dígitos, separados por dois pontos (:).

      • OFFSET: o fuso horário formatado como um desvio de Tempo Universal Coordenado (UTC). Por exemplo, para usar a Hora Padrão do Pacífico (PST), especifique -08:00. Em alternativa, para não usar nenhum desvio, especifique Z.

    • Para eliminar a reserva após uma duração específica, faça um POST pedido ao método.beta.reservations.insert No corpo do pedido, 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).

Resolução de problemas

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

O que se segue?