Crie uma reserva partilhada

Consola

Siga os passos para ver as políticas da organização usando a restrição Shared Reservations Owner Projects.

gcloud

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

1. Transfira a política da sua organização como um ficheiro denominado 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 da sua organização.

2. Use um editor de texto para abrir o ficheiro policy.yaml e ver a restrição compute.sharedReservationsOwnerProjects. Os projetos autorizados a criar e modificar reservas partilhadas 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 projetos dos únicos projetos na sua organização que podem criar reservas partilhadas.

3. Opcional: elimine o ficheiro policy.yaml.

   • Se estiver a usar um terminal Linux ou macOS, use o seguinte comando:

     rm policy.yaml
     

   • Se estiver a usar um terminal do Windows, use o seguinte comando:

     del policy.yaml
     

Consola

Siga os passos para personalizar as políticas para restrições de listas usando a restrição Projetos proprietários de reservas partilhadas.

gcloud

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

• Para conceder autorização a um único projeto para criar e modificar reservas partilhadas, use o comando gcloud resource-manager org-policies allow. Pode repetir este comando para cada projeto ao qual quer conceder esta autorizaçã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 quer permitir que crie e modifique reservas partilhadas.
  • ORGANIZATION_ID: o ID da organização da sua organização.

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

  1. Para transferir a política da sua organização como um ficheiro com o nome 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 da sua organização.

  2. Use um editor de texto para modificar o ficheiro policy.yaml de modo que a restrição compute.sharedReservationsOwnerProjects liste todos os projetos que quer que possam criar e modificar reservas partilhadas no respetivo allowedValues.

     • Para cada projeto ao qual quer conceder a autorização para criar e modificar reservas partilhadas, adicione o projeto numa nova linha em allowedValues.
     • Para cada projeto para o qual quer revogar a autorização para criar e modificar reservas partilhadas, elimine a linha desse projeto.

     Quando terminar, certifique-se de que o ficheiro policy.yaml tem um aspeto 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 na sua organização que quer que possam criar e modificar reservas partilhadas.

  3. Guarde o ficheiro policy.yaml e feche o editor de texto.

  4. Para atualizar a política da sua organização com as suas 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 da sua organização.

  5. Opcional: elimine o ficheiro policy.yaml.

     • Se estiver a usar um terminal Linux ou macOS, use o seguinte comando:

       rm policy.yaml
       

     • Se estiver a usar um terminal do Windows, use o seguinte comando:

       del policy.yaml
       

Consola

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

   Aceda a Reservas

   É apresentada a página Reservas.

2. Clique em add_box Criar reserva.

   É apresentada a página Criar uma reserva.

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

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

5. Na secção Tipo de partilha, faça o seguinte:

   1. Para especificar uma reserva partilhada, selecione Partilhada.

   2. Clique em add Adicionar projetos e, de seguida, selecione os projetos da organização do projeto atual com os quais quer partilhar a reserva. Pode selecionar até 100 projetos de consumidor.

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

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

   • Para permitir que as instâncias de VM correspondentes usem automaticamente esta reserva, selecione Usar reserva automaticamente se ainda não estiver selecionada.

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

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

9. Na secção Configuração da máquina, selecione Usar modelo de instância e, de seguida, selecione o modelo de instância da sua escolha. Se selecionar um modelo de instância regional, só pode reservar recursos na mesma região que a região do modelo.

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

11. Para criar a reserva, clique em Criar.

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

gcloud

Para criar uma reserva partilhada, use o comando gcloud compute reservations create com os indicadores --share-setting=projects e --share-with.

Para criar uma reserva partilhada especificando um modelo de instância e sem incluir quaisquer 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 o seguinte:

• RESERVATION_NAME: o nome da reserva a criar.

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

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

• LOCATION: a localização do modelo de instância. Especifique um dos seguintes valores:

  • Para um modelo de instância global: global.

  • Para um modelo de instância regional: regions/REGION. Substitua REGION pela região onde o modelo de instância está localizado. Se especificar um modelo de instância regional, só pode reservar VMs na mesma região que a região do modelo.

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

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

• ZONE: a zona na qual reservar recursos.

