Evite que las instancias informáticas consuman reservas

Este documento explica cómo evitar que las instancias de Compute Engine consuman reservas. Para obtener más información sobre las reservas, consulta Reservas de recursos zonales de Compute Engine .

Las reservas consumidas automáticamente permiten que las instancias con propiedades que coincidan con las reservas las consuman automáticamente. Para evitar que las instancias consuman una reserva, realice una de las siguientes acciones:

  • Configure instancias para que no consuman reservas, como se describe en este documento.

  • Cree o actualice instancias con propiedades que no coincidan con la reserva.

Puede evitar consumir reservas cuando desee utilizar sus instancias para tareas como pruebas, depuración o implementaciones aisladas.

Limitaciones

Solo puede actualizar una instancia existente para que no consuma reservas si la instancia está configurada para consumir automáticamente reservas coincidentes.

Antes de comenzar

Roles requeridos

Para obtener los permisos que necesita para evitar que una instancia informática consuma reservas, solicite a su administrador que le otorgue el rol de IAM de Administrador de instancia informática (v1) ( roles/compute.instanceAdmin.v1 ) en el proyecto. Para obtener más información sobre cómo otorgar roles, consulte Administrar el acceso a proyectos, carpetas y organizaciones .

Esta función predefinida contiene los permisos necesarios para evitar que una instancia informática consuma reservas. Para ver los permisos exactos que se requieren, expanda la sección Permisos requeridos :

Permisos requeridos

Se requieren los siguientes permisos para evitar que una instancia informática consuma reservas:

  • Para crear reservas: compute.reservations.create en el proyecto.
  • Para crear instancias:
    • compute.instances.create en el proyecto.
    • Para usar una imagen personalizada para crear la VM: compute.images.useReadOnly en la imagen
    • Para usar una instantánea para crear la VM: compute.snapshots.useReadOnly en la instantánea
    • Para usar una plantilla de instancia para crear la VM: compute.instanceTemplates.useReadOnly en la plantilla de instancia
    • Para asignar una red heredada a la VM: compute.networks.use en el proyecto
    • Para especificar una dirección IP estática para la VM: compute.addresses.use en el proyecto
    • Para asignar una dirección IP externa a la VM cuando se usa una red heredada: compute.networks.useExternalIp en el proyecto
    • Para especificar una subred para la VM: compute.subnetworks.use en el proyecto o en la subred elegida
    • Para asignar una dirección IP externa a la VM cuando se usa una red VPC: compute.subnetworks.useExternalIp en el proyecto o en la subred elegida
    • Para configurar metadatos de instancia de VM para la VM: compute.instances.setMetadata en el proyecto
    • Para configurar etiquetas para la VM: compute.instances.setTags en la VM
    • Para configurar etiquetas para la VM: compute.instances.setLabels en la VM
    • Para configurar una cuenta de servicio para que la use la VM: compute.instances.setServiceAccount en la VM
    • Para crear un nuevo disco para la VM: compute.disks.create en el proyecto
    • Para conectar un disco existente en modo de solo lectura o lectura-escritura: compute.disks.use en el disco
    • Para conectar un disco existente en modo de solo lectura: compute.disks.useReadOnly en el disco
  • Para crear plantillas de instancias: compute.instanceTemplates.create en el proyecto.

Es posible que también pueda obtener estos permisos con roles personalizados u otros roles predefinidos .

Prevenir el consumo de reservas

Para evitar que una instancia informática consuma reservas, establezca su propiedad de afinidad de reservas ( reservationAffinity ) para que no consuma reservas. Esta propiedad controla si una instancia puede consumir reservas coincidentes, una reserva específica o ninguna reserva.

Para evitar que una o más instancias consuman reservas, utilice uno de los siguientes métodos:

Evitar el consumo en una instancia existente

Puede actualizar una instancia en ejecución para que ya no consuma reservas automáticamente. Debe reiniciar la instancia para que los cambios sean efectivos, como se describe en esta sección.

