Criar uma reserva compartilhada

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Console

Siga as etapas em Como visualizar políticas da organização usando a restrição Projetos de proprietário de reservas compartilhadas.

gcloud

Para ver quais projetos a restrição compute.sharedReservationsOwnerProjects permite criar e modificar reservas compartilhadas:

1. Faça o download da política da sua organização como um arquivo chamado policy.yaml, usando o comando gcloud resource-manager org-policies describe:

   gcloud resource-manager org-policies describe compute.sharedReservationsOwnerProjects --organization=ORGANIZATION_ID > policy.yaml
   

   Substitua ORGANIZATION_ID pelo ID da organização.

2. Use um editor de texto para abrir o arquivo policy.yaml e ver a restrição compute.sharedReservationsOwnerProjects. Os projetos que têm permissão para criar e modificar reservas compartilhadas estão listados em allowedValues:

   ...
   constraint: constraints/compute.sharedReservationsOwnerProjects
   listPolicy:
     allowedValues:
     - projects/PROJECT_NUMBER_1
     - projects/PROJECT_NUMBER_2
     - projects/PROJECT_NUMBER_3
   ...
   

   em que PROJECT_NUMBER_1, PROJECT_NUMBER_2 e PROJECT_NUMBER_3 são os números de projeto dos únicos projetos da organização que têm permissão para criar reservas compartilhadas.

3. Opcional: exclua o arquivo policy.yaml.

   • Se você estiver usando um terminal Linux ou macOS, use o seguinte comando:

     rm policy.yaml
     

   • Se você estiver usando um terminal do Windows, use o seguinte comando:

     del policy.yaml
     

Console

Siga as etapas em Como personalizar políticas para restrições de lista usando a restrição Projetos de proprietário de reservas compartilhadas.

gcloud

Para editar quais projetos a restrição compute.sharedReservationsOwnerProjects permite criar e modificar reservas compartilhadas, use um dos seguintes métodos:

• Para conceder permissão a um único projeto para criar e modificar reservas compartilhadas, use o comando gcloud resource-manager org-policies allow. Repita esse comando para cada projeto ao qual quer conceder essa permissão.

  gcloud resource-manager org-policies allow compute.sharedReservationsOwnerProjects projects/PROJECT_NUMBER \
      --organization=ORGANIZATION_ID
  

  Substitua:

  • PROJECT_NUMBER: o número do projeto (não o ID) de um projeto na organização que você quer permitir para criar e modificar reservas compartilhadas.
  • ORGANIZATION_ID: o ID da organização.

• Para conceder ou revogar as permissões de vários projetos para criar e modificar reservas compartilhadas, substitua a restrição da política da organização:

  1. Para fazer o download da política da sua organização como um arquivo chamado policy.yaml, use o comando gcloud resource-manager org-policies describe:

     gcloud resource-manager org-policies describe compute.sharedReservationsOwnerProjects --organization=ORGANIZATION_ID > policy.yaml
     

     Substitua ORGANIZATION_ID pelo ID da organização.

  2. Use um editor de texto para modificar o arquivo policy.yaml para que a restrição compute.sharedReservationsOwnerProjects liste todos os projetos que podem ter permissão para criar e modificar reservas compartilhadas em allowedValues.

     • Para cada projeto que receber permissão para criar e modificar reservas compartilhadas, adicione o projeto a uma nova linha em allowedValues.
     • Para cada projeto que tiver permissão revogada para criar e modificar reservas compartilhadas, exclua a linha desse projeto.

     Ao terminar, verifique se o arquivo policy.yaml fica parecido com o seguinte:

     ...
     constraint: constraints/compute.sharedReservationsOwnerProjects
     listPolicy:
       allowedValues:
       - projects/PROJECT_NUMBER_1
       - projects/PROJECT_NUMBER_2
       - projects/PROJECT_NUMBER_3
     ...
     

     em que PROJECT_NUMBER_1, PROJECT_NUMBER_2 e PROJECT_NUMBER_3 são os números (não os IDs) de todos os projetos em sua organização que você quer que crie e modifique reservas compartilhadas.

  3. Salve o arquivo policy.yaml e feche o editor.

  4. Para atualizar a política da organização com as alterações, use o comando gcloud resource-manager org-policies set-policy:

     gcloud resource-manager org-policies set-policy --organization=ORGANIZATION_ID policy.yaml
     

     Substitua ORGANIZATION_ID pelo ID da organização.

  5. Opcional: exclua o arquivo policy.yaml.

     • Se você estiver usando um terminal Linux ou macOS, use o seguinte comando:

       rm policy.yaml
       

     • Se você estiver usando um terminal do Windows, use o seguinte comando:

       del policy.yaml
       

