Impedir que instâncias de computação consumam reservas

Este documento explica como evitar que instâncias do Compute Engine consumam reservas. Para saber mais sobre reservas, consulte Reservas de recursos zonais do Compute Engine .

As reservas consumidas automaticamente permitem que instâncias com propriedades que correspondam às reservas as consumam automaticamente. Para evitar que as instâncias consumam uma reserva, siga um destes procedimentos:

  • Configure instâncias para não consumir reservas, conforme descrito neste documento.

  • Crie ou atualize instâncias com propriedades que não correspondam à reserva.

Você pode evitar o consumo de reservas quando quiser usar suas instâncias para tarefas como testes, depuração ou implantações isoladas.

Limitações

Você só poderá atualizar uma instância existente para não consumir reservas se a instância estiver configurada para consumir reservas correspondentes automaticamente.

Antes de começar

Funções obrigatórias

Para obter as permissões necessárias para evitar que uma instância de computação consuma reservas, peça ao administrador para conceder a você a função do IAM Compute Instance Admin (v1) ( roles/compute.instanceAdmin.v1 ) no projeto. Para obter mais informações sobre a concessão de funções, consulte Gerenciar acesso a projetos, pastas e organizações .

Esta função predefinida contém as permissões necessárias para evitar que uma instância de computação consuma reservas. Para ver as permissões exatas necessárias, expanda a seção Permissões necessárias :

Permissões necessárias

As seguintes permissões são necessárias para evitar que uma instância de computação consuma reservas:

  • Para criar reservas: compute.reservations.create no projeto
  • Para criar instâncias:
    • compute.instances.create no projeto
    • Para usar uma imagem personalizada para criar a VM: compute.images.useReadOnly na imagem
    • Para usar um instantâneo para criar a VM: compute.snapshots.useReadOnly no instantâneo
    • Para usar um modelo de instância para criar a VM: compute.instanceTemplates.useReadOnly no modelo de instância
    • Para atribuir uma rede legada à VM: compute.networks.use no projeto
    • Para especificar um endereço IP estático para a VM: compute.addresses.use no projeto
    • Para atribuir um endereço IP externo à VM ao usar uma rede legada: compute.networks.useExternalIp no projeto
    • Para especificar uma sub-rede para a VM: compute.subnetworks.use no projeto ou na sub-rede escolhida
    • Para atribuir um endereço IP externo à VM ao usar uma rede VPC: compute.subnetworks.useExternalIp no projeto ou na sub-rede escolhida
    • Para definir metadados de instância de VM para a VM: compute.instances.setMetadata no projeto
    • Para definir tags para a VM: compute.instances.setTags na VM
    • Para definir rótulos para a VM: compute.instances.setLabels na VM
    • Para definir uma conta de serviço para a VM usar: compute.instances.setServiceAccount na VM
    • Para criar um novo disco para a VM: compute.disks.create no projeto
    • Para anexar um disco existente no modo somente leitura ou leitura-gravação: compute.disks.use no disco
    • Para anexar um disco existente no modo somente leitura: compute.disks.useReadOnly no disco
  • Para criar modelos de instância: compute.instanceTemplates.create no projeto

Você também poderá obter essas permissões com funções personalizadas ou outras funções predefinidas .

Evitar o consumo de reservas

Para evitar que uma instância de computação consuma reservas, defina sua propriedade de afinidade de reserva ( reservationAffinity ) para não consumir reservas. Esta propriedade controla se uma instância pode consumir reservas correspondentes, uma reserva específica ou nenhuma reserva.

Para evitar que uma ou mais instâncias consumam reservas, use um dos seguintes métodos:

Impedir o consumo em uma instância existente

Você pode atualizar uma instância em execução para que ela não consuma mais reservas automaticamente. Você deve reiniciar a instância para que as alterações tenham efeito, conforme descrito nesta seção.

Para evitar que uma instância existente consuma reservas, selecione uma das seguintes opções:

gcloud

  1. Crie um arquivo YAML vazio.

  2. Para exportar as propriedades de uma instância para o arquivo YAML que você acabou de criar, use o comando gcloud compute instances export :

    gcloud compute instances export INSTANCE_NAME \
    --destination=YAML_FILE \
    --zone=ZONE

    Substitua o seguinte:

    • INSTANCE_NAME : o nome da instância.

    • YAML_FILE : o caminho para o arquivo YAML vazio que você criou na etapa anterior.

    • ZONE : a zona onde a instância existe.

  3. No arquivo de configuração YAML, configure consumeReservationType como NO_RESERVATION :

    reservationAffinity:
  consumeReservationType: NO_RESERVATION

  4. Para atualizar a instância e reiniciá-la, use o comando gcloud compute instances update-from-file com a sinalização --most-disruptive-allowed-action definida como RESTART :

    gcloud compute instances update-from-file INSTANCE_NAME \
    --most-disruptive-allowed-action=RESTART \
    --source=YAML_FILE \
    --zone=ZONE

    Substitua o seguinte:

    • INSTANCE_NAME : o nome da instância.

    • YAML_FILE : o caminho para o arquivo YAML com os dados de configuração que você modificou na etapa anterior.

    • ZONE : a zona onde a instância existe.

DESCANSAR

  1. Para visualizar as propriedades de uma instância existente, faça uma solicitação GET ao método instances.get :

    GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME

    Substitua o seguinte:

    • PROJECT_ID : o ID do projeto onde você criou a instância.

    • ZONE : a zona onde a instância existe.

    • INSTANCE_NAME : o nome da instância.

  2. Armazene a saída da solicitação GET em um arquivo ou editor de texto. Modifique a saída copiada para alterar o campo consumeReservationType para NO_RESERVATION :

    {
  ...
  "reservationAffinity": {
    "consumeReservationType": "NO_RESERVATION"
  },
  ...
}

  3. Para atualizar a instância e reiniciá-la, faça uma solicitação PUT ao método instances.update . Na solicitação, faça o seguinte:

    • No URL de solicitação, inclua o parâmetro de consulta mostDisruptiveAllowedAction definido como RESTART .

    • Para o corpo da solicitação, use a saída da solicitação GET editada na etapa anterior.

    A solicitação é semelhante ao exemplo a seguir:

    PUT https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central-1/instances/instance-01?mostDisruptiveAllowedAction=RESTART

{
  ...
  "reservationAffinity": {
    "consumeReservationType": "NO_RESERVATION"
  },
  ...
}

Para obter mais informações sobre como atualizar uma instância, consulte Atualizar propriedades da instância .

Impedir o consumo ao criar uma instância

Para criar uma instância de computação que não possa consumir reservas, selecione uma das seguintes opções:

Console

  1. No console do Google Cloud, acesse a página Criar uma instância .

    Vá para Criar uma instância

  2. No campo Nome , insira um nome para a instância.

  3. Nas listas Região e Zona , selecione a região e a zona nas quais deseja criar a instância.

  4. Especifique o tipo de máquina a ser usado para a instância.

  5. No menu de navegação, clique em Avançado .

  6. Na seção Reservas , selecione Não usar uma reserva .

  7. Clique em Criar .

gcloud

Para criar uma instância que não pode consumir reservas, use o comando gcloud compute instances create com a sinalização --reservation-affinity definida como none :

gcloud compute instances create INSTANCE_NAME \
    --machine-type=MACHINE_TYPE \
    --reservation-affinity=none \
    --zone=ZONE

Substitua o seguinte:

  • INSTANCE_NAME : o nome da instância.

  • MACHINE_TYPE : o tipo de máquina a ser usado para a instância.

  • ZONE : a zona na qual criar a instância.

Ir

Para criar uma instância que não pode consumir reservas, use o seguinte exemplo de código: 