Para evitar que una instancia existente consuma reservas, seleccione una de las siguientes opciones:

nube de gcloud

  1. Cree un archivo YAML vacío.

  2. Para exportar las propiedades de una instancia al archivo YAML que acaba de crear, use el comando gcloud compute instances export :

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

    Reemplace lo siguiente:

    • INSTANCE_NAME : el nombre de la instancia.

    • YAML_FILE : la ruta al archivo YAML vacío que creó en el paso anterior.

    • ZONE : la zona donde existe la instancia.

  3. En el archivo de configuración YAML, establezca consumeReservationType en NO_RESERVATION :

    reservationAffinity:
  consumeReservationType: NO_RESERVATION

  4. Para actualizar la instancia y reiniciarla, usa el comando gcloud compute instances update-from-file con el indicador --most-disruptive-allowed-action configurado en RESTART :

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

    Reemplace lo siguiente:

    • INSTANCE_NAME : el nombre de la instancia.

    • YAML_FILE : la ruta al archivo YAML con los datos de configuración que modificaste en el paso anterior.

    • ZONE : la zona donde existe la instancia.

DESCANSAR

  1. Para ver las propiedades de una instancia existente, realice una solicitud GET al método instances.get :

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

    Reemplace lo siguiente:

    • PROJECT_ID : el ID del proyecto donde creaste la instancia.

    • ZONE : la zona donde existe la instancia.

    • INSTANCE_NAME : el nombre de la instancia.

  2. Almacene el resultado de la solicitud GET en un archivo o editor de texto. Modifique la salida copiada para cambiar el campo consumeReservationType a NO_RESERVATION :

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

  3. Para actualizar la instancia y reiniciarla, realice una solicitud PUT al método instances.update . En la solicitud, haga lo siguiente:

    • En la URL de solicitud, incluya el parámetro de consulta mostDisruptiveAllowedAction establecido en RESTART .

    • Para el cuerpo de la solicitud, utilice el resultado de la solicitud GET que editó en un paso anterior.

    La solicitud es similar al siguiente ejemplo:

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

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

Para obtener más información sobre cómo actualizar una instancia, consulte Actualizar propiedades de instancia .

Evitar el consumo al crear una instancia

Para crear una instancia informática que no pueda consumir reservas, seleccione una de las siguientes opciones:

Consola

  1. En la consola de Google Cloud, vaya a la página Crear una instancia .

    Ir a Crear una instancia

  2. En el campo Nombre , ingrese un nombre para la instancia.

  3. En las listas Región y Zona , seleccione la región y la zona en las que crear la instancia.

  4. Especifique el tipo de máquina que se utilizará para la instancia.

  5. En el menú de navegación, haga clic en Avanzado .

  6. En la sección Reservas , seleccione No utilizar una reserva .

  7. Haga clic en Crear .

nube de gcloud

Para crear una instancia que no pueda consumir reservas, usa el comando gcloud compute instances create con el indicador --reservation-affinity establecido en none :

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

Reemplace lo siguiente:

  • INSTANCE_NAME : el nombre de la instancia.

  • MACHINE_TYPE : el tipo de máquina que se utilizará para la instancia.

  • ZONE : la zona en la que crear la instancia.

Ir

Para crear una instancia que no pueda consumir reservas, utilice el siguiente código de ejemplo: 

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 crear una instancia que no pueda consumir reservas, utilice el siguiente código de ejemplo: 

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

Nodo.js

Para crear una instancia que no pueda consumir reservas, utilice el siguiente código de ejemplo: 

// 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ón

Para crear una instancia que no pueda consumir reservas, utilice el siguiente código de ejemplo: 

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 crear una instancia que no pueda consumir reservas, realice una solicitud POST al método instances.insert . En el cuerpo de la solicitud, incluya el campo consumeReservationType establecido en 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"
  }
}