Por exemplo, para criar uma reserva especificando um modelo de instância global na zona us-central1-a, partilhe a reserva com os projetos project-1 e project-2 e reserve dez VMs que usam cada uma um tipo de máquina predefinido N2 com 4 vCPUs, execute o seguinte comando:

gcloud compute reservations create my-reservation \
    --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, pode fazer uma ou mais das seguintes ações:

• Para especificar que apenas as VMs que segmentam especificamente esta reserva a podem consumir, inclua a flag --require-specific-reservation.

  gcloud compute reservations create RESERVATION_NAME \
      --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 tarefas de preparação personalizadas ou tarefas de previsão no Vertex AI, inclua a flag --reservation-sharing-policy definida como ALLOW_ALL.

  gcloud compute reservations create RESERVATION_NAME \
      --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 elimine automaticamente a reserva, selecione um dos seguintes métodos:

  • Para eliminar a reserva numa data e hora específicas, use o comando gcloud beta compute reservations create com a flag --delete-at-time.

    gcloud beta compute reservations create RESERVATION_NAME \
        --delete-at-time=DELETE_AT_TIME \
        --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 uma hora formatadas como uma data/hora RFC 3339, que tem de ser a seguinte:

    YYYY-MM-DDTHH:MM:SSOFFSET
    

    Substitua o seguinte:

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

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

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

  • Para eliminar a reserva após uma duração específica, use o comando gcloud beta compute reservations create com a flag --delete-after-duration.

    gcloud beta compute reservations create RESERVATION_NAME \
        --delete-after-duration=DELETE_AFTER_DURATION \
        --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();

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 partilhada, faça um pedido POST ao método reservations.insert. No corpo do pedido, inclua o seguinte:

• O campo projectMap.

• O campo shareType está definido como SPECIFIC_PROJECTS.

Por exemplo, para criar uma reserva partilhada especificando um modelo de instância sem incluir campos opcionais e partilhar a reserva com dois projetos de consumidor, faça o seguinte pedido 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 quer reservar recursos e onde existe o modelo de instância.

• ZONE: a zona na qual reservar recursos.

• RESERVATION_NAME: o nome da reserva a criar.

• CONSUMER_PROJECT_ID_1 e CONSUMER_PROJECT_ID_2: os IDs dos projetos que podem consumir esta reserva. Pode incluir até 100 projetos de consumo. Estes projetos têm de estar na mesma organização que o projeto proprietário. Não inclua o projeto proprietário. Por predefinição, já é permitido consumir a reserva.

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

• LOCATION: a localização do modelo de instância. Especifique um dos seguintes valores:

  • Para um modelo de instância global: global.

  • Para um modelo de instância regional: regions/REGION. Substitua REGION pela região onde o modelo de instância está localizado. Se especificar um modelo de instância regional, só pode reservar VMs na mesma região que a região do modelo.

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

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

• Para especificar que apenas as VMs que segmentam especificamente esta reserva a podem usar, inclua o campo specificReservationRequired no corpo do pedido e defina o campo como true.

  Por exemplo, para criar uma reserva específica especificando um modelo de instância e partilhar a reserva com dois projetos de consumidor, faça um pedido 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 tarefas de preparação personalizadas ou tarefas de previsão no Vertex AI, inclua o campo serviceShareType e defina-o como ALLOW_ALL.

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
  
  {
    "name": "RESERVATION_NAME",
    "reservationSharingPolicy": {
      "serviceShareType": "ALLOW_ALL"
    },
    "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 elimine automaticamente a reserva, selecione um dos seguintes métodos:

  • Para eliminar a reserva numa data e hora específicas, faça um POST pedido ao métodobeta.reservations.insert. No corpo do pedido, inclua o campo deleteAtTime.

    Por exemplo, para criar uma reserva especificando um modelo de instância, eliminar automaticamente a reserva numa data e hora específicas e partilhar a reserva com dois projetos de consumidor, faça um pedido 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 uma hora formatadas como uma data/hora RFC 3339, que tem de ser a seguinte:

    YYYY-MM-DDTHH:MM:SSOFFSET
    

    Substitua o seguinte:

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

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

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

  • Para eliminar a reserva após uma duração específica, faça um POST pedido ao método.beta.reservations.insert No corpo do pedido, inclua o campo deleteAfterDuration.

    Por exemplo, para criar uma reserva especificando um modelo de instância, eliminar automaticamente a reserva após uma duração específica e partilhar a reserva com dois projetos de consumidor, faça um pedido 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).

