Crear y usar VM Spot

En esta página, se explica cómo crear y administrar VM Spot, lo que incluye lo siguiente:

• Cómo crear, iniciar e identificar VM Spot
• Cómo detectar, manejar y probar la interrupción de las VM Spot
• Prácticas recomendadas para las VM Spot

Las VMs Spot son instancias de máquina virtual (VM) que usan el modelo de aprovisionamiento spot. Las VMs Spot están disponibles con un descuento de hasta el 60% del precio según demanda de las VMs estándar. Para obtener más información, consulta la página de precios. Sin embargo, Compute Engine podría reclamar los recursos interrumpiendo las VMs Spot en cualquier momento. Las VMs Spot se recomiendan solo para cargas de trabajo tolerantes a errores que pueden soportar la interrupción de la VM.

Antes de comenzar

• Lee sobre las VMs Spot, en especial las limitaciones.
• Verifica que tengas suficiente cuota para los recursos que deseas solicitar. Para obtener más información, consulta Cuotas de asignación.
• Si aún no lo hiciste, configura la autenticación. La autenticación verifica tu identidad para acceder a los servicios y las APIs de Google Cloud . Para ejecutar código o muestras desde un entorno de desarrollo local, puedes autenticarte en Compute Engine seleccionando una de las siguientes opciones:

  Selecciona la pestaña que corresponda a la forma en que planeas usar las muestras de esta página:

  Console

  Cuando usas la consola de Google Cloud para acceder a los servicios y las APIs de Google Cloud , no necesitas configurar la autenticación.

  gcloud

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

     gcloud init

     Si usas un proveedor de identidad externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.

• Configura una región y una zona predeterminadas.

Terraform

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

1. Instala Google Cloud CLI.

2. Si usas un proveedor de identidad (IdP) externo, primero debes acceder a gcloud CLI con tu identidad federada.

3. Si usas una shell local, crea credenciales de autenticación locales para tu cuenta de usuario:

   gcloud auth application-default login

   No es necesario que lo hagas si usas Cloud Shell.

   Si se muestra un error de autenticación y usas un proveedor de identidad (IdP) externo, confirma que accediste a la gcloud CLI con tu identidad federada.

Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

REST

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

Instala Google Cloud CLI.

Si usas un proveedor de identidad externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.

Para obtener más información, consulta Autentícate para usar REST en la documentación de autenticación de Google Cloud .

Roles obligatorios

Para obtener los permisos que necesitas para crear una VM Spot, pídele a tu administrador que te otorgue el rol de IAM Administrador de instancias de Compute (v1) (roles/compute.instanceAdmin.v1) en el proyecto. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

Este rol predefinido contiene los permisos necesarios para crear una VM Spot. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

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

Preparación para crear VMs Spot

Antes de crear VMs de instancias interrumpibles para una carga de trabajo, completa los siguientes pasos:

1. Configura tu carga de trabajo para administrar la preferencia. Específicamente, te recomendamos que prepares una secuencia de comandos para controlar la interrupción que se ejecute como parte de tu carga de trabajo o que sea un archivo que puedas agregar en los metadatos de la VM para que se ejecute durante el apagado. Para obtener instrucciones, consulta Administra la interrupción de VMs Spot.

2. Te recomendamos que consultes los datos de las VMs Spot para ayudarte a elegir un tipo de máquina y una ubicación. Si seleccionas un tipo de máquina y una ubicación con una mayor disponibilidad de recursos, puedes aumentar las probabilidades de evitar errores de disponibilidad de recursos y de tener un tiempo de actividad más prolongado antes de la interrupción.

   • Para obtener datos históricos de precios y de interrupciones, que son especialmente útiles cuando se planifican cargas de trabajo a largo plazo, consulta Cómo ver los datos de precios y el porcentaje de interrupción de las VMs Spot.

   • Para obtener datos de disponibilidad actuales, que son especialmente útiles inmediatamente antes de crear VMs Spot para cargas de trabajo a corto plazo, consulta Cómo ver la disponibilidad de las VMs Spot.