import (
	"context"
	"fmt"
	"io"

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

// createInstanceNotConsumeReservation creates VM, without consuming reservation
func createInstanceNotConsumeReservation(w io.Writer, projectID, zone, instanceName string) error {
	ctx := context.Background()
	machineType := fmt.Sprintf("zones/%s/machineTypes/%s", zone, "n2-standard-32")
	sourceImage := "projects/debian-cloud/global/images/family/debian-12"

	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer instancesClient.Close()

	req := &computepb.InsertInstanceRequest{
		Project: projectID,
		Zone:    zone,
		InstanceResource: &computepb.Instance{
			Disks: []*computepb.AttachedDisk{
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb:  proto.Int64(10),
						SourceImage: proto.String(sourceImage),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(true),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
			},
			MachineType:    proto.String(machineType),
			MinCpuPlatform: proto.String("Intel Cascade Lake"),
			Name:           proto.String(instanceName),
			NetworkInterfaces: []*computepb.NetworkInterface{
				{
					Name: proto.String("global/networks/default"),
				},
			},
			ReservationAffinity: &computepb.ReservationAffinity{
				ConsumeReservationType: proto.String("NO_RESERVATION"),
			},
		},
	}

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

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

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

	return nil
}

Java

Para criar uma instância que não pode consumir reservas, use o seguinte exemplo de código: 

import static com.google.cloud.compute.v1.ReservationAffinity.ConsumeReservationType.NO_RESERVATION;

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.ReservationAffinity;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateInstanceWithoutConsumingReservation {
  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the zone you want to use.
    String zone = "us-central1-a";
    // Name of the VM instance you want to query.
    String instanceName = "YOUR_INSTANCE_NAME";
    // machineType: machine type of the VM being created.
    // *   This value uses the format zones/{zone}/machineTypes/{type_name}.
    // *   For a list of machine types, see https://cloud.google.com/compute/docs/machine-types
    String machineTypeName = "n1-standard-1";
    // sourceImage: path to the operating system image to mount.
    // *   For details about images you can mount, see https://cloud.google.com/compute/docs/images
    String sourceImage = "projects/debian-cloud/global/images/family/debian-11";
    // diskSizeGb: storage size of the boot disk to attach to the instance.
    long diskSizeGb = 10L;
    // networkName: network interface to associate with the instance.
    String networkName = "default";

    createInstanceWithoutConsumingReservationAsync(projectId, zone, instanceName,
        machineTypeName, sourceImage, diskSizeGb, networkName);
  }

  // Create a virtual machine that explicitly doesn't consume reservations
  public static Instance createInstanceWithoutConsumingReservationAsync(
      String project, String zone, String instanceName,
      String machineTypeName, String sourceImage, long diskSizeGb, String networkName)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    String machineType = String.format("zones/%s/machineTypes/%s", zone, machineTypeName);

    // 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 (InstancesClient instancesClient = InstancesClient.create()) {
      AttachedDisk disk =
          AttachedDisk.newBuilder()
              .setBoot(true)
              .setAutoDelete(true)
              .setType(AttachedDisk.Type.PERSISTENT.toString())
              .setDeviceName("disk-1")
              .setInitializeParams(
                  AttachedDiskInitializeParams.newBuilder()
                      .setSourceImage(sourceImage)
                      .setDiskSizeGb(diskSizeGb)
                      .build())
              .build();

      NetworkInterface networkInterface = NetworkInterface.newBuilder()
          .setName(networkName)
          .build();

      ReservationAffinity reservationAffinity =
          ReservationAffinity.newBuilder()
              .setConsumeReservationType(NO_RESERVATION.toString())
              .build();

      Instance instanceResource =
          Instance.newBuilder()
              .setName(instanceName)
              .setMachineType(machineType)
              .addDisks(disk)
              .addNetworkInterfaces(networkInterface)
              .setReservationAffinity(reservationAffinity)
              .build();

      InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstanceResource(instanceResource)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.insertAsync(
          insertInstanceRequest);

      // Wait for the operation to complete.
      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        return null;
      }
      return instancesClient.get(project, zone, instanceName);
    }
  }
}

Node.js

Para criar uma instância que não pode consumir reservas, use o seguinte exemplo de código: 

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

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

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The ID of the project where you want to create instance.
const projectId = await instancesClient.getProjectId();
// The zone in which to create instance.
const zone = 'us-central1-a';
// The name of the instance to create.
// const instanceName = 'instance-01';
// Machine type to use for VM.
const machineType = 'n1-standard-4';

