Criar e usar VMs do Spot

Nesta página, explicamos como criar e gerenciar VMs do Spot, incluindo:

  • como criar, iniciar e identificar VMs do Spot;
  • como detectar, processar e testar a preempção das VMs do Spot;
  • práticas recomendadas para VMs do Spot;

As VMs do Spot são instâncias de máquina virtual (VM, na sigla em inglês) com o modelo de provisionamento do Spot. As VMs Spot estão disponíveis com um desconto de até 60% a 91% em comparação com o preço das VMs padrão. No entanto, o Compute Engine pode liberar os recursos antecipando as VMs spot a qualquer momento. As VMs do Spot são recomendadas apenas para aplicativos tolerantes a falhas que resistam à preempção da VM. Verifique se o aplicativo consegue processar a preempção antes de decidir criar VMs do Spot.

Antes de começar

  • Leia a documentação conceitual sobre as VMs Spot:
    • Analise as limitações e os preços das VMs do Spot.
    • Para evitar que as VMs do Spot consumam suas cotas para CPUs, GPUs e discos das VMs padrão, solicite a cota preemptiva para as VMs do Spot.
  • Configure a autenticação, caso ainda não tenha feito isso. A autenticação é o processo de verificação da sua identidade para acesso a serviços e APIs do Google Cloud. Para executar códigos ou amostras de um ambiente de desenvolvimento local, autentique-se no Compute Engine selecionando uma das seguintes opções:

    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. Install the Google Cloud CLI, then initialize it by running the following command: 

      gcloud init
    2. Set a default region and zone.

      3. Terraform

      Para usar os exemplos do Terraform nesta página em um ambiente de desenvolvimento local, instale e inicialize a gcloud CLI e, em seguida, configure o Application Default Credentials com suas credenciais de usuário.

      1. Install the Google Cloud CLI.

      2. To initialize the gcloud CLI, run the following command: 

        gcloud init

      3. 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.

      Confira mais informações em Set up authentication for a local development environment.

      REST

      Para usar as amostras da API REST nesta página em um ambiente de desenvolvimento local, use as credenciais fornecidas para gcloud CLI.

        Install the Google Cloud CLI, then initialize it by running the following command: 

        gcloud init

      Para mais informações, consulte Autenticar para usar REST na documentação de autenticação do Google Cloud.

Criar uma VM do Spot

Crie uma VM do Spot usando o console do Cloud, a CLI gcloud ou a API Compute Engine. Uma VM do Spot é qualquer VM configurada para usar o modelo de provisionamento do Spot:

  • Modelo de provisionamento de VM definido como Spot no console do Cloud
  • --provisioning-model=SPOT na CLI gcloud
  • "provisioningModel": "SPOT" na API Compute Engine

Console

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

    Acesse "Criar uma instância"

  2. Em seguida, faça o seguinte:

    1. Na seção Políticas de disponibilidade, selecione Spot na lista Modelo de provisionamento de VM. Essa configuração desativa as opções de reinicialização automática e manutenção de host para a VM e ativa a opção de ação de encerramento.
    2. Opcional: na lista No encerramento da VM, selecione o que acontecerá quando o Compute Engine encerrar a VM:
      • Para interromper a VM durante a preempção, selecione Parar (padrão).
      • Para excluir a VM durante a preempção, selecione Excluir.

  3. Opcional: especifique outras opções de VM. Para mais informações, consulte Como criar e iniciar uma instância de VM.

  4. Para criar e iniciar a VM, clique em Criar.

gcloud

Para criar uma VM a partir da CLI gcloud, use o comando gcloud compute instances create. Para criar VMs do Spot, é preciso incluir a sinalização --provisioning-model=SPOT. Opcionalmente, também é possível especificar uma ação de encerramento para VMs do Spot ao também incluir a sinalização --instance-termination-action.

gcloud compute instances create VM_NAME \
    --provisioning-model=SPOT \
    --instance-termination-action=TERMINATION_ACTION

Substitua:

  • VM_NAME: nome da nova VM.
  • TERMINATION_ACTION: opcional: especifique qual ação realizar quando o Compute Engine forçar a interrupção da VM STOP (comportamento padrão) ou DELETE.

Para mais informações sobre as opções que você pode especificar ao criar uma VM, consulte Como criar e iniciar uma instância de VM. Por exemplo, para criar VMs do Spot com um tipo de máquina e uma imagem especificados, use este comando:

gcloud compute instances create VM_NAME \
    --provisioning-model=SPOT \
    [--image=IMAGE | --image-family=IMAGE_FAMILY] \
    --image-project=IMAGE_PROJECT \
    --machine-type=MACHINE_TYPE \
    --instance-termination-action=TERMINATION_ACTION

Substitua:

  • VM_NAME: nome da nova VM.
  • IMAGE: especifique uma destas opções:
    • IMAGE: uma versão específica de uma imagem pública ou da família de imagens. Por exemplo, uma imagem específica é --image=debian-10-buster-v20200309.
    • Uma família de imagens. Isso cria a VM a partir da imagem do SO mais recente e não obsoleta. Por exemplo, se você especificar --image-family=debian-10, o Compute Engine criará uma VM a partir da versão mais recente da imagem do SO na família de imagens Debian 10.
  • IMAGE_PROJECT: o projeto que contém a imagem. Por exemplo, se você especificar debian-10 como a família de imagens, especifique debian-cloud como o projeto da imagem;
  • MACHINE_TYPE: o tipo de máquina predefinido ou personalizado da nova VM;

  • TERMINATION_ACTION: opcional: especifique qual ação realizar quando o Compute Engine forçar a interrupção da VM STOP (comportamento padrão) ou DELETE.

    Para ver uma lista dos tipos de máquinas disponíveis em uma zona, use o comando gcloud compute machine-types list com a sinalização --zones.

Terraform

É possível usar um recurso do Terraform para criar uma instância do Spot usando o bloco de programação


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

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

REST

Para criar uma VM a partir da API Compute Engine, use o método instances.insert. Especifique um tipo de máquina e um nome para a VM. Também é possível especificar uma imagem para o disco de inicialização.

Para criar VMs do Spot, é necessário incluir o campo "provisioningModel": spot. Opcionalmente, também é possível especificar uma ação de encerramento para VMs do Spot ao também incluir o campo "instanceTerminationAction".

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

Substitua:

  • PROJECT_ID: o ID do projeto em que a VM será criada;
  • ZONE: a zona em que a VM será criada. A zona também precisa ser compatível com o tipo de máquina a ser usado na nova VM;
  • MACHINE_TYPE: o tipo de máquina predefinido ou personalizado da nova VM;
  • VM_NAME: o nome da nova VM;
  • IMAGE_PROJECT: o projeto que contém a imagem. Por exemplo, se você especificar family/debian-10 como a família de imagens, especifique debian-cloud como o projeto da imagem.
  • IMAGE: especifique uma destas opções:
    • Uma versão específica de uma imagem pública. Por exemplo, uma imagem específica é "sourceImage": "projects/debian-cloud/global/images/debian-10-buster-v20200309", em que debian-cloud é o IMAGE_PROJECT.
    • Uma família de imagens. Isso cria a VM a partir da imagem do SO mais recente e não obsoleta. Por exemplo, se você especificar "sourceImage": "projects/debian-cloud/global/images/family/debian-10" em que debian-cloud é o IMAGE_PROJECT, o Compute Engine criará uma VM a partir da versão mais recente da imagem do SO no Debian: 10 famílias de imagens.
  • TERMINATION_ACTION: opcional: especifique qual ação realizar quando o Compute Engine forçar a interrupção da VM STOP (comportamento padrão) ou DELETE.

Para mais informações sobre as opções que você pode especificar ao criar uma VM, consulte Como criar e iniciar uma instância de VM.

Go