3. Selecciona un método para crear VMs Spot. Te recomendamos que selecciones un método de la siguiente manera:

   • Si nunca creaste VMs Spot o tienes una carga de trabajo pequeña a corto plazo, consulta Crea una VM Spot.

   • Si ya creaste VMs Spot y deseas crear varias, por ejemplo, para una carga de trabajo grande a largo plazo, consulta Crea un grupo de instancias administrado (MIG) que use VMs Spot.

   • Si deseas crear y administrar VMs Spot con TPUs, consulta Solicita VMs Spot de TPU.

   Para obtener más información sobre las recomendaciones para crear VMs Spot, consulta las prácticas recomendadas.

Crea una VM Spot

Después de prepararte para crear VMs Spot, puedes crear una con uno de los siguientes métodos.

gcloud compute instances create VM_NAME \
    --machine-type=MACHINE_TYPE \
    --zone=ZONE \
    --image-family=IMAGE_FAMILY \
    --image-project=IMAGE_PROJECT \
    --provisioning-model=SPOT \
    --instance-termination-action=TERMINATION_ACTION \
    --preemption-notice-duration=PREEMPTION_NOTICE_DURATION \
    --metadata shutdown-script=SHUTDOWN_SCRIPT

resource "google_compute_instance" "spot_vm_instance" {
  name         = "spot-instance-name"
  machine_type = "f1-micro"
  zone         = "us-central1-c"

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-13"
    }
  }

  scheduling {
    preemptible                 = true
    automatic_restart           = false
    provisioning_model          = "SPOT"
    instance_termination_action = "STOP"
  }

  network_interface {
    # A default network is created for all GCP projects
    network = "default"
    access_config {
    }
  }
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
 "machineType": "zones/ZONE/machineTypes/MACHINE_TYPE",
 "name": "VM_NAME",
 "disks": [
   {
     "initializeParams": {
       "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
     },
     "boot": true
   }
 ],
 "scheduling":
 {
     "provisioningModel": "SPOT",
     "instanceTerminationAction": "TERMINATION_ACTION",
     "preemptionNoticeDuration": { "seconds": PREEMPTION_NOTICE_DURATION }
 },
"metadata": {
    "items": [
      {
        "key": "shutdown-script",
        "value": "SHUTDOWN_SCRIPT"
      }
    ]
  }
}

Inicia VM Spot

Al igual que otras VM, las VM Spot se inician cuando se crean. Del mismo modo, si se detienen las VM Spot, puedes reiniciar las VM para reanudar el estado RUNNING. Puedes detener y reiniciar las VM Spot interrumpidas tantas veces como desees, siempre que haya capacidad. Para obtener más información, consulta Ciclo de vida de las instancias de VM.

Si Compute Engine detiene una o más VM Spot en un grupo de instancias administrado (MIG) con ajuste de escala automático o un clúster de Google Kubernetes Engine (GKE), el grupo reinicia las VM cuando los recursos vuelven a estar disponibles.

Identifica el modelo de aprovisionamiento y la acción de finalización de una VM

Identifica el modelo de aprovisionamiento de una VM para ver si es una VM estándar, una VM Stock o una VM interrumpible. Para una VM Spot, también puedes identificar la acción de finalización. Puedes identificar el modelo de aprovisionamiento y la acción de finalización de una VM con laGoogle Cloud consola, la gcloud CLI o la API de Compute Engine.

gcloud compute instances describe VM_NAME

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

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	"cloud.google.com/go/compute/apiv1/computepb"
)

// isSpotVM checks if a given instance is a Spot VM or not.
func isSpotVM(w io.Writer, projectID, zone, instanceName string) (bool, error) {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	ctx := context.Background()
	client, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return false, fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer client.Close()

	req := &computepb.GetInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	instance, err := client.Get(ctx, req)
	if err != nil {
		return false, fmt.Errorf("GetInstance: %w", err)
	}

	isSpot := instance.GetScheduling().GetProvisioningModel() == computepb.Scheduling_SPOT.String()

	var isSpotMessage string
	if !isSpot {
		isSpotMessage = " not"
	}
	fmt.Fprintf(w, "Instance %s is%s spot\n", instanceName, isSpotMessage)

	return instance.GetScheduling().GetProvisioningModel() == computepb.Scheduling_SPOT.String(), nil
}

import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Scheduling;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeoutException;