// Create a VM that explicitly doesn't consume reservations
async function callCreateInstanceToNotConsumeReservation() {
  // Describe the size and source image of the boot disk to attach to the instance.
  const disk = new compute.Disk({
    boot: true,
    autoDelete: true,
    type: 'PERSISTENT',
    initializeParams: {
      diskSizeGb: '10',
      sourceImage: 'projects/debian-cloud/global/images/family/debian-12',
    },
  });

  //  Define networkInterface
  const networkInterface = new compute.NetworkInterface({
    name: 'global/networks/default',
  });

  // Define reservationAffinity
  const reservationAffinity = new compute.ReservationAffinity({
    consumeReservationType: 'NO_RESERVATION',
  });

  // Create an instance
  const instance = new compute.Instance({
    name: instanceName,
    machineType: `zones/${zone}/machineTypes/${machineType}`,
    minCpuPlatform: 'Intel Skylake',
    disks: [disk],
    networkInterfaces: [networkInterface],
    reservationAffinity,
  });

  const [response] = await instancesClient.insert({
    project: projectId,
    instanceResource: instance,
    zone,
  });

  let operation = response.latestResponse;

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

  console.log(`Instance ${instanceName} created.`);
}

await callCreateInstanceToNotConsumeReservation();

Pitão

Para criar uma instância que não pode consumir reservas, use o seguinte exemplo de código: 

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_vm_not_consume_reservation(
    project_id: str, zone: str, instance_name: str, machine_type: str = "n2-standard-2"
) -> compute_v1.Instance:
    """Creates a VM that explicitly doesn't consume reservations
    Args:
        project_id (str): The ID of the Google Cloud project.
        zone (str): The zone where the VM will be created.
        instance_name (str): The name of the instance to create.
        machine_type (str, optional): The machine type for the instance.
    Returns:
        compute_v1.Instance: The created instance.
    """
    instance = compute_v1.Instance()
    instance.name = instance_name
    instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
    instance.zone = zone

    instance.disks = [
        compute_v1.AttachedDisk(
            boot=True,  # Indicates that this is a boot disk
            auto_delete=True,  # The disk will be deleted when the instance is deleted
            initialize_params=compute_v1.AttachedDiskInitializeParams(
                source_image="projects/debian-cloud/global/images/family/debian-11",
                disk_size_gb=10,
            ),
        )
    ]

    instance.network_interfaces = [
        compute_v1.NetworkInterface(
            network="global/networks/default",  # The network to use
            access_configs=[
                compute_v1.AccessConfig(
                    name="External NAT",  # Name of the access configuration
                    type="ONE_TO_ONE_NAT",  # Type of access configuration
                )
            ],
        )
    ]

    # Set the reservation affinity to not consume any reservation
    instance.reservation_affinity = compute_v1.ReservationAffinity(
        consume_reservation_type="NO_RESERVATION",  # Prevents the instance from consuming reservations
    )

    # Create a request to insert the instance
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

    vm_client = compute_v1.InstancesClient()
    operation = vm_client.insert(request)
    wait_for_extended_operation(operation, "Instance creation")

    print(f"Creating the {instance_name} instance in {zone}...")

    return vm_client.get(project=project_id, zone=zone, instance=instance_name)

DESCANSAR

Para criar uma instância que não possa consumir reservas, faça uma solicitação POST para o método instances.insert . No corpo da solicitação, inclua o campo consumeReservationType definido como NO_RESERVATION : 

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

{
  "name": "INSTANCE_NAME",
  "machineType": "zones/ZONE/machineTypes/MACHINE_TYPE",
  "disks": [
    {
      "boot": true,
      "initializeParams": {
        "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
      }
    }
  ],
  "networkInterfaces": [
    {
      "network": "global/networks/default"
    }
  ],
  "reservationAffinity": {
    "consumeReservationType": "NO_RESERVATION"
  }
}