import (
	"context"
	"fmt"
	"io"

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

// createSpotInstance creates a new Spot VM instance with Debian 10 operating system.
func createSpotInstance(w io.Writer, projectID, zone, instanceName string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"

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

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

	req := &computepb.GetFromFamilyImageRequest{
		Project: "debian-cloud",
		Family:  "debian-11",
	}

	image, err := imagesClient.GetFromFamily(ctx, req)
	if err != nil {
		return fmt.Errorf("getImageFromFamily: %w", err)
	}

	diskType := fmt.Sprintf("zones/%s/diskTypes/pd-standard", zone)
	disks := []*computepb.AttachedDisk{
		{
			AutoDelete: proto.Bool(true),
			Boot:       proto.Bool(true),
			InitializeParams: &computepb.AttachedDiskInitializeParams{
				DiskSizeGb:  proto.Int64(10),
				DiskType:    proto.String(diskType),
				SourceImage: proto.String(image.GetSelfLink()),
			},
			Type: proto.String(computepb.AttachedDisk_PERSISTENT.String()),
		},
	}

	req2 := &computepb.InsertInstanceRequest{
		Project: projectID,
		Zone:    zone,
		InstanceResource: &computepb.Instance{
			Name:        proto.String(instanceName),
			Disks:       disks,
			MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/%s", zone, "n1-standard-1")),
			NetworkInterfaces: []*computepb.NetworkInterface{
				{
					Name: proto.String("global/networks/default"),
				},
			},
			Scheduling: &computepb.Scheduling{
				ProvisioningModel: proto.String(computepb.Scheduling_SPOT.String()),
			},
		},
	}
	op, err := instancesClient.Insert(ctx, req2)
	if err != nil {
		return fmt.Errorf("insert: %w", err)
	}

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

	instance, err := instancesClient.Get(ctx, &computepb.GetInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	})

	if err != nil {
		return fmt.Errorf("createInstance: %w", err)
	}

	fmt.Fprintf(w, "Instance created: %v\n", instance)
	return nil
}

Java 


import com.google.cloud.compute.v1.AccessConfig;
import com.google.cloud.compute.v1.AccessConfig.Type;
import com.google.cloud.compute.v1.Address.NetworkTier;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.ImagesClient;
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.Scheduling;
import com.google.cloud.compute.v1.Scheduling.ProvisioningModel;
import java.io.IOException;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateSpotVm {
  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-instance-name";
    // Name of the zone you want to use. For example: "us-west3-b"
    String zone = "your-zone";

    createSpotInstance(projectId, instanceName, zone);
  }

  // Create a new Spot VM instance with Debian 11 operating system.
  public static Instance createSpotInstance(String projectId, String instanceName, String zone)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    String image;
    // 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 (ImagesClient imagesClient = ImagesClient.create()) {
      image = imagesClient.getFromFamily("debian-cloud", "debian-11").getSelfLink();
    }
    AttachedDisk attachedDisk = buildAttachedDisk(image, zone);
    String machineTypes = String.format("zones/%s/machineTypes/%s", zone, "n1-standard-1");

    // Send an instance creation request to the Compute Engine API and wait for it to complete.
    Instance instance =
            createInstance(projectId, zone, instanceName, attachedDisk, true, machineTypes, false);

    System.out.printf("Spot instance '%s' has been created successfully", instance.getName());

    return instance;
  }

  // disks: a list of compute_v1.AttachedDisk objects describing the disks
  //     you want to attach to your new instance.
  // machine_type: machine type of the VM being created. This value uses the
  //     following format: "zones/{zone}/machineTypes/{type_name}".
  //     For example: "zones/europe-west3-c/machineTypes/f1-micro"
  // external_access: boolean flag indicating if the instance should have an external IPv4
  //     address assigned.
  // spot: boolean value indicating if the new instance should be a Spot VM or not.
  private static Instance createInstance(String projectId, String zone, String instanceName,
                                         AttachedDisk disk, boolean isSpot, String machineType,
                                         boolean externalAccess)
          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 (InstancesClient client = InstancesClient.create()) {
      Instance instanceResource =
              buildInstanceResource(instanceName, disk, machineType, externalAccess, isSpot);

      InsertInstanceRequest build = InsertInstanceRequest.newBuilder()
              .setProject(projectId)
              .setRequestId(UUID.randomUUID().toString())
              .setZone(zone)
              .setInstanceResource(instanceResource)
              .build();
      client.insertCallable().futureCall(build).get(60, TimeUnit.SECONDS);

      return client.get(projectId, zone, instanceName);
    }
  }

  private static Instance buildInstanceResource(String instanceName, AttachedDisk disk,
                                                String machineType, boolean externalAccess,
                                                boolean isSpot) {
    NetworkInterface networkInterface =
            networkInterface(externalAccess);
    Instance.Builder builder = Instance.newBuilder()
            .setName(instanceName)
            .addDisks(disk)
            .setMachineType(machineType)
            .addNetworkInterfaces(networkInterface);

    if (isSpot) {
      // Set the Spot VM setting
      Scheduling.Builder scheduling = builder.getScheduling()
              .toBuilder()
              .setProvisioningModel(ProvisioningModel.SPOT.name())
              .setInstanceTerminationAction("STOP");
      builder.setScheduling(scheduling);
    }

    return builder.build();
  }

  private static NetworkInterface networkInterface(boolean externalAccess) {
    NetworkInterface.Builder build = NetworkInterface.newBuilder()
            .setNetwork("global/networks/default");

    if (externalAccess) {
      AccessConfig.Builder accessConfig = AccessConfig.newBuilder()
              .setType(Type.ONE_TO_ONE_NAT.name())
              .setName("External NAT")
              .setNetworkTier(NetworkTier.PREMIUM.name());
      build.addAccessConfigs(accessConfig.build());
    }

    return build.build();
  }

  private static AttachedDisk buildAttachedDisk(String sourceImage, String zone) {
    AttachedDiskInitializeParams initializeParams = AttachedDiskInitializeParams.newBuilder()
            .setSourceImage(sourceImage)
            .setDiskSizeGb(10)
            .setDiskType(String.format("zones/%s/diskTypes/pd-standard", zone))
            .build();
    return AttachedDisk.newBuilder()
            .setInitializeParams(initializeParams)
            // Remember to set auto_delete to True if you want the disk to be deleted
            // when you delete your VM instance.
            .setAutoDelete(true)
            .setBoot(true)
            .build();
  }
}