public class CheckIsSpotVm {
  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 Google Cloud project you want to use.
    String projectId = "your-project-id";
    // Name of the virtual machine to check.
    String instanceName = "your-route-name";
    // Name of the zone you want to use. For example: "us-west3-b"
    String zone = "your-zone";

    boolean isSpotVm = isSpotVm(projectId, instanceName, zone);
    System.out.printf("Is %s spot VM instance - %s", instanceName, isSpotVm);
  }

  // Check if a given instance is Spot VM or not.
  public static boolean isSpotVm(String projectId, String instanceName, String zone)
          throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (InstancesClient client = InstancesClient.create()) {
      Instance instance = client.get(projectId, zone, instanceName);

      return instance.getScheduling().getProvisioningModel()
              .equals(Scheduling.ProvisioningModel.SPOT.name());
    }
  }
}

from google.cloud import compute_v1


def is_spot_vm(project_id: str, zone: str, instance_name: str) -> bool:
    """
    Check if a given instance is Spot VM or not.
    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone you want to use. For example: "us-west3-b"
        instance_name: name of the virtual machine to check.
    Returns:
        The Spot VM status of the instance.
    """
    instance_client = compute_v1.InstancesClient()
    instance = instance_client.get(
        project=project_id, zone=zone, instance=instance_name
    )
    return (
        instance.scheduling.provisioning_model
        == compute_v1.Scheduling.ProvisioningModel.SPOT.name
    )

Administra la interrupción de las VMs Spot

Para aprender a administrar la interrupción de las VMs Spot, consulta las siguientes secciones:

• Controla la interrupción.
• Detecta la interrupción de las VMs Spot.
• Prueba la configuración de interrupción.

Controla la interrupción

Cuando Compute Engine comienza a interrumpir una VM Spot, puedes intentar realizar acciones de limpieza antes de que la VM termine de apagarse. El control de la preferencia puede incluir la detención correcta de un proceso en ejecución y la transferencia del estado de tu carga de trabajo.

Puedes usar los siguientes métodos para controlar la interrupción de una VM Spot. Para obtener más información sobre cómo elegir dónde controlar la interrupción de tu carga de trabajo, consulta la definición de duración del aviso de interrupción.

• Controla la interrupción dentro de tu carga de trabajo. Recomendamos este método para las VMs Spot con una duración de aviso previo a la interrupción de 120 segundos. Específicamente, dentro de tu carga de trabajo, configura el código para controlar la preferencia hasta que comience la preferencia, como se explica en Detecta la preferencia dentro de una VM. Luego, tu código para controlar la interrupción se ejecuta durante la duración del aviso de interrupción. (De manera opcional, estas VMs también pueden especificar una secuencia de comandos de apagado, que se ejecuta durante un período de apagado).
• Controla la interrupción con una secuencia de comandos de apagado. Recomendamos este método para las VMs de Spot sin una duración de notificación previa a la interrupción, que es la configuración predeterminada. Específicamente, configura tu código para controlar la apropiación previa en una secuencia de comandos de cierre, como se muestra en el siguiente ejemplo. El script de apagado se ejecuta automáticamente durante un máximo de 30 segundos durante el período de apagado de mejor esfuerzo para cualquier tipo de apagado. Por lo tanto, es posible que desees configurar el código para controlar la interrupción de modo que solo se ejecute si se interrumpe la VM, como se explica en Cómo detectar la interrupción dentro de una VM.

Ejemplo de manejo de interrupciones

En el siguiente ejemplo de secuencia de comandos, se muestra cómo controlar la interrupción subiendo un archivo de punto de control a un bucket de Cloud Storage. Puedes ejecutar esta secuencia de comandos dentro de tu carga de trabajo o configurarla como una secuencia de comandos de apagado. Después de detener de forma correcta un programa especificado, la secuencia de comandos realiza una carga paralela de un archivo de punto de control a un bucket de Cloud Storage. Después de que la secuencia de comandos finaliza o se agota el tiempo de espera, el comando kill normal del sistema operativo detiene todos los procesos restantes.

#!/bin/bash

MY_PROGRAM="PROGRAM_NAME" # For example, "apache2" or "nginx"
MY_USER="LOCAL_USER"
CHECKPOINT="/home/$MY_USER/checkpoint.out"
BUCKET_NAME="BUCKET_NAME" # For example, "my-checkpoint-files" (without gs://)