Reemplace lo siguiente:

  • PROJECT_ID : el ID del proyecto donde desea crear la instancia.

  • ZONE : la zona en la que crear la instancia.

  • INSTANCE_NAME : el nombre de la instancia.

  • MACHINE_TYPE : el tipo de máquina que se utilizará para la instancia.

  • IMAGE_PROJECT : el proyecto de imagen que contiene la imagen del sistema operativo; por ejemplo, debian-cloud . Para obtener más información sobre los proyectos de imágenes admitidos, consulte Imágenes públicas .

  • IMAGE : especifique uno de los siguientes:

    • Una versión específica de la imagen del sistema operativo; por ejemplo, debian-12-bookworm-v20240617 .

    • Una familia de imágenes , que debe tener el formato family/ IMAGE_FAMILY . Esto especifica la imagen del sistema operativo más reciente y no obsoleta. Por ejemplo, si especifica family/debian-12 , se utiliza la última versión de la familia de imágenes de Debian 12. Para obtener más información sobre el uso de familias de imágenes, consulte Mejores prácticas de familias de imágenes .

Para obtener más información sobre la creación de una instancia, consulte Crear e iniciar una instancia de Compute Engine .

Evite el consumo mientras crea instancias de forma masiva

Para crear instancias informáticas de forma masiva que no puedan consumir reservas, seleccione una de las siguientes opciones:

nube de gcloud

Para crear instancias de forma masiva que no puedan consumir reservas, usa el comando gcloud compute instances bulk create con la marca --reservation-affinity configurada en none .

Por ejemplo, para crear instancias de forma masiva en una sola zona y especificar un patrón de nombre, ejecute el siguiente comando: 

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

