Crie 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 para Visualizar políticas da organização usando a restrição Projetos de proprietários de reservas compartilhadas .

gcloud

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

1. Faça download da política para 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 sua organização.

2. Use um editor de texto para abrir o arquivo policy.yaml e visualizar 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
   ...
   

   onde PROJECT_NUMBER_1 , PROJECT_NUMBER_2 e PROJECT_NUMBER_3 são os números dos únicos projetos da sua 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 Windows, use o seguinte comando:

     del policy.yaml
     

Console

Siga as etapas para Personalizar políticas para restrições de lista usando a restrição Projetos de proprietários 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 . Você pode repetir este comando para cada projeto ao qual deseja conceder essa permissão.

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

  Substitua o seguinte:

  • PROJECT_NUMBER : o número do projeto (não o ID do projeto) de um projeto na sua organização que você deseja permitir a criação e modificação de reservas compartilhadas.
  • ORGANIZATION_ID : o ID da sua organização.

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

  1. Para fazer download da política para 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 sua 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 você deseja que tenham permissão para criar e modificar reservas compartilhadas em seu allowedValues ​​.

     • Para cada projeto ao qual você deseja conceder permissão para criar e modificar reservas compartilhadas, adicione o projeto em uma nova linha em allowedValues ​​.
     • Para cada projeto em que você deseja revogar a permissão para criar e modificar reservas compartilhadas, exclua a linha desse projeto.

     Quando terminar, certifique-se de que o arquivo policy.yaml seja semelhante ao seguinte:

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

     onde PROJECT_NUMBER_1 , PROJECT_NUMBER_2 e PROJECT_NUMBER_3 são os números dos projetos (não os IDs dos projetos) de todos os projetos da sua organização que você deseja ter permissão para criar e modificar reservas compartilhadas.

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

  4. Para atualizar a política da sua 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 sua 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 Windows, use o seguinte comando:

       del policy.yaml
       

Console

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

   Ir para Reservas

   A página Reservas é exibida.

2. Clique em add_box Criar reserva .

   A página Criar uma reserva é exibida.

3. Em Nome , insira um nome para sua reserva.

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

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

   1. Para especificar uma reserva compartilhada, selecione Compartilhado .

   2. Clique em add Adicionar projetos e selecione os projetos da organização do projeto atual com os quais você deseja compartilhar a reserva. Você pode selecionar até 100 projetos de consumo.

6. Opcional: para permitir que uma reserva de VMs de GPU seja consumida por jobs de treinamento personalizados ou de previsão na Vertex AI, na seção de 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 automaticamente esta reserva, selecione Usar reserva automaticamente se ainda não estiver selecionado.

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

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

9. Na seção Configuração da máquina , selecione Usar modelo de instância e selecione o modelo de instância de sua preferência. Se você selecionar um modelo de instância regional, só poderá reservar recursos dentro da mesma região que a região do modelo.

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

11. Para criar a reserva, clique em Criar .

    A página Reservas é aberta. 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 os sinalizadores --share-setting=projects e --share-with .

Para criar uma reserva compartilhada especificando um modelo de instância e sem incluir sinalizações 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 o seguinte:

• RESERVATION_NAME : o nome da reserva a ser criada.

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

• CONSUMER_PROJECT_IDS : uma lista separada por vírgulas de IDs de projetos que podem consumir esta reserva — por exemplo, project-1,project-2 . Você pode incluir até 100 projetos de consumo. Esses projetos devem estar na mesma organização que o projeto proprietário. Não inclua o projeto proprietário. Por padrão, já é permitido consumir a reserva.

• 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 onde o modelo de instância está localizado. Se você especificar um modelo de instância regional, só poderá reservar VMs na mesma região da 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, você deverá incluir o sinalizador --require-specific-reservation . Isto indica que apenas as VMs que visam especificamente a reserva podem consumi-la. Para obter mais informações, consulte Consumir VMs de uma reserva específica .

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

• ZONE : a zona na qual reservar recursos.

Por exemplo, para criar uma reserva especificando um modelo de instância global na zona us-central1-a , compartilhar a reserva com os projetos project-1 e project-2 e reservar dez VMs, cada uma usando um tipo de máquina predefinido N2 com 4 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

Opcionalmente, você pode fazer um ou mais dos seguintes procedimentos:

• Para especificar que apenas as VMs que visam especificamente esta reserva podem consumi-la, inclua a sinalização --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 personalizados ou de previsão no Vertex AI, inclua a sinalização --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 sinalização --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 formatada como um carimbo de data/hora RFC 3339 , que deve ser o seguinte:

    YYYY-MM-DDTHH:MM:SSOFFSET
    

    Substitua o seguinte:

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

    • HH:MM:SS : uma hora formatada como uma hora de 2 dígitos usando um horário 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 deslocamento do Tempo Universal Coordenado (UTC) . Por exemplo, para usar o Horário Padrão do Pacífico (PST), especifique -08:00 . Como alternativa, para não usar deslocamento, especifique Z .

  • Para excluir a reserva após um período específico, use o comando gcloud beta compute reservations create com a sinalização --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.

Ir

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

Pitão

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

DESCANSAR

Para criar uma reserva compartilhada, faça uma solicitação POST ao 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 nenhum campo opcional e compartilhar a reserva com dois projetos consumidores, 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 o seguinte:

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

• ZONE : a zona na qual reservar recursos.

• RESERVATION_NAME : o nome da reserva a ser criada.

• CONSUMER_PROJECT_ID_1 e CONSUMER_PROJECT_ID_2 : os IDs dos projetos que podem consumir esta reserva. Você pode incluir até 100 projetos de consumo. Esses projetos devem estar na mesma organização que o projeto proprietário. Não inclua o projeto proprietário. Por padrão já é permitido 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 onde o modelo de instância está localizado. Se você especificar um modelo de instância regional, só poderá reservar VMs na mesma região da 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, você deverá incluir o campo specificReservationRequired no corpo da solicitação e definir o campo como true . Isto indica que apenas as VMs que visam especificamente esta reserva podem consumi-la. Para obter mais informações, consulte Consumir 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 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",
    "sourceInstanceTemplate": "projects/example-project/global/instanceTemplates/example-instance-template"
  }
}

Opcionalmente, você pode fazer um ou mais dos seguintes procedimentos:

• Para especificar que apenas as VMs que visam especificamente esta reserva podem consumi-la, inclua o campo specificReservationRequired no corpo da solicitação e defina o campo como true .

  Por exemplo, para criar uma reserva específica especificando um modelo de instância e compartilhar a reserva com dois projetos consumidores, faça uma solicitação da seguinte 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",
      "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
    },
    "specificReservationRequired": true
  }
  

• Para permitir que uma reserva de VMs de GPU seja consumida por jobs de treinamento personalizados ou 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"
    },
    "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 horário específico, 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 consumidores, faça uma solicitação da seguinte forma:

    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 formatada como um carimbo de data/hora RFC 3339 , que deve ser o seguinte:

    YYYY-MM-DDTHH:MM:SSOFFSET
    

    Substitua o seguinte:

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

    • HH:MM:SS : uma hora formatada como uma hora de 2 dígitos usando um horário 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 deslocamento do Tempo Universal Coordenado (UTC) . Por exemplo, para usar o Horário Padrão do Pacífico (PST), especifique -08:00 . Como alternativa, para não usar deslocamento, especifique Z .

  • Para excluir a reserva após um período específico, faça uma solicitação POST ao 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 consumidores, faça uma solicitação da seguinte forma:

    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 .

   Ir para Reservas

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

3. Clique em add_box Criar reserva .

   A página Criar uma reserva é exibida.

4. Em Nome , insira um nome para sua reserva.

5. Para Região e Zona , selecione onde deseja reservar recursos.

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

   1. Para especificar uma reserva compartilhada, selecione Compartilhado .

   2. Clique em add Adicionar projetos e selecione os projetos da organização do projeto atual com os quais você deseja compartilhar a reserva. Você pode selecionar até 100 projetos de consumo.

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

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

   • Para permitir que VMs correspondentes consumam automaticamente esta reserva, selecione Usar reserva automaticamente (padrão).

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

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

10. Na seção Configuração da máquina , selecione Especificar tipo de máquina e 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 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, para CPU Platform , selecione uma opção.

       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 anexadas 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 anexados.

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

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

12. Para criar a reserva, clique em Criar .

    A página Reservas é aberta. 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 os sinalizadores --share-setting=projects e --share-with .