echo "Shutting down!  Seeing if ${MY_PROGRAM} is running."

# Find the newest copy of $MY_PROGRAM
PID="$(pgrep -n "$MY_PROGRAM")"

if [[ "$?" -ne 0 ]]; then
  echo "${MY_PROGRAM} not running, shutting down immediately."
  exit 0
fi

echo "Sending SIGINT to $PID"
kill -2 "$PID"

# Portable waitpid equivalent
while kill -0 "$PID"; do
   sleep 1
done

echo "$PID is done, copying ${CHECKPOINT} to gs://${BUCKET_NAME} as ${MY_USER}"

su "${MY_USER}" -c "gcloud storage cp $CHECKPOINT gs://${BUCKET_NAME}/"

echo "Done uploading, shutting down."

Esta secuencia de comandos supone lo siguiente:

• La VM se creó, como mínimo, con acceso de lectura o escritura a Cloud Storage. Para obtener instrucciones sobre cómo crear una VM con los permisos adecuados, consulta la documentación sobre autenticación.

• Tienes un bucket de Cloud Storage existente y permiso para escribir en él.

Si quieres agregar esta secuencia de comandos a una VM, configúrala para que funcione con la carga de trabajo en tu VM y, luego, agrégala a tu carga de trabajo o a los metadatos de la VM.

1. Copia o descarga la secuencia de comandos de ejemplo:

   • Copia la secuencia de comandos anterior después de reemplazar lo siguiente:

     • PROGRAM_NAME: Es el nombre del proceso o programa que quieres cerrar. Por ejemplo, apache2 o nginx.
     • LOCAL_USER: Es el nombre de usuario con el que accediste a la máquina virtual.
     • BUCKET_NAME: Es el nombre del bucket de Cloud Storage en el que deseas guardar el archivo de punto de control del programa. Ten en cuenta que el nombre del bucket no comienza con gs:// en este caso.

   • Descarga la secuencia de comandos de ejemplo en tu estación de trabajo local. Luego, reemplaza las siguientes variables en el archivo:

     • PROGRAM_NAME: Es el nombre del proceso o programa que quieres cerrar. Por ejemplo, apache2 o nginx.
     • LOCAL_USER: Es el nombre de usuario con el que accediste a la máquina virtual.
     • BUCKET_NAME: Es el nombre del bucket de Cloud Storage en el que deseas guardar el archivo de punto de control del programa. Ten en cuenta que el nombre del bucket no comienza con gs:// en este caso.

2. Configura la detección de interrupciones y agrega la secuencia de comandos según dónde planees controlar la interrupción, ya sea dentro de tu carga de trabajo o dentro de una secuencia de comandos de apagado. Para obtener más información sobre cómo elegir dónde controlar la interrupción de tu carga de trabajo, consulta la definición de duración del aviso de interrupción.

   • Controla la preferencia dentro de tu carga de trabajo: Completa los siguientes pasos.

     1. Configura la secuencia de comandos para que espere hasta que comience la interrupción, como se explica en Cómo detectar la interrupción en una VM.

     2. Agrega el script a tu carga de trabajo.

   • Controla la interrupción con una secuencia de comandos de apagado: Completa los siguientes pasos.

     1. Te recomendamos que configures la secuencia de comandos para que se ejecute solo cuando el apagado se deba a una interrupción, como se explica en Cómo detectar una interrupción en una VM. Por ejemplo, no es necesario que subas un archivo de punto de control cuando se apaga tu VM porque finalizó la carga de trabajo.

     2. Agrega la secuencia de comandos de apagado a una VM nueva o a una VM existente.

Detecta la interrupción de las VM Spot

En las siguientes secciones, se explican los métodos que puedes usar para detectar la interrupción de las VMs de Spot.

• Detecta la interrupción dentro de una VM: Por ejemplo, usa este método para verificar la interrupción dentro de una secuencia de comandos de apagado o para activar el control de interrupciones para las VMs Spot con una duración de aviso de interrupción de 120 segundos.
• Ver operaciones de interrupción: Por ejemplo, usa este método cuando quieras determinar por qué se apagaron las VMs Spot.