Console

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

   Acessar "Reservas"

   A página Reservas é exibida.

2. Clique em add_box Criar reserva.

   A página Criar uma reserva será exibida.

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

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

5. Na seção Tipo de compartilhamento, faça o seguinte:

   1. Para especificar uma reserva compartilhada, clique em Compartilhada.

   2. Clique em add Adicionar projetos e selecione os projetos da organização com que você quer compartilhar a reserva. É possível selecionar até 100 projetos.

6. Opcional: para permitir que uma reserva de VMs 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 instâncias de VM correspondentes usem 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 Usar modelo de instância e escolha o modelo de instância de sua preferência. Se você selecionar um modelo de instância regional, só poderá reservar na mesma região que a do modelo.

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 compartilhada pode levar até um minuto para ser concluída.

gcloud

Para criar uma reserva compartilhada, use o comando gcloud compute reservations create com as sinalizações --share-setting=projects e --share-with.

Para criar uma reserva compartilhada especificando um modelo de instância sem flags opcionais, execute o seguinte comando:

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

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.

• CONSUMER_PROJECT_IDS: uma lista separada por vírgulas de IDs de projetos que podem consumir essa reserva, por exemplo, project-1,project-2. É possível incluir até 100 projetos pessoais. Esses projetos precisam estar na mesma organização do projeto de proprietário. Não inclua o projeto proprietário. Por padrão, a reserva já pode ser efetivada.

• 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 Mega, A3 High ou A3 Edge, 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 especificando um modelo de instância global na zona us-central1-a, compartilhe a reserva com os projetos project-1 e project-2 e reserve dez VMs que usam um tipo de máquina predefinido N2 com quatro vCPUs, execute o seguinte comando:

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

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 \
      --require-specific-reservation \
      --share-setting=projects \
      --share-with=CONSUMER_PROJECT_IDS \
      --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
      --vm-count=NUMBER_OF_VMS \
      --zone=ZONE
  

• Para permitir que uma reserva de VMs de GPU seja consumida por jobs de treinamento personalizado ou jobs de previsão na Vertex AI, inclua a flag --reservation-sharing-policy definida como ALLOW_ALL.

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

• Para permitir que 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 \
        --share-setting=projects \
        --share-with=CONSUMER_PROJECT_IDS \
        --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
        --vm-count=NUMBER_OF_VMS \
        --zone=ZONE
    

    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 \
        --share-setting=projects \
        --share-with=CONSUMER_PROJECT_IDS \
        --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
        --vm-count=NUMBER_OF_VMS \
        --zone=ZONE
    

    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"

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

// Creates shared reservation from given template in particular zone
func createSharedReservation(w io.Writer, client ClientInterface, projectID, baseProjectId, zone, reservationName, sourceTemplate string) error {
	// client, err := compute.NewReservationsRESTClient(ctx)
	// projectID := "your_project_id". Destination of sharing.
	// baseProjectId := "your_project_id2". Project where the reservation will be created.
	// zone := "us-west3-a"
	// reservationName := "your_reservation_name"
	// sourceTemplate: existing template path. Following formats are allowed:
	//  	- projects/{project_id}/global/instanceTemplates/{template_name}
	//  	- projects/{project_id}/regions/{region}/instanceTemplates/{template_name}
	//  	- https://www.googleapis.com/compute/v1/projects/{project_id}/global/instanceTemplates/instanceTemplate
	//  	- https://www.googleapis.com/compute/v1/projects/{project_id}/regions/{region}/instanceTemplates/instanceTemplate

	ctx := context.Background()

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

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

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

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

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

	return nil
}

Java

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

public class CreateSharedReservation {

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

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

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

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (ReservationsClient reservationsClient = ReservationsClient.create()) {
      ShareSettings shareSettings = ShareSettings.newBuilder()
              .setShareType(String.valueOf(ShareSettings.ShareType.SPECIFIC_PROJECTS))
              // The IDs of projects that can consume this reservation. You can include up to
              // 100 consumer projects. These projects must be in the same organization as
              // the owner project. Don't include the owner project.
              // By default, it is already allowed to consume the reservation.
              .putProjectMap("CONSUMER_PROJECT_1", ShareSettingsProjectConfig.newBuilder().build())
              .putProjectMap("CONSUMER_PROJECT_2", ShareSettingsProjectConfig.newBuilder().build())
              .build();

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

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

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

      if (response.hasError()) {
        throw new Error("Reservation creation failed!!" + response);
      }
      return response.getStatus();
    }
  }
}

Node.js

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

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

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

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

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

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

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

  let operation = response.latestResponse;

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

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

return await callCreateComputeSharedReservation();