Para criar uma reserva compartilhada especificando propriedades diretamente e sem incluir sinalizações 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 o seguinte:

• RESERVATION_NAME : o nome da reserva a ser criada.

• MACHINE_TYPE : um tipo de máquina a ser usado para cada VM. Se você especificar um tipo de máquina A3 Mega, A3 High ou A3 Edge, você deverá incluir o sinalizador --require-specific-reservation . Isso indica que apenas as VMs que segmentam especificamente a reserva podem consumi -la. Para obter mais informações, consulte Consumir VMs de uma reserva específica .

• CONSUMER_PROJECT_IDS : Uma lista separada por vírgula de IDs de projetos que podem consumir essa reserva-por exemplo, project-1,project-2 . Você pode incluir até 100 projetos de consumidores. Esses projetos devem estar na mesma organização que o projeto do proprietário. Não inclua o projeto do proprietário. Por padrão, já é permitido consumir a reserva.

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

• ZONE : a zona para reservar recursos.

Por exemplo, para criar uma reserva na zona us-central1-a para dez VMs que usam um tipo de máquina predefinido N2 com 4 vcpus e compartilhe a reserva com 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

Opcionalmente, você pode fazer um ou mais dos seguintes:

• Para conectar as GPUs às suas VMs N1 reservadas, inclua o sinalizador --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 o seguinte:

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

  • ACCELERATOR_TYPE : um modelo GPU suportado para VMs N1 . Certifique -se de que o modelo GPU escolhido esteja disponível na zona onde você deseja reservar recursos. Caso contrário, a criação da reserva falha.

• Para anexar os discos SSD locais a um tipo de máquina que não inclui discos SSD locais por padrão , inclua o sinalizador --local-ssd . Você 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 serem anexados.

  • INTERFACE_TYPE : o tipo de interface de disco que você deseja 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 mínima específica da CPU em vez da plataforma CPU padrão da zona, inclua o sinalizador --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 CPU mínima. Para garantir que uma plataforma CPU esteja disponível na zona em que você esteja reservando recursos, consulte as plataformas de CPU disponíveis por zona .

• Para especificar que apenas as VMs que segmentam especificamente essa reserva podem consumi-la, inclua o sinalizador --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 das VMs da GPU seja consumida por trabalhos de treinamento personalizados ou de previsão em vértice IA, inclua o conjunto de bandeira --reservation-sharing-policy para 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 ativar o mecanismo de computação para excluir automaticamente a reserva , selecione um dos seguintes métodos:

  • Para excluir a reserva em uma data e hora específicas, use as gcloud beta compute reservations create COMMAND com o sinalizador --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 formatados como um registro de data e hora RFC 3339 , que deve ser o seguinte:

    YYYY-MM-DDTHH:MM:SSOFFSET
    

    Substitua o seguinte:

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

    • HH:MM:SS : Um tempo formatado como uma hora de 2 dígitos usando um tempo de 24 horas, 2 minutos e segundos de 2 dígitos, separado por cenários ( : .

    • OFFSET : o fuso horário formatado como um deslocamento do tempo universal coordenado (UTC) . Por exemplo, para usar o tempo padrão do Pacífico (PST), especifique -08:00 . Como alternativa, para não usar o deslocamento, especifique Z .

  • Para excluir a reserva após uma duração específica, use o comando gcloud beta compute reservations create com o sinalizador --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 por 30 minutos ou 1d2h3m4s por 1 dia, 2 horas, 3 minutos e 4 segundos.

Terraforma

Para criar uma reserva, use o recurso do Terraform google_compute_reservation . 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 do projeto dos projetos com os quais você deseja compartilhar esta reserva.

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

DESCANSAR

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

• O campo projectMap .

• O campo shareType definido como SPECIFIC_PROJECTS .

Por exemplo, para criar uma reserva compartilhada sem incluir campos opcionais e compartilhar a reserva com dois projetos de consumidores, 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 o seguinte:

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

• ZONE : a zona para reservar recursos.

• RESERVATION_NAME : o nome da reserva para criar.

• CONSUMER_PROJECT_ID_1 e CONSUMER_PROJECT_ID_2 : os IDs de projetos que podem consumir esta reserva. Você pode incluir até 100 projetos de consumidores. Esses projetos devem estar na mesma organização que o projeto do proprietário. Não inclua o projeto do proprietário. Por padrão, já é permitido consumir a reserva.

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

• MACHINE_TYPE : um tipo de máquina a ser usado para cada VM. Se você especificar um tipo de máquina A3 Mega, A3 High ou A3 Edge, deverá incluir o campo specificReservationRequired no corpo da solicitação e definir o campo como true . Isso indica que apenas as 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 projetos project-1 e project-2 e reserve dez VMs que usam um tipo de máquina predefinido N2 com 4 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",
    }
  }
}