Detecta la interrupción dentro de una VM

Para detectar si se está interrumpiendo una VM desde el interior de la VM, verifica el servidor de metadatos para el valor preempted en los metadatos predeterminados de tu VM. Por ejemplo, usa uno o más de los siguientes métodos según dónde planees controlar la preferencia.

• Si controlas la interrupción en una secuencia de comandos de apagado, verifica el valor actual de preempted. Puedes ejecutar el siguiente comando de curl desde tu VM para obtener el valor actual de preempted:

  curl "http://metadata.google.internal/computeMetadata/v1/instance/preempted" -H "Metadata-Flavor: Google"
  TRUE
  

  Si este valor es TRUE, Compute Engine interrumpió la VM; de lo contrario, es FALSE. Por ejemplo, usa este comando en una secuencia de comandos de apagado para realizar diferentes acciones según si el apagado se debió a una interrupción o no.

• Si controlas la preferencia dentro de tu carga de trabajo, espera hasta que preempted sea TRUE. Para esperar hasta que preempted sea TRUE, puedes agregar el parámetro de consulta ?wait_for_change=true a la URL del comando anterior. Con este parámetro de consulta, el comando realiza una solicitud HTTP GET pendiente que solo se muestra cuando cambian los metadatos y se interrumpe la VM.

  curl "http://metadata.google.internal/computeMetadata/v1/instance/preempted?wait_for_change=true" -H "Metadata-Flavor: Google"
  TRUE
  

  Este comando es útil cuando deseas activar el control de interrupciones fuera de una secuencia de comandos de apagado. Por ejemplo, usa este método para activar el control de interrupciones para las VMs Spot con una duración de aviso de interrupción de 120 segundos.

Cómo ver las operaciones de interrupción

Puedes ver las operaciones de interrupción de Compute Engine conGoogle Cloud console, la gcloud CLI o la API de Compute Engine.

gcloud compute operations list \
    --filter="operationType=compute.instances.preempted"

gcloud compute operations list \
    --filter="operationType=compute.instances.preempted AND targetLink:instances/BASE_INSTANCE_NAME"

NAME                  TYPE                         TARGET                                        HTTP_STATUS STATUS TIMESTAMP
systemevent-yyyyyyyy  compute.instances.preempted  us-central1-f/instances/example-instance-yyy  200         DONE   2015-04-02T12:12:10.881-07:00

gcloud compute operations describe SYSTEM_EVENT \
    --zone=ZONE

...
operationType: compute.instances.preempted
progress: 100
selfLink: https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central1-f/operations/systemevent-yyyyyyyy
startTime: '2015-04-02T12:12:10.881-07:00'
status: DONE
statusMessage: Instance was preempted.
...

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

operationType="compute.instances.preempted"

operationType="compute.instances.preempted" AND
targetLink="https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME

{
  "kind": "compute#operation",
  "id": "15041793718812375371",
  "name": "systemevent-yyyyyyyy",
  "zone": "https://www.googleapis.com/compute/v1/projects/my-project/zones/us-central1-f",
  "operationType": "compute.instances.preempted",
  "targetLink": "https://www.googleapis.com/compute/v1/projects/my-project/zones/us-central1-f/instances/example-instance",
  "targetId": "12820389800990687210",
  "status": "DONE",
  "statusMessage": "Instance was preempted.",
  ...
}

Prueba la configuración de interrupción

Puedes ejecutar eventos de mantenimiento simulados en tus VMs Spot para forzarlas a interrumpirse. Usa esta función para probar cómo tus cargas de trabajo detectan y controlan la interrupción. Para obtener información sobre cómo probar los eventos de mantenimiento en tus instancias, consulta Simula un evento de mantenimiento de host.

Prácticas recomendadas

Estas son algunas de las prácticas recomendadas para ayudarte a aprovechar al máximo las VM Spot.

• Ver la disponibilidad de recursos Antes de crear VMs Spot, o si intentas crear VMs Spot, pero sigues encontrando errores de disponibilidad de recursos, puedes ver la disponibilidad de un tipo de máquina en una región o zona específica. Comprobar la disponibilidad de los recursos ayuda a aumentar las posibilidades de crear VMs Spot correctamente. Para obtener instrucciones, consulta Cómo ver la disponibilidad de las VMs Spot.