Consola

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

   Aceda a Reservas

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

3. Clique em add_box Criar reserva.

   É apresentada a página Criar uma reserva.

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

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

6. Na secção Tipo de partilha, faça o seguinte:

   1. Para especificar uma reserva partilhada, selecione Partilhada.

   2. Clique em add Adicionar projetos e, de seguida, selecione os projetos da organização do projeto atual com os quais quer partilhar a reserva. Pode selecionar até 100 projetos de consumidor.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

12. Para criar a reserva, clique em Criar.

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

gcloud

Para criar uma reserva partilhada, use o comando gcloud compute reservations create com os indicadores --share-setting=projects e --share-with.

Para criar uma reserva partilhada especificando as 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 o seguinte:

• RESERVATION_NAME: o nome da reserva a criar.

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

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

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

• ZONE: a zona na qual reservar recursos.

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

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

• Para anexar GPUs às suas VMs N1 reservadas, inclua a flag --accelerator.

  gcloud compute reservations create RESERVATION_NAME \
      --accelerator=count=NUMBER_OF_ACCELERATORS,type=ACCELERATOR_TYPE
      --machine-type=MACHINE_TYPE \
      --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 adicionar por VM reservada.

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

• Para anexar discos SSD local a um tipo de máquina que não inclui discos SSD local por predefinição, inclua a flag --local-ssd. Só pode anexar discos SSD locais de 375 GB.

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

  Substitua o seguinte:

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

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

    • Para a interface de disco NVME: nvme

    • Para a interface de disco SCSI: scsi

• Para que as VMs reservadas usem uma plataforma de CPU mínima específica, em vez da plataforma de CPU predefinida da zona, inclua o sinalizador --min-cpu-platform.

  gcloud compute reservations create RESERVATION_NAME \
      --machine-type=MACHINE_TYPE \
      --min-cpu-platform="MIN_CPU_PLATFORM" \
      --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 se certificar de que uma plataforma de CPU está disponível na zona onde está a reservar recursos, veja as plataformas de CPU disponíveis por zona.

• Para especificar que apenas as VMs que segmentam especificamente esta reserva a podem consumir, inclua a flag --require-specific-reservation.

  gcloud compute reservations create RESERVATION_NAME \
      --machine-type=MACHINE_TYPE \
      --require-specific-reservation \
      --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 tarefas de preparação personalizadas ou tarefas de previsão no Vertex AI, inclua a flag --reservation-sharing-policy definida como ALLOW_ALL.

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

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

  • Para eliminar a reserva numa data e hora específicas, use o comando gcloud beta compute reservations create com a flag --delete-at-time.

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

    Substitua DELETE_AT_TIME por uma data e uma hora formatadas como uma data/hora RFC 3339, que tem de ser a seguinte:

    YYYY-MM-DDTHH:MM:SSOFFSET
    

    Substitua o seguinte:

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

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

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

  • Para eliminar a reserva após uma duração específica, use o comando gcloud beta compute reservations create com a flag --delete-after-duration.

    gcloud beta compute reservations create RESERVATION_NAME \
        --delete-after-duration=DELETE_AFTER_DURATION \
        --machine-type=MACHINE_TYPE \
        --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 google_compute_reservation recurso do Terraform. Para especificar uma reserva partilhada, defina o bloco share_settings:

• Defina o campo share_type como SPECIFIC_PROJECTS.
• No bloco project_map, especifique os IDs dos projetos com os quais quer partilhar esta reserva.

Para mais informações sobre como usar o Terraform, consulte o artigo Usar o Terraform com Trusted Cloud by S3NS.

REST

Para criar uma reserva partilhada, faça um pedido POST ao método reservations.insert. No corpo do pedido, inclua o seguinte:

• O campo projectMap.

• O campo shareType está definido como SPECIFIC_PROJECTS.

Por exemplo, para criar uma reserva partilhada sem incluir campos opcionais e partilhar a reserva com dois projetos de consumidor, faça o seguinte pedido 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 onde quer reservar recursos.

• ZONE: a zona na qual reservar recursos.