Python 

from __future__ import annotations

import re
import sys
from typing import Any
import warnings

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def get_image_from_family(project: str, family: str) -> compute_v1.Image:
    """
    Retrieve the newest image that is part of a given family in a project.

    Args:
        project: project ID or project number of the Cloud project you want to get image from.
        family: name of the image family you want to get image from.

    Returns:
        An Image object.
    """
    image_client = compute_v1.ImagesClient()
    # List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details
    newest_image = image_client.get_from_family(project=project, family=family)
    return newest_image


def disk_from_image(
    disk_type: str,
    disk_size_gb: int,
    boot: bool,
    source_image: str,
    auto_delete: bool = True,
) -> compute_v1.AttachedDisk:
    """
    Create an AttachedDisk object to be used in VM instance creation. Uses an image as the
    source for the new disk.

    Args:
         disk_type: the type of disk you want to create. This value uses the following format:
            "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "zones/us-west3-b/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        boot: boolean flag indicating whether this disk should be used as a boot disk of an instance
        source_image: source image to use when creating this disk. You must have read access to this disk. This can be one
            of the publicly available images or an image from one of your projects.
            This value uses the following format: "projects/{project_name}/global/images/{image_name}"
        auto_delete: boolean flag indicating whether this disk should be deleted with the VM that uses it

    Returns:
        AttachedDisk object configured to be created using the specified image.
    """
    boot_disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.source_image = source_image
    initialize_params.disk_size_gb = disk_size_gb
    initialize_params.disk_type = disk_type
    boot_disk.initialize_params = initialize_params
    # Remember to set auto_delete to True if you want the disk to be deleted when you delete
    # your VM instance.
    boot_disk.auto_delete = auto_delete
    boot_disk.boot = boot
    return boot_disk


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(
    project_id: str,
    zone: str,
    instance_name: str,
    disks: list[compute_v1.AttachedDisk],
    machine_type: str = "n1-standard-1",
    network_link: str = "global/networks/default",
    subnetwork_link: str = None,
    internal_ip: str = None,
    external_access: bool = False,
    external_ipv4: str = None,
    accelerators: list[compute_v1.AcceleratorConfig] = None,
    preemptible: bool = False,
    spot: bool = False,
    instance_termination_action: str = "STOP",
    custom_hostname: str = None,
    delete_protection: bool = False,
) -> compute_v1.Instance:
    """
    Send an instance creation request to the Compute Engine API and wait for it to complete.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        disks: a list of compute_v1.AttachedDisk objects describing the disks
            you want to attach to your new instance.
        machine_type: machine type of the VM being created. This value uses the
            following format: "zones/{zone}/machineTypes/{type_name}".
            For example: "zones/europe-west3-c/machineTypes/f1-micro"
        network_link: name of the network you want the new instance to use.
            For example: "global/networks/default" represents the network
            named "default", which is created automatically for each project.
        subnetwork_link: name of the subnetwork you want the new instance to use.
            This value uses the following format:
            "regions/{region}/subnetworks/{subnetwork_name}"
        internal_ip: internal IP address you want to assign to the new instance.
            By default, a free address from the pool of available internal IP addresses of
            used subnet will be used.
        external_access: boolean flag indicating if the instance should have an external IPv4
            address assigned.
        external_ipv4: external IPv4 address to be assigned to this instance. If you specify
            an external IP address, it must live in the same region as the zone of the instance.
            This setting requires `external_access` to be set to True to work.
        accelerators: a list of AcceleratorConfig objects describing the accelerators that will
            be attached to the new instance.
        preemptible: boolean value indicating if the new instance should be preemptible
            or not. Preemptible VMs have been deprecated and you should now use Spot VMs.
        spot: boolean value indicating if the new instance should be a Spot VM or not.
        instance_termination_action: What action should be taken once a Spot VM is terminated.
            Possible values: "STOP", "DELETE"
        custom_hostname: Custom hostname of the new VM instance.
            Custom hostnames must conform to RFC 1035 requirements for valid hostnames.
        delete_protection: boolean value indicating if the new virtual machine should be
            protected against deletion or not.
    Returns:
        Instance object.
    """
    instance_client = compute_v1.InstancesClient()

    # Use the network interface provided in the network_link argument.
    network_interface = compute_v1.NetworkInterface()
    network_interface.network = network_link
    if subnetwork_link:
        network_interface.subnetwork = subnetwork_link

    if internal_ip:
        network_interface.network_i_p = internal_ip

    if external_access:
        access = compute_v1.AccessConfig()
        access.type_ = compute_v1.AccessConfig.Type.ONE_TO_ONE_NAT.name
        access.name = "External NAT"
        access.network_tier = access.NetworkTier.PREMIUM.name
        if external_ipv4:
            access.nat_i_p = external_ipv4
        network_interface.access_configs = [access]

    # Collect information into the Instance object.
    instance = compute_v1.Instance()
    instance.network_interfaces = [network_interface]
    instance.name = instance_name
    instance.disks = disks
    if re.match(r"^zones/[a-z\d\-]+/machineTypes/[a-z\d\-]+$", machine_type):
        instance.machine_type = machine_type
    else:
        instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"

    instance.scheduling = compute_v1.Scheduling()
    if accelerators:
        instance.guest_accelerators = accelerators
        instance.scheduling.on_host_maintenance = (
            compute_v1.Scheduling.OnHostMaintenance.TERMINATE.name
        )

    if preemptible:
        # Set the preemptible setting
        warnings.warn(
            "Preemptible VMs are being replaced by Spot VMs.", DeprecationWarning
        )
        instance.scheduling = compute_v1.Scheduling()
        instance.scheduling.preemptible = True

    if spot:
        # Set the Spot VM setting
        instance.scheduling.provisioning_model = (
            compute_v1.Scheduling.ProvisioningModel.SPOT.name
        )
        instance.scheduling.instance_termination_action = instance_termination_action

    if custom_hostname is not None:
        # Set the custom hostname for the instance
        instance.hostname = custom_hostname

    if delete_protection:
        # Set the delete protection bit
        instance.deletion_protection = True

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

    # Wait for the create operation to complete.
    print(f"Creating the {instance_name} instance in {zone}...")

    operation = instance_client.insert(request=request)

    wait_for_extended_operation(operation, "instance creation")

    print(f"Instance {instance_name} created.")
    return instance_client.get(project=project_id, zone=zone, instance=instance_name)