Python

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

    # Create a client
    client = compute_v1.ReservationsClient()

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

    reservation = client.get(
        project=project_id, zone=zone, reservation=reservation_name
    )
    shared_project = next(iter(reservation.share_settings.project_map.values()))

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

    return reservation

REST

Para criar uma reserva compartilhada, faça uma solicitação POST para o método reservations.insert. No corpo da solicitação, inclua o seguinte:

• O campo projectMap.

• O campo shareType definido como SPECIFIC_PROJECTS.

Por exemplo, para criar uma reserva compartilhada especificando um modelo de instância sem incluir campos opcionais e compartilhar a reserva com dois projetos de consumidor, faça a seguinte solicitação POST:

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

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

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.

• CONSUMER_PROJECT_ID_1 e CONSUMER_PROJECT_ID_2: os IDs do projeto que podem consumir essa reserva. É possível incluir até 100 projetos pessoais. Esses projetos precisam estar na mesma organização do projeto de proprietário. Não inclua o projeto proprietário. Por padrão, ele já pode consumir a reserva.

• 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 Mega, A3 High ou A3 Edge, 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 e compartilhar a reserva com os projetos project-1 e project-2, faça a solicitação POST a seguir:

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

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

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.

  Por exemplo, para criar uma reserva específica especificando um modelo de instância e compartilhar a reserva com dois projetos de consumidor, faça uma solicitação da seguinte maneira:

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

• Para permitir que uma reserva de VMs GPU seja consumida por jobs de treinamento personalizado ou jobs de previsão na Vertex AI, inclua o campo serviceShareType e defina como ALLOW_ALL.

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

• Para permitir que 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.

    Por exemplo, para criar uma reserva especificando um modelo de instância, excluir automaticamente a reserva em uma data e hora específicas e compartilhar a reserva com dois projetos de consumidor, faça uma solicitação da seguinte maneira:

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

    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.

    Por exemplo, para criar uma reserva especificando um modelo de instância, excluir automaticamente a reserva após um período específico e compartilhar a reserva com dois projetos de consumidor, faça uma solicitação da seguinte maneira:

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

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

Console

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

   Acessar "Reservas"

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

3. Clique em add_box Criar reserva.

   A página Criar uma reserva será exibida.

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

5. Em Região e Zona, selecione onde você quer reservar recursos.

6. Na seção Tipo de compartilhamento, faça o seguinte:

   1. Para especificar uma reserva compartilhada, clique em Compartilhada.

   2. Clique em add Adicionar projetos e selecione os projetos da organização com que você quer compartilhar a reserva. É possível selecionar até 100 projetos.

7. Opcional: para permitir que uma reserva de VMs 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.

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

   • Permitir que VMs correspondentes efetivem essa reserva automaticamente. Clique em Usar reserva automaticamente (padrão).

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

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

10. 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 expand_more.

       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 add 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 anexar discos SSD locais a um tipo de máquina que não inclui discos SSD locais por padrão, faça o seguinte:

       1. Em Número de discos, selecione o número de discos SSD locais a serem conectados.

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

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 compartilhada pode levar até um minuto para ser concluída.

gcloud

Para criar uma reserva compartilhada, use o comando gcloud compute reservations create com as sinalizações --share-setting=projects e --share-with.

Para criar uma reserva compartilhada especificando propriedades diretamente e sem incluir flags opcionais, execute o seguinte comando:

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

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 Mega, A3 High ou A3 Edge, 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.

• CONSUMER_PROJECT_IDS: uma lista separada por vírgulas de IDs de projetos que podem consumir essa reserva, por exemplo, project-1,project-2. É possível incluir até 100 projetos pessoais. Esses projetos precisam estar na mesma organização do projeto de proprietário. Não inclua o projeto proprietário. Por padrão, ele já é permitido para consumir a reserva.

• 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 4 vCPUs, e compartilhar a reserva com os projetos project-1 e project-2, execute o seguinte comando:

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

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

  Substitua:

  • NUMBER_OF_ACCELERATORS: o número de GPUs a serem adicionadas por VM reservada.

  • ACCELERATOR_TYPE: um modelo de GPU com suporte para VMs N1. Verifique se o modelo de GPU escolhido está disponível na zona em que você quer reservar recursos. Caso contrário, a criação da reserva falhará.

• Para anexar discos SSD locais a um tipo de máquina que não inclui discos SSD locais por padrão, inclua a flag --local-ssd. Só é possível 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:

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

  • INTERFACE_TYPE: o tipo de interface do disco que você quer que cada disco SSD local use e que seu tipo de máquina especificado ofereça suporte. 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 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" \
      --share-setting=projects \
      --share-with=CONSUMER_PROJECT_IDS \
      --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 \
      --share-setting=projects \
      --share-with=CONSUMER_PROJECT_IDS \
      --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, 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 \
      --share-setting=projects \
      --share-with=CONSUMER_PROJECT_IDS \
      --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 \
        --share-setting=projects \
        --share-with=CONSUMER_PROJECT_IDS \
        --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 \
        --share-setting=projects \
        --share-with=CONSUMER_PROJECT_IDS \
        --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.