• Consulta los datos históricos. Antes de crear VMs Spot, puedes consultar el porcentaje histórico de interrupción y los precios históricos de los tipos de máquinas que quieres que usen tus VMs Spot. Esta información te ayuda a comparar y elegir el tipo de máquina que mejor se adapte a tus necesidades de carga de trabajo y costos. Para obtener instrucciones, consulta Cómo ver la tasa de interrupción y los precios de las VMs Spot.

• Usa plantillas de instancias. En lugar de crear VM Spot una a la vez, puedes usar plantillas de instancias para crear varias VM Spot con las mismas propiedades. Las plantillas de instancias son necesarias para usar los MIG. De manera alternativa, también puedes crear varias VM Spot con la API de instancia masiva.

• Usa MIG para mejorar la disponibilidad de recursos y volver a crear automáticamente las VMs Spot. Usa MIG para hacer que las cargas de trabajo en las VM Spot sean más flexibles y resilientes. Por ejemplo, para evitar errores de disponibilidad de recursos, puedes aumentar la flexibilidad de tu carga de trabajo permitiendo lo siguiente:

  • Permite varias ubicaciones con MIG regionales.
  • Permite varios tipos de máquinas con la flexibilidad de instancias.

  Además, los MIG pueden reparar las VMs Spot interrumpidas recreándolas automáticamente.

• Elige tipos de máquina más pequeños. Los recursos de las VMs Spot se obtienen del exceso y la capacidad de copia de seguridad Google Cloud . La capacidad de las VMs Spot suele ser más fácil de obtener en tipos de máquinas más pequeños, es decir, tipos de máquinas con menos recursos, como la memoria y las CPU virtuales. Puedes encontrar más capacidad para las VM Spot si seleccionas un tipo personalizado de máquina más pequeño, pero la capacidad es aún más probable para tipos predefinidos de máquinas más pequeños. Por ejemplo, en comparación con la capacidad del tipo predefinido de máquina n2-standard-32, la capacidad para el tipo personalizado de máquina n2-custom-24-96 es más probable, pero la capacidad para el tipo predefinido de máquina n2-standard-16 es aún más probable.

• Ejecuta clústeres grandes de VM Spot durante las horas de menor actividad. La carga en los centros de datos de Google Cloud varía según la ubicación y la hora del día, pero, en general, es más baja por las noches y los fines de semana. En este sentido, a la noche y en los fines de semana son los mejores momentos para ejecutar clústeres grandes de VM Spot.

• Diseña tus cargas de trabajo para que sean tolerantes a errores y a la interrupción. Es importante estar preparado para el hecho de que hay cambios en los patrones de interrupción en diferentes momentos. Por ejemplo, si una zona sufre una interrupción parcial, se puede interrumpir una gran cantidad de VM Spot a fin de dejar lugar para las VM estándar que deben moverse como parte de la recuperación. Durante ese período, la tasa de interrupción se verá muy diferente a la de cualquier otro día. Si tu carga de trabajo da por hecho que las interrupciones siempre se hacen en grupos pequeños, es posible que no estés preparado para tal evento.

• Intenta crear las VM Spot que se interrumpiron. Si se interrumpieron tus VM Spot, intenta crear VM nuevas una o dos veces antes de volver a las VM estándar. Según tus requisitos, puede ser una buena idea combinar VM estándar y VM Spot en tus clústeres para garantizar que el trabajo avance a un ritmo adecuado.

• Guarda el progreso para mitigar la interrupción. Administra las notificaciones de cierre y de interrupción guardando el progreso de tu carga de trabajo para que pueda continuar donde lo dejó, en lugar de comenzar desde cero. Por ejemplo, guarda el progreso cada vez que se detecte una interrupción, como se explica en Administra la interrupción de las VMs Spot. Para mayor resiliencia, también considera guardar el progreso a intervalos regulares, no solo cuando se detecta la interrupción.

Próximos pasos

• Conéctate a tu instancia de VM.
• Obtén más información sobre las secuencias de comandos de apagado.
• Obtén más información sobre cómo limitar el entorno de ejecución de una VM.
• Obtén información sobre las plantillas de instancias.
• Obtén información sobre los MIG.