Evitar que las instancias de proceso consuman reservas

---

En este documento se 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 de zona 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, haz lo siguiente:

• Configura las instancias para que no consuman reservas, tal como se describe en este documento.

• Crea o actualiza instancias con propiedades que no coincidan con la reserva.

Puedes evitar consumir reservas cuando quieras usar tus instancias para tareas como pruebas, depuración o implementaciones aisladas.

Limitaciones

Solo puedes actualizar una instancia para que no consuma reservas si está configurada para consumir automáticamente las reservas coincidentes.

Antes de empezar

• Si aún no lo has hecho, configura la autenticación. La autenticación verifica tu identidad para acceder a Google Cloud servicios y APIs. Para ejecutar código o ejemplos desde un entorno de desarrollo local, puedes autenticarte en Compute Engine seleccionando una de las siguientes opciones:

  Select the tab for how you plan to use the samples on this page:

  Console

  When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

  gcloud

  1. Instala Google Cloud CLI. Después de la instalación, inicializa la CLI de Google Cloud ejecutando el siguiente comando:

     gcloud init

     Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

     Nota: Si ya has instalado la CLI de gcloud, asegúrate de que tienes la versión más reciente ejecutando gcloud components update.
  2. Set a default region and zone.

  Go

  Para usar las Go muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

  Instala Google Cloud CLI.

  Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

  Nota: Si ya has instalado la CLI de gcloud, asegúrate de que tienes la versión más reciente ejecutando gcloud components update.

  If you're using a local shell, then create local authentication credentials for your user account:

  gcloud auth application-default login

  You don't need to do this if you're using Cloud Shell.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para obtener más información, consulta Set up authentication for a local development environment.

  Java

  Para usar las Java muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

  Instala Google Cloud CLI.

  Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

  Nota: Si ya has instalado la CLI de gcloud, asegúrate de que tienes la versión más reciente ejecutando gcloud components update.

  If you're using a local shell, then create local authentication credentials for your user account:

  gcloud auth application-default login

  You don't need to do this if you're using Cloud Shell.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para obtener más información, consulta Set up authentication for a local development environment.

  Node.js

  Para usar las Node.js muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

  Instala Google Cloud CLI.

  Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

  Nota: Si ya has instalado la CLI de gcloud, asegúrate de que tienes la versión más reciente ejecutando gcloud components update.

  If you're using a local shell, then create local authentication credentials for your user account:

  gcloud auth application-default login

  You don't need to do this if you're using Cloud Shell.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para obtener más información, consulta Set up authentication for a local development environment.

  Python

  Para usar las Python muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

  Instala Google Cloud CLI.

  Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

  Nota: Si ya has instalado la CLI de gcloud, asegúrate de que tienes la versión más reciente ejecutando gcloud components update.

  If you're using a local shell, then create local authentication credentials for your user account:

  gcloud auth application-default login

  You don't need to do this if you're using Cloud Shell.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para obtener más información, consulta Set up authentication for a local development environment.

  REST

  Para usar las muestras de la API REST de esta página en un entorno de desarrollo local, debes usar las credenciales que proporciones a la CLI de gcloud.

  Instala Google Cloud CLI.

  Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

  Nota: Si ya has instalado la CLI de gcloud, asegúrate de que tienes la versión más reciente ejecutando gcloud components update.

  Para obtener más información, consulta el artículo Autenticarse para usar REST de la documentación sobre autenticación de Google Cloud .

Roles obligatorios

Para obtener los permisos que necesitas para evitar que una instancia de cálculo consuma reservas, pide a tu administrador que te conceda el rol de gestión de identidades y accesos Administrador de instancias de Compute (v. 1) (roles/compute.instanceAdmin.v1) en el proyecto. Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

Este rol predefinido contiene los permisos necesarios para evitar que una instancia de computación consuma reservas. Para ver los permisos exactos que se necesitan, despliega la sección Permisos necesarios:

Permisos obligatorios

Se necesitan los siguientes permisos para evitar que una instancia de proceso consuma reservas:

• Para crear reservas, sigue estos pasos: compute.reservations.create en el proyecto
• Para crear instancias, sigue estos pasos:
  • compute.instances.create en el proyecto
  • Para usar una imagen personalizada para crear la VM, haz clic en compute.images.useReadOnly en la imagen.
  • Para usar una captura para crear la VM, compute.snapshots.useReadOnly en la captura
  • Para usar una plantilla de instancia para crear la VM, haz clic en compute.instanceTemplates.useReadOnly en la plantilla de instancia.
  • Para asignar una red antigua a la VM, haz lo siguiente: compute.networks.use en el proyecto
  • Para especificar una dirección IP estática para la máquina virtual, compute.addresses.use en el proyecto
  • Para asignar una dirección IP externa a la VM cuando se usa una red antigua, haz lo siguiente: 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 de VPC, compute.subnetworks.useExternalIp en el proyecto o en la subred elegida.
  • Para definir los metadatos de la instancia de VM de la VM: compute.instances.setMetadata en el proyecto,
  • Para definir etiquetas en la máquina virtual, compute.instances.setTags en la máquina virtual
  • Para definir etiquetas de la VM, compute.instances.setLabels en la VM
  • Para definir una cuenta de servicio que use la VM, haz lo siguiente en la VM: compute.instances.setServiceAccount
  • Para crear un disco para la VM compute.disks.create del proyecto, sigue estos pasos:
  • Para adjuntar un disco en modo de solo lectura o de lectura y escritura, haz lo siguiente: compute.disks.use en el disco
  • Para adjuntar un disco en modo de solo lectura, compute.disks.useReadOnly en el disco.
• Para crear plantillas de instancia, sigue estos pasos: compute.instanceTemplates.create en el proyecto

También puedes obtener estos permisos con roles personalizados u otros roles predefinidos.

Evitar el consumo de reservas

Para evitar que una instancia de proceso consuma reservas, asigna a su propiedad de afinidad de reserva (reservationAffinity) el valor "no consumir reservas". Esta propiedad controla si una instancia puede consumir reservas coincidentes, una reserva específica o ninguna reserva.

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

• Evitar el consumo en una instancia ya creada

• Evitar el consumo al crear una instancia

• Evitar el consumo al crear instancias en bloque

• Evitar el consumo al crear una plantilla de instancia

Evitar el consumo en una instancia

Puedes actualizar una instancia en ejecución para que deje de consumir reservas automáticamente. Debes reiniciar la instancia para que los cambios se apliquen, tal como se describe en esta sección.

Para evitar que una instancia utilice reservas, selecciona una de las siguientes opciones:

gcloud

1. Crea un archivo YAML vacío.

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

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

   Haz los cambios siguientes:

   • INSTANCE_NAME: el nombre de la instancia.

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

   • ZONE: la zona en la que se encuentra la instancia.

3. En el archivo de configuración YAML, asigna el valor consumeReservationType a NO_RESERVATION:

   reservationAffinity:
     consumeReservationType: NO_RESERVATION
   

   Nota: Para evitar que se produzca un error como "ERROR: (gcloud.compute.instances.update-from-file) Cannot parse YAML: [Expected type for field value, found True (type )]", añada comillas (' ') a los valores de etiqueta yes o no en el archivo de configuración de la instancia exportada. Esto indica que los valores son cadenas, no valores booleanos.

4. Para actualizar la instancia y reiniciarla, usa el comando gcloud compute instances update-from-file con la marca --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
   

   Haz los cambios siguientes:

   • INSTANCE_NAME: el nombre de la instancia.

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

   • ZONE: la zona en la que se encuentra la instancia.

REST

1. Para ver las propiedades de una instancia, envía una solicitud GET al método instances.get:

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

   Haz los cambios siguientes:

   • PROJECT_ID: el ID del proyecto en el que has creado la instancia.

   • ZONE: la zona en la que se encuentra la instancia.

   • INSTANCE_NAME: el nombre de la instancia.

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

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

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

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

   • En el cuerpo de la solicitud, usa el resultado de la solicitud GET que has editado 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, consulta Actualizar las propiedades de una instancia.