Opcionalmente, você pode fazer um ou mais dos seguintes:

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

  Por exemplo, para criar uma reserva compartilhada com dois projetos de consumo e anexar GPUs a qualquer VMS N1 reservado, faça uma solicitação da seguinte 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": {
        "guestAccelerators": [
          {
            "acceleratorCount": NUMBER_OF_ACCELERATORS,
            "acceleratorType": "ACCELERATOR_TYPE"
          }
        ],
        "machineType": "MACHINE_TYPE"
      }
    }
  }
  

  Substitua o seguinte:

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

  • ACCELERATOR_TYPE : um modelo GPU suportado para VMs N1 . Certifique -se de que o modelo GPU escolhido esteja disponível na zona onde você deseja reservar recursos. Caso contrário, a criação da reserva falha.

• 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 órgão de solicitação. Você só pode anexar discos SSD locais de 375 GB.

  Por exemplo, para anexar dois discos SSD locais ao tipo de máquina que você deseja reservar enquanto especifica dois projetos de consumidores, faça uma solicitação da seguinte 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": {
        "localSsds": [
          {
            "diskSizeGb": "375",
            "interface": "INTERFACE_TYPE"
          },
          {
            "diskSizeGb": "375",
            "interface": "INTERFACE_TYPE"
          }
        ],
        "machineType": "MACHINE_TYPE"
      }
    }
  }
  

  Substitua INTERFACE_TYPE pelo tipo de interface de disco que você deseja 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 mínima específica da CPU em vez da plataforma CPU padrão da zona, inclua o campo minCpuPlatform no corpo da solicitação.

  Por exemplo, para criar uma reserva compartilhada ao especificar uma plataforma mínima de CPU e dois projetos de consumo, 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 CPU mínima. Para garantir que uma plataforma CPU esteja disponível na zona em que você esteja reservando recursos, consulte as plataformas de CPU disponíveis por zona .

• Para especificar que apenas as VMs que segmentam especificamente essa reserva podem consumi -la, inclua o campo specificReservationRequired no corpo da solicitação e defina o campo como true .

  Por exemplo, para criar uma reserva específica e compartilhá -la com dois projetos de consumidores, 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"
      }
    },
    "specificReservationRequired": true
  }
  

• Para permitir que uma reserva das VMs da GPU seja consumida por trabalhos de treinamento personalizados ou de previsão em vértice IA, inclua o campo serviceShareType e defina -o para 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 ativar o mecanismo de computação para excluir 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 ao método beta.reservations.insert . No órgão de solicitação, inclua o campo deleteAtTime .

    Por exemplo, para criar uma reserva enquanto especifica uma data e hora para excluir uma reserva e compartilhar a reserva com dois projetos de consumidores, faça uma solicitação da seguinte forma:

    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 formatados como um registro de data e hora RFC 3339 , que deve ser o seguinte:

    YYYY-MM-DDTHH:MM:SSOFFSET
    

    Substitua o seguinte:

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

    • HH:MM:SS : Um tempo formatado como uma hora de 2 dígitos usando um tempo de 24 horas, 2 minutos e segundos de 2 dígitos, separado por cenários ( : .

    • OFFSET : o fuso horário formatado como um deslocamento do tempo universal coordenado (UTC) . Por exemplo, para usar o tempo padrão do Pacífico (PST), especifique -08:00 . Como alternativa, para não usar o deslocamento, especifique Z .

  • Para excluir a reserva após uma duração específica, faça uma solicitação POST ao método beta.reservations.insert . No órgão de solicitação, inclua o campo deleteAfterDuration .

    Por exemplo, para criar uma reserva que calcule o mecanismo exclui após uma duração específica e compartilhe a reserva com dois projetos de consumidores, faça uma solicitação da seguinte forma:

    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 por 86.400 segundos (1 dia).