Substitua o seguinte:

  • PROJECT_ID : o ID do projeto onde você deseja criar a instância.

  • ZONE : a zona na qual criar a instância.

  • INSTANCE_NAME : o nome da instância.

  • MACHINE_TYPE : o tipo de máquina a ser usado para a instância.

  • IMAGE_PROJECT : o projeto de imagem que contém a imagem do SO; por exemplo, debian-cloud . Para obter mais informações sobre os projetos de imagem suportados, consulte Imagens públicas .

  • IMAGE : especifique um dos seguintes:

    • Uma versão específica da imagem do sistema operacional; por exemplo, debian-12-bookworm-v20240617 .

    • Uma família de imagens , que deve ser formatada como family/ IMAGE_FAMILY . Isso especifica a imagem do sistema operacional mais recente e não obsoleta. Por exemplo, se você especificar family/debian-12 , a versão mais recente da família de imagens Debian 12 será usada. Para obter mais informações sobre o uso de famílias de imagens, consulte Práticas recomendadas para famílias de imagens .

Para mais informações sobre como criar uma instância, consulte Criar e iniciar uma instância do Compute Engine .

Evite o consumo ao criar instâncias em massa

Para criar instâncias de computação em massa que não possam consumir reservas, selecione uma das seguintes opções:

gcloud

Para criar instâncias em massa que não podem consumir reservas, use o comando gcloud compute instances bulk create com a sinalização --reservation-affinity definida como none .

Por exemplo, para criar instâncias em massa em uma única zona e especificar um padrão de nome, execute o seguinte comando: 

gcloud compute instances bulk create \
    --count=COUNT \
    --machine-type=MACHINE_TYPE \
    --name-pattern="NAME_PATTERN" \
    --reservation-affinity=none \
    --zone=ZONE