Evitar el consumo al crear una instancia

Para crear una instancia de proceso que no pueda consumir reservas, selecciona una de las siguientes opciones:

Consola

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

   Ir a Crear una instancia

2. En el campo Name (Nombre), introduce un nombre para la instancia.

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

4. Especifica el tipo de máquina que quieres usar en la instancia.

5. En el menú de navegación, haz clic en Opciones avanzadas.

6. En la sección Reservas, selecciona No usar una reserva.

7. Haz clic en Crear.

gcloud

Para crear una instancia que no pueda consumir reservas, usa el comando gcloud compute instances create con la marca --reservation-affinity definida como none:

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

Haz los cambios siguientes:

• INSTANCE_NAME: el nombre de la instancia.

• MACHINE_TYPE: el tipo de máquina que se va a usar en la instancia.

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

Go

Para crear una instancia que no pueda consumir reservas, usa 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, usa 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);
    }
  }
}

Node.js

Para crear una instancia que no pueda consumir reservas, usa 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();

Python

Para crear una instancia que no pueda consumir reservas, usa 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)

REST

Para crear una instancia que no pueda consumir reservas, haz una solicitud POST al método instances.insert. En el cuerpo de la solicitud, incluye el campo consumeReservationType con el valor 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"
  }
}

Haz los cambios siguientes:

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

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

• INSTANCE_NAME: el nombre de la instancia.

• MACHINE_TYPE: el tipo de máquina que se va a usar en la instancia.

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

• IMAGE: especifica una de las siguientes opciones:

  • Una versión específica de la imagen del SO. Por ejemplo, debian-12-bookworm-v20240617.

  • Una familia de imágenes, que debe tener el formato family/IMAGE_FAMILY. Especifica la imagen del SO más reciente que no está obsoleta. Por ejemplo, si especificas family/debian-12, se usará la versión más reciente de la familia de imágenes de Debian 12. Para obtener más información sobre cómo usar familias de imágenes, consulte las prácticas recomendadas para familias de imágenes.

Para obtener más información sobre cómo crear una instancia, consulta Crear e iniciar una instancia de Compute Engine.

Evitar el consumo al crear instancias en bloque

Para crear instancias de computación en bloque que no puedan consumir reservas, selecciona una de las siguientes opciones:

gcloud

Para crear instancias en bloque que no puedan consumir reservas, usa el comando gcloud compute instances bulk create con la marca --reservation-affinity definida como none.

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

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

Haz los cambios siguientes:

• COUNT: número de instancias que se van a crear.

• MACHINE_TYPE: el tipo de máquina que se va a usar en las instancias.