Reemplace lo siguiente:

  • COUNT : el número de instancias a crear.

  • MACHINE_TYPE : el tipo de máquina que se utilizará para las instancias.

  • NAME_PATTERN : el patrón de nombre de las instancias. Para reemplazar una secuencia de números en el nombre de una instancia, utilice una secuencia de caracteres almohadilla ( # ). Por ejemplo, el uso de instance-# para el patrón de nombre genera instancias con nombres que comienzan con instance-1 , instance-2 y continúan hasta el número de instancias especificado por COUNT .

  • ZONE : la zona en la que crear instancias de forma masiva.

DESCANSAR

Para crear instancias de forma masiva que no puedan consumir reservas, realice una solicitud POST al método instances.bulkInsert . En el cuerpo de la solicitud, incluya el campo consumeReservationType establecido en NO_RESERVATION .

Por ejemplo, para crear instancias de forma masiva en una sola zona y especificar un patrón de nombre, realice una solicitud de la siguiente manera: 

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

Reemplace lo siguiente:

  • PROJECT_ID : el ID del proyecto en el que crear instancias de forma masiva.

  • ZONE : la zona en la que crear instancias de forma masiva.

  • COUNT : el número de instancias a crear.

  • NAME_PATTERN : el patrón de nombre de las instancias. Para reemplazar una secuencia de números en el nombre de una instancia, utilice una secuencia de caracteres almohadilla ( # ). Por ejemplo, el uso de instance-# para el patrón de nombre genera instancias con nombres que comienzan con instance-1 , instance-2 y continúan hasta el número de instancias especificado por COUNT .

  • MACHINE_TYPE : el tipo de máquina que se utilizará para las instancias.

  • IMAGE_PROJECT : el proyecto de imagen que contiene la imagen del sistema operativo; por ejemplo, debian-cloud . Para obtener más información sobre los proyectos de imágenes admitidos, consulte Imágenes públicas .

  • IMAGE : especifique uno de los siguientes:

    • Una versión específica de la imagen del sistema operativo; por ejemplo, debian-12-bookworm-v20240617 .

    • Una familia de imágenes , que debe tener el formato family/ IMAGE_FAMILY . Esto especifica la imagen del sistema operativo más reciente y no obsoleta. Por ejemplo, si especifica family/debian-12 , se utiliza la última versión de la familia de imágenes de Debian 12. Para obtener más información sobre el uso de familias de imágenes, consulte Mejores prácticas de familias de imágenes .

Para obtener más información sobre la creación de instancias de forma masiva, consulte Crear máquinas virtuales de forma masiva .

Evite el consumo al crear una plantilla de instancia

Después de crear una plantilla de instancias que configura instancias para que no consuman reservas, puede usar la plantilla para hacer lo siguiente:

Para crear una plantilla de instancias que configure instancias para que no consuman reservas, seleccione una de las siguientes opciones:

Consola

  1. En la consola de Google Cloud, vaya a la página Crear una plantilla de instancia .

    Ir a Crear una plantilla de instancia

  2. En el campo Nombre , ingrese un nombre para la plantilla de instancia.

  3. En la sección Ubicación , especifique si desea crear una plantilla de instancia regional (predeterminada) o global.

  4. En la sección Configuración de la máquina , especifique el tipo de máquina que se usará para las instancias creadas usando la plantilla.

  5. Expanda la sección Opciones avanzadas y luego haga lo siguiente:

    1. Expanda la sección Gestión .

    2. En la sección Reservas , seleccione No utilizar una reserva .

  6. Haga clic en Crear .

nube de gcloud

Para crear una plantilla de instancias que configure instancias para que no consuman reservas, use el comando gcloud compute instances-templates create con el indicador --reservation-affinity establecido en none .

Para crear una plantilla de instancia regional que configure instancias para que no consuman reservas, ejecute el siguiente comando. Si desea crear una plantilla de instancia global, utilice el mismo comando sin el indicador --instance-template-region . 

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

Reemplace lo siguiente:

  • INSTANCE_TEMPLATE_NAME : el nombre de la plantilla de instancia.

  • REGION : la región en la que se creará la plantilla de instancia.

  • MACHINE_TYPE : el tipo de máquina que se utilizará para las instancias creadas utilizando la plantilla de instancia.

Ir

Para crear una plantilla de instancias que configure instancias para que no consuman reservas, utilice el siguiente código de ejemplo: 

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 crear una plantilla de instancias que configure instancias para que no consuman reservas, utilice el siguiente código de ejemplo: 

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

Nodo.js

Para crear una plantilla de instancias que configure instancias para que no consuman reservas, utilice el siguiente código de ejemplo: 

// 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ón

Para crear una plantilla de instancias que configure instancias para que no consuman reservas, utilice el siguiente código de ejemplo: 

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 crear una plantilla de instancia que configure instancias para que no consuman reservas, realice una solicitud POST a uno de los siguientes métodos:

En el cuerpo de la solicitud, incluya el campo consumeReservationType y configúrelo en NO_RESERVATION .

Por ejemplo, para crear una plantilla de instancia regional y especificar que no se consuman reservas, realice una solicitud de la siguiente manera: 

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

Reemplace lo siguiente:

  • PROJECT_ID : el ID del proyecto en el que crear la plantilla de instancia.

  • INSTANCE_TEMPLATE_NAME : el nombre de la plantilla de instancia.

  • MACHINE_TYPE : el tipo de máquina que se utilizará para las instancias creadas utilizando la plantilla de instancia.

  • IMAGE_PROJECT : el proyecto de imagen que contiene la imagen del sistema operativo; por ejemplo, debian-cloud . Para obtener más información sobre los proyectos de imágenes admitidos, consulte Imágenes públicas .

  • IMAGE : especifique uno de los siguientes:

    • Una versión específica de la imagen del sistema operativo; por ejemplo, debian-12-bookworm-v20240617 .

    • Una familia de imágenes , que debe tener el formato family/ IMAGE_FAMILY . Esto especifica la imagen del sistema operativo más reciente y no obsoleta. Por ejemplo, si especifica family/debian-12 , se utiliza la última versión de la familia de imágenes de Debian 12. Para obtener más información sobre el uso de familias de imágenes, consulte Mejores prácticas de familias de imágenes .

Para obtener más información sobre la creación de plantillas de instancias, consulte Crear plantillas de instancias .

¿Qué sigue?