Substitua o seguinte:

  • COUNT : o número de instâncias a serem criadas.

  • MACHINE_TYPE : o tipo de máquina a ser usado para as instâncias.

  • NAME_PATTERN : o padrão de nome para as instâncias. Para substituir uma sequência de números em um nome de instância, use uma sequência de caracteres hash ( # ). Por exemplo, usar instance-# para o padrão de nome gera instâncias com nomes começando com instance-1 , instance-2 e continuando até o número de instâncias especificado por COUNT .

  • ZONE : a zona na qual criar instâncias em massa.

DESCANSAR

Para criar instâncias em massa que não podem consumir reservas, faça uma solicitação POST para o método instances.bulkInsert . No corpo da solicitação, inclua o campo consumeReservationType definido como NO_RESERVATION .

Por exemplo, para criar instâncias em massa em uma única zona e especificar um padrão de nome, faça uma solicitação da seguinte forma: 

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

{
  "count": COUNT,
  "namePattern": "NAME_PATTERN",
  "instanceProperties": {
    "machineType": "MACHINE_TYPE",
    "disks": [
      {
        "boot": true,
        "initializeParams": {
          "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
        }
      }
    ],
    "networkInterfaces": [
      {
        "network": "global/networks/default"
      }
    ],
    "reservationAffinity": {
      "consumeReservationType": "NO_RESERVATION"
    }
  }
}

Substitua o seguinte:

  • PROJECT_ID : o ID do projeto no qual serão criadas instâncias em massa.

  • ZONE : a zona na qual criar instâncias em massa.

  • COUNT : o número de instâncias a serem criadas.

  • NAME_PATTERN : o padrão de nome para as instâncias. Para substituir uma sequência de números em um nome de instância, use uma sequência de caracteres hash ( # ). Por exemplo, usar instance-# para o padrão de nome gera instâncias com nomes começando com instance-1 , instance-2 e continuando até o número de instâncias especificado por COUNT .

  • MACHINE_TYPE : o tipo de máquina a ser usado para as instâncias.

  • IMAGE_PROJECT : o projeto de imagem que contém a imagem do SO; por exemplo, debian-cloud . Para obter mais informações sobre os projetos de imagem suportados, consulte Imagens públicas .

  • IMAGE : especifique um dos seguintes:

    • Uma versão específica da imagem do sistema operacional; por exemplo, debian-12-bookworm-v20240617 .

    • Uma família de imagens , que deve ser formatada como family/ IMAGE_FAMILY . Isso especifica a imagem do sistema operacional mais recente e não obsoleta. Por exemplo, se você especificar family/debian-12 , a versão mais recente da família de imagens Debian 12 será usada. Para obter mais informações sobre o uso de famílias de imagens, consulte Práticas recomendadas para famílias de imagens .

Para obter mais informações sobre como criar instâncias em massa, consulte Criar VMs em massa .

Evite o consumo ao criar um modelo de instância

Depois de criar um modelo de instância que configure as instâncias para não consumirem reservas, você poderá usar o modelo para fazer o seguinte:

Para criar um modelo de instância que configure instâncias para não consumirem reservas, selecione uma das seguintes opções:

Console

  1. No console do Google Cloud, acesse a página Criar um modelo de instância .

    Vá para Criar um modelo de instância

  2. No campo Nome , insira um nome para o modelo de instância.

  3. Na seção Localização , especifique se deseja criar um modelo de instância regional (padrão) ou global.

  4. Na seção Configuração da máquina , especifique o tipo de máquina a ser usado para as instâncias criadas usando o modelo.

  5. Expanda a seção Opções avançadas e faça o seguinte:

    1. Expanda a seção Gerenciamento .

    2. Na seção Reservas , selecione Não usar uma reserva .

  6. Clique em Criar .

gcloud

Para criar um modelo de instância que configure instâncias para não consumirem reservas, use o comando gcloud compute instances-templates create com a sinalização --reservation-affinity definida como none .

Para criar um modelo de instância regional que configure instâncias para não consumir reservas, execute o comando a seguir. Se você deseja criar um modelo de instância global, use o mesmo comando sem o sinalizador --instance-template-region . 

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --instance-template-region=REGION \
    --machine-type=MACHINE_TYPE \
    --reservation-affinity=none

Substitua o seguinte:

  • INSTANCE_TEMPLATE_NAME : o nome do modelo de instância.

  • REGION : a região na qual o modelo de instância será criado.

  • MACHINE_TYPE : o tipo de máquina a ser usado para as instâncias criadas usando o modelo de instância.

Ir

Para criar um modelo de instância que configure instâncias para não consumirem reservas, use o seguinte exemplo de código: 

import (
	"context"
	"fmt"
	"io"

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

// createInstanceNotConsumeReservation creates a new instance template, which won't consume reservations
func createTemplateNotConsumeReservation(w io.Writer, projectID, templateName string) error {
	// projectID := "your_project_id"
	// templateName := "your_template_name"

	ctx := context.Background()
	instanceTemplatesClient, err := compute.NewInstanceTemplatesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstanceTemplatesRESTClient: %w", err)
	}
	defer instanceTemplatesClient.Close()

	req := &computepb.InsertInstanceTemplateRequest{
		Project: projectID,
		InstanceTemplateResource: &computepb.InstanceTemplate{
			Name: proto.String(templateName),
			Properties: &computepb.InstanceProperties{
				// The template describes the size and source image of the boot disk
				// to attach to the instance.
				Disks: []*computepb.AttachedDisk{
					{
						InitializeParams: &computepb.AttachedDiskInitializeParams{
							DiskSizeGb:  proto.Int64(250),
							SourceImage: proto.String("projects/debian-cloud/global/images/family/debian-11"),
						},
						AutoDelete: proto.Bool(true),
						Boot:       proto.Bool(true),
					},
				},
				MachineType: proto.String("e2-standard-4"),
				// The template connects the instance to the `default` network,
				// without specifying a subnetwork.
				NetworkInterfaces: []*computepb.NetworkInterface{
					{
						Name: proto.String("global/networks/default"),
						// The template lets the instance use an external IP address.
						AccessConfigs: []*computepb.AccessConfig{
							{
								Name:        proto.String("External NAT"),
								Type:        proto.String(computepb.AccessConfig_ONE_TO_ONE_NAT.String()),
								NetworkTier: proto.String(computepb.AccessConfig_PREMIUM.String()),
							},
						},
					},
				},
				ReservationAffinity: &computepb.ReservationAffinity{
					ConsumeReservationType: proto.String("NO_RESERVATION"),
				},
			},
		},
	}

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

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

	fmt.Fprintf(w, "Instance template created\n")

	return nil
}

Java

Para criar um modelo de instância que configure instâncias para não consumirem reservas, use o seguinte exemplo de código: 

import static com.google.cloud.compute.v1.ReservationAffinity.ConsumeReservationType.NO_RESERVATION;

import com.google.cloud.compute.v1.AccessConfig;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.InsertInstanceTemplateRequest;
import com.google.cloud.compute.v1.InstanceProperties;
import com.google.cloud.compute.v1.InstanceTemplate;
import com.google.cloud.compute.v1.InstanceTemplatesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.ReservationAffinity;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateTemplateWithoutConsumingReservation {
  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the template you want to query.
    String templateName = "YOUR_INSTANCE_TEMPLATE_NAME";
    String machineType = "e2-standard-4";
    String sourceImage = "projects/debian-cloud/global/images/family/debian-11";

    createTemplateWithoutConsumingReservationAsync(
        projectId, templateName, machineType, sourceImage);
  }


  // Create a template that explicitly doesn't consume any reservations.
  public static InstanceTemplate createTemplateWithoutConsumingReservationAsync(
      String projectId, String templateName, String machineType, String sourceImage)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create()) {
      AttachedDisk attachedDisk = AttachedDisk.newBuilder()
          .setInitializeParams(AttachedDiskInitializeParams.newBuilder()
              .setSourceImage(sourceImage)
              .setDiskType("pd-balanced")
              .setDiskSizeGb(250)
              .build())
          .setAutoDelete(true)
          .setBoot(true)
          .build();

      NetworkInterface networkInterface = NetworkInterface.newBuilder()
          .setName("global/networks/default")
          .addAccessConfigs(AccessConfig.newBuilder()
              .setName("External NAT")
              .setType(AccessConfig.Type.ONE_TO_ONE_NAT.toString())
              .setNetworkTier(AccessConfig.NetworkTier.PREMIUM.toString())
              .build())
          .build();

      ReservationAffinity reservationAffinity =
          ReservationAffinity.newBuilder()
              .setConsumeReservationType(NO_RESERVATION.toString())
              .build();

      InstanceProperties instanceProperties = InstanceProperties.newBuilder()
          .addDisks(attachedDisk)
          .setMachineType(machineType)
          .setReservationAffinity(reservationAffinity)
          .addNetworkInterfaces(networkInterface)
          .build();

      InsertInstanceTemplateRequest insertInstanceTemplateRequest = InsertInstanceTemplateRequest
          .newBuilder()
          .setProject(projectId)
          .setInstanceTemplateResource(InstanceTemplate.newBuilder()
              .setName(templateName)
              .setProperties(instanceProperties)
              .build())
          .build();

      Operation response = instanceTemplatesClient.insertAsync(insertInstanceTemplateRequest)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        return null;
      }
      return instanceTemplatesClient.get(projectId, templateName);
    }
  }
}