def create_spot_instance(
    project_id: str, zone: str, instance_name: str
) -> compute_v1.Instance:
    """
    Create a new Spot VM instance with Debian 10 operating system.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.

    Returns:
        Instance object.
    """
    newest_debian = get_image_from_family(project="debian-cloud", family="debian-11")
    disk_type = f"zones/{zone}/diskTypes/pd-standard"
    disks = [disk_from_image(disk_type, 10, True, newest_debian.self_link)]
    instance = create_instance(project_id, zone, instance_name, disks, spot=True)
    return instance

Para criar várias VMs spot com as mesmas propriedades, é possível criar um modelo de instância e usar o modelo para criar um grupo gerenciado de instâncias (MIG). Para mais informações, consulte Práticas recomendadas.

Iniciar VMs do Spot

Assim como outras VMs, as VMs do Spot começam na criação. Da mesma forma, se as VMs do Spot forem interrompidas, será possível reiniciá-las para retomar o estado RUNNING. É possível interromper e reiniciar VMs do Spot interrompidas quantas quiser, desde que haja capacidade. Para mais informações, consulte Ciclo de vida da instância da VM.

Se o Compute Engine interromper uma ou mais VMs do Spot em um grupo gerenciado de gerenciadas (MIG, na sigla em inglês) de escalonamento automático ou um cluster do Google Kubernetes Engine (GKE), o grupo reiniciará as VMs quando os recursos ficarem disponíveis novamente.