• NAME_PATTERN: el patrón de nombre de las instancias. Para sustituir una secuencia de números en un nombre de instancia, usa una secuencia de caracteres de almohadilla (#). Por ejemplo, si se usa instance-# como patrón de nombre, se generarán instancias con nombres que empiecen por instance-1, instance-2 y así sucesivamente hasta el número de instancias especificado por COUNT.

• ZONE: la zona en la que se crearán las instancias en bloque.

REST

Para crear instancias en bloque que no puedan consumir reservas, haz una solicitud al método POST instances.bulkInsert. En el cuerpo de la solicitud, incluye el campo consumeReservationType con el valor NO_RESERVATION.

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

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

Haz los cambios siguientes:

• PROJECT_ID: ID del proyecto en el que se crearán las instancias en bloque.

• ZONE: la zona en la que se crearán las instancias en bloque.

• COUNT: número de instancias que se van a crear.

• NAME_PATTERN: el patrón de nombre de las instancias. Para sustituir una secuencia de números en un nombre de instancia, usa una secuencia de caracteres de almohadilla (#). Por ejemplo, si se usa instance-# como patrón de nombre, se generarán instancias con nombres que empiecen por instance-1, instance-2 y así sucesivamente hasta el número de instancias especificado por COUNT.

• MACHINE_TYPE: el tipo de máquina que se va a usar en las instancias.

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

• IMAGE: especifica una de las siguientes opciones:

  • Una versión específica de la imagen del SO. Por ejemplo, debian-12-bookworm-v20240617.

  • Una familia de imágenes, que debe tener el formato family/IMAGE_FAMILY. Especifica la imagen del SO más reciente que no está obsoleta. Por ejemplo, si especificas family/debian-12, se usará la versión más reciente de la familia de imágenes de Debian 12. Para obtener más información sobre cómo usar familias de imágenes, consulte las prácticas recomendadas para familias de imágenes.

Para obtener más información sobre cómo crear instancias en bloque, consulta Crear VMs en bloque.

Evitar el consumo al crear una plantilla de instancia

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

• Evita que las instancias de cálculo de un grupo de instancias gestionado (MIG) consuman reservas cuando hagas lo siguiente:

  • Crear un MIG

  • Aplicar nuevas configuraciones de instancia en un MIG

• Crear una instancia que no consuma reservas

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

Consola

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

   Ir a Crear una plantilla de instancia

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

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

4. En la sección Configuración de la máquina, especifica el tipo de máquina que se va a usar en las instancias creadas con la plantilla.

5. Despliega la sección Opciones avanzadas y sigue estos pasos:

   1. Despliega la sección Gestión.

   2. En la sección Reservas, selecciona No usar una reserva.

6. Haz clic en Crear.

gcloud

Para crear una plantilla de instancia que configure las instancias para que no consuman reservas, usa el comando gcloud compute instances-templates create con la marca --reservation-affinity definida como none.

Para crear una plantilla de instancia regional que configure las instancias para que no consuman reservas, ejecuta el siguiente comando. Si quieres crear una plantilla de instancia global, usa el mismo comando sin la marca --instance-template-region.

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

Haz los cambios siguientes:

• 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 usará en las instancias creadas con la plantilla de instancia.

Go

Para crear una plantilla de instancia que configure las instancias para que no consuman reservas, usa 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 instancia que configure las instancias para que no consuman reservas, usa 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);
    }
  }
}

Node.js

Para crear una plantilla de instancia que configure las instancias para que no consuman reservas, usa 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();

Python

Para crear una plantilla de instancia que configure las instancias para que no consuman reservas, usa 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)

REST

Para crear una plantilla de instancia que configure las instancias para que no consuman reservas, haz una solicitud POST a uno de los siguientes métodos:

• Para crear una plantilla de instancia global, usa el método instanceTemplates.insert.

• Para crear una plantilla de instancia regional, usa el método regionInstanceTemplates.insert.

En el cuerpo de la solicitud, incluye el campo consumeReservationType y asigna el valor NO_RESERVATION.

Por ejemplo, para crear una plantilla de instancia regional y especificar que no se utilicen reservas, haz una solicitud como la siguiente:

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

Haz los cambios siguientes:

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

• INSTANCE_TEMPLATE_NAME: el nombre de la plantilla de instancia.

• MACHINE_TYPE: el tipo de máquina que se usará en las instancias creadas con la plantilla de instancia.

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

• IMAGE: especifica una de las siguientes opciones:

  • Una versión específica de la imagen del SO. Por ejemplo, debian-12-bookworm-v20240617.

  • Una familia de imágenes, que debe tener el formato family/IMAGE_FAMILY. Especifica la imagen del SO más reciente que no está obsoleta. Por ejemplo, si especificas family/debian-12, se usará la versión más reciente de la familia de imágenes de Debian 12. Para obtener más información sobre cómo usar familias de imágenes, consulte las prácticas recomendadas para familias de imágenes.

Para obtener más información sobre cómo crear plantillas de instancia, consulta el artículo Crear plantillas de instancia.

Siguientes pasos

• Modificar reservas

• Eliminar reservas