Node.js

Para criar um modelo de instância que configure instâncias para não consumirem reservas, use o seguinte exemplo de código: 

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

// Instantiate an instanceTemplatesClient
const instanceTemplatesClient = new computeLib.InstanceTemplatesClient();
// Instantiate a globalOperationsClient
const globalOperationsClient = new computeLib.GlobalOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The ID of the project where you want to create template.
const projectId = await instanceTemplatesClient.getProjectId();
// The name of the template to create.
// const templateName = 'instance-01';

// Create an instance template that creates VMs that don't explicitly consume reservations
async function callCreateTemplateToNotConsumeReservation() {
  // Define the boot disk for the instance template
  const disk = new compute.AttachedDisk({
    initializeParams: new compute.AttachedDiskInitializeParams({
      sourceImage:
        'projects/debian-cloud/global/images/debian-12-bookworm-v20240815',
      diskSizeGb: '100',
      diskType: 'pd-balanced',
    }),
    autoDelete: true,
    boot: true,
    type: 'PERSISTENT',
  });

  // Define the network interface for the instance template
  const network = new compute.NetworkInterface({
    network: `projects/${projectId}/global/networks/default`,
  });

  // Define reservationAffinity
  const reservationAffinity = new compute.ReservationAffinity({
    consumeReservationType: 'NO_RESERVATION',
  });

  // Define instance template
  const instanceTemplate = new compute.InstanceTemplate({
    name: templateName,
    properties: {
      disks: [disk],
      machineType: 'e2-medium',
      // The template connects the instance to the `default` network,
      // without specifying a subnetwork.
      networkInterfaces: [network],
      reservationAffinity,
    },
  });

  const [response] = await instanceTemplatesClient.insert({
    project: projectId,
    instanceTemplateResource: instanceTemplate,
  });

  let operation = response.latestResponse;

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

  console.log(`Template ${templateName} created.`);
}