Identificar o modelo de provisionamento e a ação de encerramento de uma VM

Identifique o modelo de provisionamento de uma VM para ver se ela é uma VM padrão, uma VM do Spot ou uma VM preemptiva. Em uma VM do Spot, também é possível identificar a ação de encerramento. É possível identificar o modelo de provisionamento e a ação de encerramento de uma VM usando o console do Google Cloud, a CLI gcloud ou a API Compute Engine.

Console

  1. Acesse a página Instâncias da VM.

    Acessar a página "Instâncias de VM"

  2. Clique no Nome da VM que você quer identificar. A página Detalhes da instância de VM será aberta.

  3. Acesse a seção Gerenciamento na parte inferior da página. Na subseção Políticas de disponibilidade, verifique as seguintes opções:

    • Se o Modelo de provisionamento da VM estiver definido como Spot, a VM será uma VM do Spot.
      • No encerramento da VM indica qual ação será realizada quando o Compute Engine forçar a interrupção da VM, seja Parar ou Excluir a VM.
    • Caso contrário, se o Modelo de provisionamento da VM estiver definido como Padrão ou —:
      • Se a opção Capacidade de preempção estiver definida como Ativada, a VM será uma VM preemptiva.
      • Caso contrário, a VM será uma VM padrão.

gcloud

Para descrever uma VM na CLI gcloud, use o comando gcloud compute instances describe:

gcloud compute instances describe VM_NAME

em que VM_NAME é o nome da VM que você quer verificar.

Na saída, verifique o campo scheduling para identificar a VM:

  • Se a saída inclui o campo provisioningModel definido como SPOT, semelhante a este, a VM é uma VM do Spot.

    ...
scheduling:
...
provisioningModel: SPOT
instanceTerminationAction: TERMINATION_ACTION
...

    em que TERMINATION_ACTION indica qual ação será executada quando o Compute Engine forçar a interrupção da VM, seja parar (STOP) ou excluir (DELETE) a VM. Se o campo instanceTerminationAction estiver ausente, o valor padrão será STOP.

  • Caso contrário, se a saída inclui o campo provisioningModel definido como standard ou se a saída omite o campo provisioningModel:

    • Se a saída inclui o campo preemptible definido como true, a VM é uma VM preemptiva.
    • Caso contrário, a VM será uma VM padrão.

REST

Para descrever uma VM a partir da API Compute Engine, use o método instances.get:

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

Substitua:

  • PROJECT_ID: o ID do projeto em que a VM está;
  • ZONE: a zona em que está localizada a VM.
  • VM_NAME: o nome da VM que você quer verificar.

Na saída, verifique o campo scheduling para identificar a VM:

  • Se a saída inclui o campo provisioningModel definido como SPOT, semelhante a este, a VM é uma VM do Spot.

    {
  ...
  "scheduling":
  {
     ...
     "provisioningModel": "SPOT",
     "instanceTerminationAction": "TERMINATION_ACTION"
     ...
  },
  ...
}

    em que TERMINATION_ACTION indica qual ação será executada quando o Compute Engine forçar a interrupção da VM, seja parar (STOP) ou excluir (DELETE) a VM. Se o campo instanceTerminationAction estiver ausente, o valor padrão será STOP.

  • Caso contrário, se a saída inclui o campo provisioningModel definido como standard ou se a saída omite o campo provisioningModel:

    • Se a saída inclui o campo preemptible definido como true, a VM é uma VM preemptiva.
    • Caso contrário, a VM será uma VM padrão.

Go


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
}

Java 


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

Python 

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
    )

Processar a preempção com um script de desligamento

Quando o Compute Engine interrompe uma VM Spot, é possível usar um script de desligamento para tentar executar ações de limpeza antes que a VM sofra uma interrupção forçada. Por exemplo, é possível interromper normalmente um processo em execução e copiar um arquivo de checkpoint para o Cloud Storage. O período máximo de desligamento é menor para uma notificação de preempção do que para um desligamento iniciado pelo usuário. Para mais informações sobre o período de desativação de uma notificação de preempção, consulte Processo de preempção na documentação conceitual das VMs do Spot.