Terraform

Para criar uma reserva, use o recurso google_compute_reservation do Terraform. Para especificar uma reserva compartilhada, defina o bloco share_settings:

• Defina o campo share_type como SPECIFIC_PROJECTS
• No bloco project_map, especifique os IDs dos projetos com que você quer compartilhar essa reserva.

Para mais informações sobre como usar o Terraform, consulte Como usar o Terraform com o Google Cloud.

REST

Para criar uma reserva compartilhada, faça uma solicitação POST para o método reservations.insert. No corpo da solicitação, inclua o seguinte:

• O campo projectMap.

• O campo shareType definido como SPECIFIC_PROJECTS.

Por exemplo, para criar uma reserva compartilhada sem campos opcionais e compartilhar a reserva com dois projetos de consumidor, faça a seguinte solicitação POST:

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

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

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.

• CONSUMER_PROJECT_ID_1 e CONSUMER_PROJECT_ID_2: os IDs do projeto que podem consumir essa reserva. É possível incluir até 100 projetos pessoais. Esses projetos precisam estar na mesma organização do projeto de proprietário. Não inclua o projeto proprietário. Por padrão, ele já pode consumir a reserva.

• 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 Mega, A3 High ou A3 Edge, 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.

Por exemplo, para criar uma reserva especificando um modelo de instância global na zona us-central1-a, compartilhe a reserva com os projetos project-1 e project-2 e reserve dez VMs que usam 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",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "project-1": {
        "projectId": "project-1"
      },
      "project-2": {
        "projectId": "project-2"
      }
    }
  },
  "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.

  Por exemplo, para criar uma reserva compartilhada com dois projetos de consumidor e anexar GPUs a qualquer VM N1 reservada, faça uma solicitação da seguinte maneira:

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

  Substitua:

  • NUMBER_OF_ACCELERATORS: o número de GPUs a serem adicionadas por VM reservada.

  • ACCELERATOR_TYPE: um modelo de GPU com suporte para VMs N1. Verifique se o modelo de GPU escolhido está disponível na zona em que você quer reservar recursos. Caso contrário, a criação da reserva falhará.

• Para anexar discos SSD locais a um tipo de máquina que não inclui discos SSD locais por padrão, inclua o campo localSsds no corpo da solicitação. Só é possível anexar discos SSD locais de 375 GB.

  Por exemplo, para anexar dois discos SSD locais ao tipo de máquina que você quer reservar ao especificar dois projetos de consumidor, faça uma solicitação da seguinte maneira:

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

  Substitua INTERFACE_TYPE pelo tipo de interface que você quer que cada disco SSD local use e que seu tipo de máquina especificado ofereça suporte. 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 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.

  Por exemplo, para criar uma reserva compartilhada especificando uma plataforma de CPU mínima e dois projetos de consumidor, faça uma solicitação da seguinte maneira:

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

  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 possam consumi-la, inclua o campo specificReservationRequired no corpo da solicitação e defina-o como true.

  Por exemplo, para criar uma reserva específica e compartilhá-la com dois projetos de consumidor, faça uma solicitação desta forma:

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

• Para permitir que uma reserva de VMs GPU seja consumida por jobs de treinamento personalizado ou jobs de previsão na Vertex AI, inclua o campo serviceShareType e defina como ALLOW_ALL.

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
  
  {
    "name": "RESERVATION_NAME",
    "reservationSharingPolicy": {
      "serviceShareType": "ALLOW_ALL"
    },
    "shareSettings": {
      "shareType": "SPECIFIC_PROJECTS",
      "projectMap": {
        "CONSUMER_PROJECT_ID_1": {
          "projectId": "CONSUMER_PROJECT_ID_1"
        },
        "CONSUMER_PROJECT_ID_2": {
          "projectId": "CONSUMER_PROJECT_ID_2"
        }
      }
    },
    "specificReservation": {
      "count": "NUMBER_OF_VMS",
      "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.

    Por exemplo, para criar uma reserva especificando uma data e hora para excluir uma reserva e compartilhar a reserva com dois projetos de consumidor, faça uma solicitação da seguinte maneira:

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

    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.

    Por exemplo, para criar uma reserva que o Compute Engine exclui após uma duração específica e compartilhar a reserva com dois projetos de consumidor, faça uma solicitação da seguinte maneira:

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

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