await callCreateTemplateToNotConsumeReservation();

Pitão

Para criar um modelo de instância que configure instâncias para não consumirem reservas, use o seguinte exemplo de código: 

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_instance_template_not_consume_reservation(
    project_id: str,
    template_name: str,
    machine_type: str = "n1-standard-1",
) -> compute_v1.InstanceTemplate:
    """
    Creates an instance template that creates VMs that don't explicitly consume reservations

    Args:
        project_id: project ID or project number of the Cloud project you use.
        template_name: name of the new template to create.
        machine_type: machine type for the instance.
    Returns:
        InstanceTemplate object that represents the new instance template.
    """

    template = compute_v1.InstanceTemplate()
    template.name = template_name
    template.properties.machine_type = machine_type
    # The template describes the size and source image of the boot disk
    # to attach to the instance.
    template.properties.disks = [
        compute_v1.AttachedDisk(
            boot=True,
            auto_delete=True,  # The disk will be deleted when the instance is deleted
            initialize_params=compute_v1.AttachedDiskInitializeParams(
                source_image="projects/debian-cloud/global/images/family/debian-11",
                disk_size_gb=10,
            ),
        )
    ]
    # The template connects the instance to the `default` network,
    template.properties.network_interfaces = [
        compute_v1.NetworkInterface(
            network="global/networks/default",
            access_configs=[
                compute_v1.AccessConfig(
                    name="External NAT",
                    type="ONE_TO_ONE_NAT",
                )
            ],
        )
    ]
    # The template doesn't explicitly consume reservations
    template.properties.reservation_affinity = compute_v1.ReservationAffinity(
        consume_reservation_type="NO_RESERVATION"
    )

    template_client = compute_v1.InstanceTemplatesClient()
    operation = template_client.insert(
        project=project_id, instance_template_resource=template
    )

    wait_for_extended_operation(operation, "instance template creation")

    return template_client.get(project=project_id, instance_template=template_name)

DESCANSAR

Para criar um modelo de instância que configure instâncias para não consumirem reservas, faça uma solicitação POST para um dos seguintes métodos:

No corpo da solicitação, inclua o campo consumeReservationType e defina-o como NO_RESERVATION .

Por exemplo, para criar um modelo de instância regional e especificar que não consumirá reservas, faça uma solicitação da seguinte forma: 

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/InstanceTemplates

{
  "name": "INSTANCE_TEMPLATE_NAME",
  "properties": {
    "machineType": "MACHINE_TYPE",
    "disks": [
      {
        "boot": true,
        "initializeParams": {
          "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
        }
      }
    ],
    "networkInterfaces": [
      {
        "network": "global/networks/default"
      }
    ],
    "reservationAffinity": {
      "consumeReservationType": "NO_RESERVATION"
    }
  }
}

Substitua o seguinte:

  • PROJECT_ID : o ID do projeto no qual será criado o modelo de instância.

  • INSTANCE_TEMPLATE_NAME : o nome do modelo de instância.

  • MACHINE_TYPE : o tipo de máquina a ser usado para as instâncias criadas usando o modelo de instância.

  • IMAGE_PROJECT : o projeto de imagem que contém a imagem do SO; por exemplo, debian-cloud . Para obter mais informações sobre os projetos de imagem suportados, consulte Imagens públicas .

  • IMAGE : especifique um dos seguintes:

    • Uma versão específica da imagem do sistema operacional; por exemplo, debian-12-bookworm-v20240617 .

    • Uma família de imagens , que deve ser formatada como family/ IMAGE_FAMILY . Isso especifica a imagem do sistema operacional mais recente e não obsoleta. Por exemplo, se você especificar family/debian-12 , a versão mais recente da família de imagens Debian 12 será usada. Para obter mais informações sobre o uso de famílias de imagens, consulte Práticas recomendadas para famílias de imagens .

Para obter mais informações sobre como criar modelos de instância, consulte Criar modelos de instância .

O que vem a seguir