• RESERVATION_NAME: o nome da reserva a criar.

• CONSUMER_PROJECT_ID_1 e CONSUMER_PROJECT_ID_2: os IDs dos projetos que podem consumir esta reserva. Pode incluir até 100 projetos de consumo. Estes projetos têm de estar na mesma organização que o projeto proprietário. Não inclua o projeto proprietário. Por predefinição, já é permitido consumir a reserva.

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

• MACHINE_TYPE: um tipo de máquina a usar para cada VM. Se especificar um tipo de máquina A3 Mega, A3 High ou A3 Edge, tem de incluir o campo specificReservationRequired no corpo do pedido e definir o campo como true. Isto indica que apenas as VMs que segmentam especificamente a reserva podem consumi-la.

Por exemplo, para criar uma reserva especificando um modelo de instância global na zona us-central1-a, partilhe a reserva com os projetos project-1 e project-2 e reserve dez VMs que usam cada uma um tipo de máquina predefinido N2 com 4 vCPUs, faça o seguinte pedido POST:

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

{
  "name": "my-reservation",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "project-1": {
        "projectId": "project-1"
      },
      "project-2": {
        "projectId": "project-2"
      }
    }
  },
  "specificReservation": {
    "count": "10",
    "instanceProperties": {
      "machineType": "n2-standard-4",
    }
  }
}

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

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

  Por exemplo, para criar uma reserva partilhada com dois projetos de consumidor e anexar GPUs a quaisquer VMs N1 reservadas, faça um pedido 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 adicionar por VM reservada.

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

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

  Por exemplo, para anexar dois discos SSD locais ao tipo de máquina que quer reservar enquanto especifica dois projetos de consumidor, faça um pedido 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 quer que cada disco SSD local use e que o tipo de máquina especificado suporta. Especifique um dos seguintes valores:

  • Para a interface de disco NVME: NVME

  • Para a interface de disco SCSI: SCSI

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

  Por exemplo, para criar uma reserva partilhada enquanto especifica uma plataforma de CPU mínima e dois projetos de consumidor, faça um pedido 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": {
        "machineType": "MACHINE_TYPE",
        "minCpuPlatform": "MIN_CPU_PLATFORM"
      }
    }
  }
  

  Substitua MIN_CPU_PLATFORM por uma plataforma de CPU mínima. Para se certificar de que uma plataforma de CPU está disponível na zona onde está a reservar recursos, veja as plataformas de CPU disponíveis por zona.

• Para especificar que apenas as VMs que segmentam especificamente esta reserva a podem consumir, inclua o campo specificReservationRequired no corpo do pedido e defina o campo como true.

  Por exemplo, para criar uma reserva específica e partilhá-la com dois projetos de consumidor, faça um pedido 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": {
        "machineType": "MACHINE_TYPE"
      }
    },
    "specificReservationRequired": true
  }
  

• Para permitir que uma reserva de VMs de GPU seja consumida por tarefas de preparação personalizadas ou tarefas de previsão no Vertex AI, inclua o campo serviceShareType e defina-o como ALLOW_ALL.

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
  
  {
    "name": "RESERVATION_NAME",
    "reservationSharingPolicy": {
      "serviceShareType": "ALLOW_ALL"
    },
    "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 elimine automaticamente a reserva, selecione um dos seguintes métodos:

  • Para eliminar a reserva numa data e hora específicas, faça um POST pedido ao métodobeta.reservations.insert. No corpo do pedido, inclua o campo deleteAtTime.

    Por exemplo, para criar uma reserva enquanto especifica uma data e hora para eliminar uma reserva e partilhar a reserva com dois projetos de consumidor, faça um pedido 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 uma hora formatadas como uma data/hora RFC 3339, que tem de ser a seguinte:

    YYYY-MM-DDTHH:MM:SSOFFSET
    

    Substitua o seguinte:

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

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

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

  • Para eliminar a reserva após uma duração específica, faça um POST pedido ao método.beta.reservations.insert No corpo do pedido, inclua o campo deleteAfterDuration.

    Por exemplo, para criar uma reserva que o Compute Engine elimina após uma duração específica e partilhar a reserva com dois projetos de consumidor, faça um pedido 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 para 86 400 segundos (1 dia).