Confira a seguir um exemplo de script de encerramento que pode ser adicionado a uma VM do Spot em execução ou ao criar uma nova VM do Spot. Esse script é executado quando a instância começa a ser encerrada e antes que o comando kill normal do sistema operacional interrompa todos os processos restantes. Após o encerramento normal do programa desejado, o script fará o upload paralelo de um arquivo de checkpoint para um bucket do Cloud Storage.

#!/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."

Para esse script, presume-se que:

  • A instância foi criada com pelo menos acesso de leitura/gravação ao Cloud Storage. Para instruções sobre como criar uma VM com os escopos apropriados, consulte a documentação de autenticação.

  • você tenha um bucket do Cloud Storage e permissão para gravar nele.

Para adicionar esse script a uma VM, configure-o para trabalhar com um aplicativo na VM e adicione-o aos metadados da VM.

  1. Copie ou faça o download do script de encerramento:

    • Copie o script de encerramento anterior após substituir:

      • PROGRAM_NAME é o nome do processo ou programa que você quer encerrar; Por exemplo, apache2 ou nginx.
      • LOCAL_USER é o nome de usuário que você usou para fazer login na máquina virtual;
      • BUCKET_NAME é o nome do bucket do Cloud Storage em que você quer salvar o arquivo de checkpoint do programa. Nesse caso, o nome do bucket não começa com gs://.

    • Faça o download do script de encerramento na estação de trabalho local e substitua as seguintes variáveis no arquivo:

      • [PROGRAM_NAME] é o nome do processo ou programa que você quer encerrar. Por exemplo, apache2 ou nginx.
      • [LOCAL_USER] é o nome de usuário que você usou para fazer login na máquina virtual.
      • [BUCKET_NAME] é o nome do bucket do Cloud Storage em que você quer salvar o arquivo de checkpoint do programa. Observe que o nome do bucket não começa com gs:// nesse caso.

  2. Adicione o script de encerramento a uma nova VM ou a uma VM atual.

Detectar a preempção das VMs do Spot

Determine se as VMs do Spot foram interrompidas pelo Compute Engine usando o console do Google Cloud, a CLI gcloud ou a API Compute Engine.

Console

É possível verificar se uma VM foi interrompida verificando os registros de atividades do sistema.

  1. No console do Google Cloud, acesse a página Registros.

    Ir para os registros

  2. Selecione o projeto e clique em Continuar.

  3. Adicione compute.instances.preempted ao campo filtrar por rótulo ou pesquisa de texto.

  4. Outra opção é inserir um nome de VM se você quiser ver as operações de preempção de uma determinada VM.

  5. Pressione Enter para aplicar os filtros especificados. O console do Google Cloud atualiza a lista de registros para exibir somente as operações em que uma VM foi preemptiva.

  6. Selecione uma operação na lista para ver detalhes sobre a instância que passou por interrupção forçada.

gcloud

Use o comando gcloud compute operations list com um parâmetro de filtro para receber uma lista de eventos de preempção no projeto.

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

Também é possível usar outros parâmetros de filtro para ampliar o escopo dos resultados. Por exemplo, para ver eventos de preempção apenas de instâncias dentro de um grupo gerenciado de instâncias, use o seguinte comando:

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

em que BASE_INSTANCE_NAME é o nome de base especificado como prefixo para os nomes de todas as VMs nesse grupo gerenciado de instâncias.

A saída será assim:

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

Um tipo de operação compute.instances.preempted indica que a instância da VM foi interrompida. É possível usar o comando gcloud compute operations describe para mais informações sobre uma determinada operação de preempção.

gcloud compute operations describe SYSTEM_EVENT \
    --zone=ZONE

Substitua:

  • SYSTEM_EVENT: o evento do sistema na saída do comando gcloud compute operations list. Por exemplo, systemevent-xxxxxxxx.
  • ZONE: a zona do evento do sistema, por exemplo, us-central1-f.

O resultado será assim:

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

REST

Para ver uma lista das operações recentes do sistema para um projeto e uma zona específicos, use o método zoneOperations.get.

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

Substitua:

Para que a resposta mostre apenas operações de preempção, adicione um filtro à solicitação de API:

operationType="compute.instances.preempted"

Como alternativa, para ver as operações de preempção de uma VM específica, adicione um parâmetro targetLink ao filtro:

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

Substitua o seguinte: + PROJECT_ID: o ID do projeto. + ZONE: a zona. + VM_NAME: o nome de uma VM específica nessa zona e projeto.

A resposta contém uma lista das operações recentes. Por exemplo, uma preempção é semelhante a:

{
  "kind": "compute#operation",
  "id": "15041793718812375371",
  "name": "systemevent-xxxxxxxx",
  "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.",
  ...
}

Outra opção é determinar se uma VM passou por interrupção forçada dentro da própria VM. Isso é útil quando você quer lidar com um encerramento decorrente de uma preempção do Compute Engine de maneira diferente de um encerramento normal em um script de encerramento. Para fazer isso, basta verificar o valor preempted do servidor de metadados nos metadados padrão da VM.

Por exemplo, use curl na VM para receber o valor de preempted:

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

Se esse valor for TRUE, significa que a VM passou por interrupção forçada pelo Compute Engine. Caso contrário, será FALSE.

Para usar isso fora de um script de encerramento, anexe ?wait_for_change=true ao URL. Será executada uma solicitação HTTP GET pendente que só retorna quando os metadados são alterados e a VM foi interrompida.

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

Como testar as configurações de preempção

Para forçar a interrupção, é possível executar eventos de manutenção simulados nas instâncias. Use esse recurso para testar como seus aplicativos processam VMs do Spot. Leia Simular um evento de manutenção do host para aprender a testar eventos de manutenção nas instâncias.

Também é possível interromper a instância de VM para simular a preempção da VM. Isso pode ser usado em vez de simular um evento de manutenção e para evitar limites de cota.

Práticas recomendadas

Veja algumas práticas recomendadas para ajudar você a aproveitar ao máximo as VMs do Spot.

  • Use modelos de instância. Em vez de criar VMs do Spot uma de cada vez, é possível usar modelos de instância para criar várias VMs do Spot com as mesmas propriedades. Os modelos de instância são necessários para usar MIGs. Outra alternativa possível é criar várias VMs do Spot usando a API de instância em massa.

  • Use MIGs para distribuir regionalmente e recriar automaticamente as VMs do Spot. Use MIGs para tornar as cargas de trabalho das VMs do Spot mais flexíveis e resilientes. Por exemplo, use MIGs regionais para distribuir VMs em várias zonas, o que ajuda a mitigar erros de disponibilidade de recursos. Além disso, use a recuperação automática para recriar automaticamente as VMs do Spot após a interrupção forçada.

  • Escolha menores tipos de máquina. Os recursos de VMs do Spot saem da capacidade extra e de backup do Google Cloud. A capacidade de VMs do Spot geralmente é mais fácil para menores tipos de máquinas, o que significa tipos de máquina com menos recursos, como vCPUs e memória. É possível conseguir mais capacidade para VMs do Spot selecionando um menor tipo de máquina personalizado, mas a capacidade é ainda mais provável para menores tipos de máquina predefinidos. Por exemplo, em comparação com a capacidade do tipo de máquina predefinido n2-standard-32, a capacidade para o tipo de máquina personalizado n2-custom-24-96 é mais provável, mas a capacidade para o tipo de máquina predefinido n2-standard-16 é ainda mais provável.

  • Executar clusters grandes de VMs do Spot durante os horários de pico. A carga nos data centers do Google Cloud varia de acordo com o local e a hora do dia, mas costuma ser mais baixa nas noites e fins de semana. Assim, noites e fins de semana são os melhores momentos para executar grandes clusters de VMs do Spot.

  • Desenvolver os aplicativos para serem tolerantes a falhas e preempção. É importante se preparar para mudanças nos padrões de preempção em diferentes momentos. Por exemplo, se uma zona sofrer uma interrupção parcial, uma grande quantidade de VMs do Spot poderão ser interrompidas à força para liberar espaço para VMs padrão que precisam ser movidas como parte da recuperação. Nesse pequeno intervalo de tempo, a taxa de preempção será muito diferente de qualquer outro dia. Se seu aplicativo considera que as preempções sempre ocorrem em pequenos grupos, pode ser que você não esteja preparado para um evento desse tipo.

  • Tentar criar novamente VMs do Spot que foram interrompidas. Se as VMs do Spot tiverem sido interrompidas, tente criar novas VMs do Spot uma ou duas vezes antes de voltar às VMs padrão. Dependendo dos seus requisitos, é recomendável combinar VMs padrão e do Spot nos clusters para garantir que o trabalho ocorra em um ritmo adequado.

  • Usar scripts de encerramento. Gerencie avisos de interrupção e de preempção com um script de encerramento que salva o progresso de um job. Dessa forma, é possível continuar de onde você parou em vez de começar do zero.

A seguir