Esta página foi traduzida pela API Cloud Translation.

Crie e use VMs do Spot

Esta página explica como criar e gerir VMs de capacidade instantânea, incluindo o seguinte:

Como criar, iniciar e identificar VMs do Spot
Como detetar, processar e testar a preemptividade das VMs de Spot
Práticas recomendadas para VMs do Spot

As VMs do Spot são instâncias de máquinas virtuais (VMs) com o modelo de aprovisionamento do Spot. As VMs do 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 reaver os recursos ao antecipar VMs spot em qualquer altura. As VMs do Spot são recomendadas apenas para aplicações com tolerância a falhas que podem resistir à remoção preventiva de VMs. Certifique-se de que a sua aplicação consegue processar a preempção antes de decidir criar VMs Spot.

Antes de começar

Leia a documentação conceptual para VMs do Spot:

Reveja as limitações e os preços das VMs Spot.
Para impedir que as VMs do Spot consumam as suas quotas de CPUs, GPUs e discos de VMs padrão, pondere pedir uma quota anulável para VMs do Spot.

Se ainda não o tiver feito, configure a autenticação. A autenticação valida a sua identidade para aceder a Google Cloud serviços e APIs. Para executar código ou exemplos a partir de um ambiente de desenvolvimento local, pode autenticar-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. Instale a CLI Google Cloud. Após a instalação, inicialize a CLI gcloud executando o seguinte comando:
  gcloud init
  Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.
  
  Nota: se instalou a CLI gcloud anteriormente, certifique-se de que tem a versão mais recente executando gcloud components update.
2. Set a default region and zone.
Terraform

Para usar os exemplos do Terraform nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as credenciais predefinidas da aplicação com as suas credenciais de utilizador.
Para mais informações, consulte Set up authentication for a local development environment.
REST

Para usar os exemplos da API REST nesta página num ambiente de desenvolvimento local, usa as credenciais que fornece à CLI gcloud.
Para mais informações, consulte o artigo Autenticar para usar REST na Google Cloud documentação de autenticação.

Crie uma VM do Spot

Crie uma VM de Spot através da Google Cloud consola, da CLI gcloud ou da API Compute Engine. Uma VM do Spot é qualquer VM configurada para usar o modelo de aprovisionamento do Spot:

Modelo de aprovisionamento de VMs definido como Spot na Google Cloud consola
--provisioning-model=SPOT na CLI gcloud
"provisioningModel": "SPOT" na API Compute Engine

Consola

Na Google Cloud consola, aceda à página Criar uma instância.

Aceda a Criar uma instância
No menu de navegação, clique em Avançadas. No painel Avançadas apresentado, conclua os seguintes passos:
1. Na secção Modelo de aprovisionamento, selecione Spot na lista Modelo de aprovisionamento de VMs.
2. Opcional: para selecionar a ação de rescisão que ocorre quando o Compute Engine antecipa a VM, conclua os seguintes passos:
  1. Expanda a secção Definições avançadas do modelo de aprovisionamento de VMs.
  2. Na lista On VM termination, selecione uma das seguintes opções:
    - Para parar a VM durante a remoção preventiva, selecione Parar (predefinição).
    - Para eliminar a VM durante a preempção, selecione Eliminar.
Opcional: especifique outras opções de configuração. Para mais informações, consulte o artigo Opções de configuração durante a criação da instância.
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 de capacidade instantânea, tem de incluir a flag --provisioning-model=SPOT. Opcionalmente, também pode especificar uma ação de encerramento para VMs Spot incluindo também a flag --instance-termination-action.

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

Substitua o seguinte:

VM_NAME: name da nova VM.
TERMINATION_ACTION: Opcional: especifique a ação a tomar quando o Compute Engine antecipa a VM, STOP (comportamento predefinido) ou DELETE.

Para mais informações sobre as opções que pode especificar quando cria uma VM, consulte o artigo Opções de configuração durante a criação da instância. Por exemplo, para criar VMs do Spot com um tipo de máquina e uma imagem especificados, use o seguinte 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 o seguinte:

VM_NAME: name da nova VM.
IMAGE: especifique uma das seguintes 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. Isto cria a VM a partir da imagem do SO não descontinuada mais recente. Por exemplo, se especificar --image-family=debian-10, o Compute Engine cria uma VM a partir da versão mais recente da imagem do SO na família de imagens do Debian 10.
IMAGE_PROJECT: o projeto que contém a imagem. Por exemplo, se especificar debian-10 como a família de imagens, especifique debian-cloud como o projeto de imagens.
MACHINE_TYPE: o predefinido ou personalizado, tipo de máquina para a nova VM.
TERMINATION_ACTION: Opcional: especifique a ação a tomar quando o Compute Engine antecipa a VM, STOP (comportamento predefinido) ou DELETE.

Para obter uma lista dos tipos de máquinas disponíveis numa zona, use o comando gcloud compute machine-types list com a flag --zones.

Terraform

Pode usar um recurso do Terraform para criar uma instância de reserva com um bloco de agendamento


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. Tem de especificar um tipo de máquina e um nome para a VM. Opcionalmente, também pode especificar uma imagem para o disco de arranque.

Para criar VMs do Spot, tem de incluir o campo "provisioningModel": spot. Opcionalmente, também pode especificar uma ação de rescisão para VMs de spot incluindo também 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 o seguinte:

PROJECT_ID: o ID do projeto do projeto no qual criar a VM.
ZONE: a zona onde criar a VM. A zona também tem de suportar o tipo de máquina a usar para a nova VM.
MACHINE_TYPE: o predefinido ou personalizado, tipo de máquina para a nova VM.
VM_NAME: o nome da nova VM.
IMAGE_PROJECT: o projeto que contém a imagem. Por exemplo, se especificar family/debian-10 como a família de imagens, especifique debian-cloud como o projeto de imagens.
IMAGE: especifique uma das seguintes 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" onde debian-cloud é o IMAGE_PROJECT.
- Uma família de imagens. Isto cria a VM a partir da imagem do SO não descontinuada mais recente. Por exemplo, se especificar "sourceImage": "projects/debian-cloud/global/images/family/debian-10" onde debian-cloud é o IMAGE_PROJECT, o Compute Engine cria uma VM a partir da versão mais recente da imagem do SO na família de imagens do Debian 10.
TERMINATION_ACTION: Opcional: especifique a ação a tomar quando o Compute Engine antecipa a VM, STOP (comportamento predefinido) ou DELETE.

Para mais informações sobre as opções que pode especificar quando cria uma VM, consulte o artigo Opções de configuração durante a criação da instância.

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 de capacidade instantânea com as mesmas propriedades, pode criar um modelo de instância e usar o modelo para criar um grupo de instâncias geridas (GIG). Para mais informações, consulte as práticas recomendadas.

Inicie VMs do Spot

Tal como outras VMs, as VMs do Spot são iniciadas após a criação. Da mesma forma, se as VMs de Spot forem paradas, pode reiniciá-las para retomar o estado RUNNING. Pode parar e reiniciar VMs Spot antecipadas quantas vezes quiser, desde que haja capacidade. Para mais informações, consulte o artigo Ciclo de vida da instância de VM.

Se o Compute Engine parar uma ou mais VMs de spot num grupo de instâncias geridas (GIG) de escala automática ou num cluster do Google Kubernetes Engine (GKE), o grupo reinicia as VMs quando os recursos ficarem novamente disponíveis.

Identifique o modelo de aprovisionamento e a ação de rescisão de uma VM

Identifique o modelo de aprovisionamento de uma VM para ver se é uma VM padrão, uma VM Spot ou uma VM com opção de remoção. Para uma VM Spot, também pode identificar a ação de encerramento. Pode identificar o modelo de aprovisionamento e a ação de rescisão de uma VM através da Google Cloud consola, da CLI gcloud ou da API Compute Engine.

Consola

Aceda à página Instâncias de VM.

Aceda à página de instâncias de VM
Clique no Nome da VM que quer identificar. É apresentada a página Detalhes da instância de VM.
Aceda à secção Gestão na parte inferior da página. Na subsecção Políticas de disponibilidade, selecione as seguintes opções:
- Se o modelo de aprovisionamento de VMs estiver definido como Spot, a VM é uma VM Spot.
  - On VM termination indica que ação tomar quando o Compute Engine antecipa a VM, Stop ou Delete a VM.
- Caso contrário, se o modelo de aprovisionamento de VMs estiver definido como Standard ou —:
  - Se a opção Capacidade de interrupção estiver definida como Ativada, a VM é uma VM com capacidade de interrupção.
  - Caso contrário, a VM é uma VM padrão.

gcloud

Para descrever uma VM a partir da CLI gcloud, use o comando gcloud compute instances describe:

gcloud compute instances describe VM_NAME

onde VM_NAME é o nome da VM que quer verificar.

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

Se a saída incluir o campo provisioningModel definido como SPOT, semelhante ao seguinte, a VM é uma VM de Spot.
```
...
scheduling:
...
provisioningModel: SPOT
instanceTerminationAction: TERMINATION_ACTION
...
```
em que TERMINATION_ACTION indica a ação a tomar quando o Compute Engine antecipa a VM, ou seja, parar (STOP) ou eliminar (DELETE) a VM. Se o campo instanceTerminationAction estiver em falta, o valor predefinido é STOP.
Caso contrário, se a saída incluir o campo provisioningModel definido como standard ou se a saída omitir o campo provisioningModel:
- Se a saída incluir o campo preemptible definido como true, a VM é uma VM preemptível.
- Caso contrário, a VM é 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 o seguinte:

PROJECT_ID: o ID do projeto do projeto em que a VM se encontra.
ZONE: a zona onde a VM está localizada.
VM_NAME: o nome da VM que quer verificar.

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

Se a saída incluir o campo provisioningModel definido como SPOT, semelhante ao seguinte, a VM é uma VM de Spot.
```
{
  ...
  "scheduling":
  {
     ...
     "provisioningModel": "SPOT",
     "instanceTerminationAction": "TERMINATION_ACTION"
     ...
  },
  ...
}
```
em que TERMINATION_ACTION indica a ação a tomar quando o Compute Engine antecipa a VM, ou seja, parar (STOP) ou eliminar (DELETE) a VM. Se o campo instanceTerminationAction estiver em falta, o valor predefinido é STOP.
Caso contrário, se a saída incluir o campo provisioningModel definido como standard ou se a saída omitir o campo provisioningModel:
- Se a saída incluir o campo preemptible definido como true, a VM é uma VM preemptível.
- Caso contrário, a VM é 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
    )

Faça a gestão da remoção de VMs do Spot

Para saber como gerir a antecipação de VMs Spot, reveja as seguintes secções:

Faça a gestão da preempção com um script de encerramento.
Detetar a remoção preventiva de VMs do Spot.
Teste as definições de prioridade.

Faça a gestão da preempção com um script de encerramento

Quando o Compute Engine antecipa uma VM Spot, pode usar um script de encerramento para tentar realizar ações de limpeza antes de a VM ser antecipada. Por exemplo, pode parar graciosamente um processo em execução e copiar um ficheiro de ponto de verificação para o Cloud Storage. Em particular, a duração máxima do período de encerramento é mais curta para um aviso de preemptão do que para um encerramento iniciado pelo utilizador. Para mais informações acerca do período de encerramento de um aviso de preempção, consulte o processo de preempção na documentação conceptual das VMs de spot.

Segue-se um exemplo de um script de encerramento que pode adicionar a uma VM Spot em execução ou adicionar ao criar uma nova VM Spot. Este script é executado quando a VM começa a ser encerrada, antes de o comando kill normal do sistema operativo parar todos os processos restantes. Depois de parar corretamente o programa pretendido, o script faz um carregamento paralelo de um ficheiro de ponto de verificação para um contentor 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."

Este script pressupõe o seguinte:

A VM foi criada com, pelo menos, acesso de leitura/escrita ao Cloud Storage. Para ver instruções sobre como criar uma VM com os âmbitos adequados, consulte a documentação de autenticação.
Tem um contentor do Cloud Storage existente e autorização para escrever nele.

Para adicionar este script a uma VM, configure o script para funcionar com uma aplicação na VM e adicione-o aos metadados da VM.

Copie ou transfira o script de encerramento:
- Copie o script de encerramento anterior depois de substituir o seguinte:
  - PROGRAM_NAME é o nome do processo ou do programa que quer encerrar. Por exemplo, apache2 ou nginx.
  - LOCAL_USER é o nome de utilizador com o qual tem sessão iniciada na máquina virtual.
  - BUCKET_NAME é o nome do contentor do Cloud Storage onde quer guardar o ficheiro de ponto de verificação do programa. Tenha em atenção que, neste caso, o nome do contentor não começa por gs://.
- Transfira o script de encerramento para a sua estação de trabalho local e, em seguida, substitua as seguintes variáveis no ficheiro:
  - [PROGRAM_NAME] é o nome do processo ou do programa que quer encerrar. Por exemplo, apache2 ou nginx.
  - [LOCAL_USER] é o nome de utilizador com o qual tem sessão iniciada na máquina virtual.
  - [BUCKET_NAME] é o nome do contentor do Cloud Storage onde quer guardar o ficheiro de ponto de verificação do programa. Tenha em atenção que, neste caso, o nome do contentor não começa com gs://.
Adicione o script de encerramento a uma nova VM ou a uma VM existente.

Detete a remoção preventiva de VMs do Spot

Determine se as VMs de Spot foram anuladas pelo Compute Engine através da Google Cloud console, CLI gcloud ou da API Compute Engine.

Consola

Pode verificar se uma VM foi anulada verificando os registos de atividade do sistema.

Na Google Cloud consola, aceda à página Registos.

Aceda aos registos
Selecione o projeto e clique em Continuar.
Adicione compute.instances.preempted ao campo filtrar por etiqueta ou pesquisa de texto.
Opcionalmente, também pode introduzir um nome de VM se quiser ver operações de remoção preventiva para uma VM específica.
Prima Enter para aplicar os filtros especificados. A Google Cloud consola atualiza a lista de registos para mostrar apenas as operações em que uma MV foi anulada.
Selecione uma operação na lista para ver detalhes sobre a VM que foi anulada.

gcloud

Use o comando gcloud compute operations list com um parâmetro filter para obter uma lista de eventos de preemptção no seu projeto.

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

Opcionalmente, pode usar parâmetros de filtro adicionais para restringir ainda mais o âmbito dos resultados. Por exemplo, para ver eventos de antecipação apenas para instâncias num grupo de instâncias gerido, use o seguinte comando:

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

onde BASE_INSTANCE_NAME é o nome base especificado como um prefixo para os nomes de todas as VMs neste grupo de instâncias gerido.

O resultado é semelhante ao seguinte:

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 de compute.instances.preempted indica que a instância de VM foi anulada. Pode usar o comando gcloud compute operations describe para obter mais informações sobre uma operação de preemptiva específica.

gcloud compute operations describe SYSTEM_EVENT \
    --zone=ZONE

Substitua o seguinte:

SYSTEM_EVENT: o evento do sistema a partir do resultado do comando gcloud compute operations list, por exemplo, systemevent-xxxxxxxx.
ZONE: a zona do evento do sistema, por exemplo, us-central1-f.

O resultado é semelhante ao seguinte:

...
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 obter uma lista de 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 o seguinte:

PROJECT_ID: um ID do projeto.
ZONE: uma zona.

Opcionalmente, para restringir o âmbito da resposta de modo a mostrar apenas operações de antecipação, pode adicionar um filtro ao seu pedido de API:

operationType="compute.instances.preempted"

Em alternativa, para ver as operações de antecipaçã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: o fuso horário. + VM_NAME: o nome de uma VM específica nesta zona e neste projeto.

A resposta contém uma lista de operações recentes. Por exemplo, uma preempção tem um aspeto semelhante ao seguinte:

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

Em alternativa, pode determinar se uma VM foi anulada a partir da própria VM. Isto é útil se quiser processar um encerramento devido a uma preempção do Compute Engine de forma diferente de um encerramento normal num script de encerramento. Para tal, basta verificar o valor preempted no metadados predefinidos da VM no servidor de metadados.

Por exemplo, use curl a partir da sua VM para obter o valor de preempted:

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

Se este valor for TRUE, a VM foi anulada pelo Compute Engine. Caso contrário, é FALSE.

Se quiser usar isto fora de um script de encerramento, pode anexar ?wait_for_change=true ao URL. Isto executa um pedido HTTP GET pendente que só é devolvido quando os metadados são alterados e a VM é anulada.

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

Teste as definições de antecipação

Pode executar eventos de manutenção simulados nas suas VMs para forçar a sua remoção preventiva. Use esta funcionalidade para testar como as suas apps processam VMs Spot. Leia o artigo Simule um evento de manutenção do anfitrião para saber como testar eventos de manutenção nas suas instâncias.

Práticas recomendadas

Seguem-se algumas práticas recomendadas para ajudar a tirar o máximo partido das VMs de capacidade instantânea.

Use modelos de instâncias. Em vez de criar VMs do Spot uma de cada vez, pode usar modelos de instâncias para criar várias VMs do Spot com as mesmas propriedades. Os modelos de instâncias são necessários para usar GIGs. Em alternativa, também pode criar várias VMs de Spot através da API de instâncias em massa.
Use GIGs para distribuir regionalmente e recriar automaticamente VMs de capacidade instantânea. Use GIGs para tornar as cargas de trabalho em VMs do Spot mais flexíveis e resilientes. Por exemplo, use GIGs regionais para distribuir VMs por 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 VMs de Spot após a sua remoção.
Escolha tipos de máquinas mais pequenos. Os recursos das VMs do Spot provêm da capacidade excedente e de cópia de segurança Google Cloud . A capacidade para VMs Spot é frequentemente mais fácil de obter para tipos de máquinas mais pequenos, o que significa tipos de máquinas com menos recursos, como vCPUs e memória. Pode encontrar mais capacidade para VMs Spot selecionando um tipo de máquina personalizado mais pequeno, mas a capacidade é ainda mais provável para tipos de máquinas predefinidos mais pequenos. Por exemplo, em comparação com a capacidade do tipo de máquina n2-standard-32 predefinido, a capacidade do tipo de máquina n2-custom-24-96 personalizado é mais provável, mas a capacidade do tipo de máquina n2-standard-16 predefinido é ainda mais provável.
Execute grandes clusters de VMs do Spot durante as horas de menor procura. A carga nos Google Cloud centros de dados varia consoante a localização e a hora do dia, mas é geralmente mais baixa à noite e aos fins de semana. Como tal, as noites e os fins de semana são as melhores alturas para executar grandes clusters de VMs Spot.
Crie as suas aplicações para serem tolerantes a falhas e à preempção. É importante estar preparado para o facto de existirem alterações nos padrões de antecipação em diferentes momentos. Por exemplo, se uma zona sofrer uma indisponibilidade parcial, um grande número de VMs de Spot pode ser anulado para dar lugar a VMs padrão que precisam de ser movidas como parte da recuperação. Nesse pequeno período, a taxa de antecipação seria muito diferente da de qualquer outro dia. Se a sua aplicação pressupõe que as antecipações são sempre feitas em pequenos grupos, pode não estar preparada para um evento deste tipo.
Tente criar novamente VMs do Spot que foram anuladas. Se as suas VMs do Spot tiverem sido preemptivas, experimente criar novas VMs do Spot uma ou duas vezes antes de voltar às VMs padrão. Consoante os seus requisitos, pode ser uma boa ideia combinar VMs padrão e VMs Spot nos seus clusters para garantir que o trabalho avança a um ritmo adequado.
Use scripts de encerramento. Faça a gestão dos avisos de encerramento e de preemptção com um script de encerramento que pode guardar o progresso de uma tarefa para que possa continuar de onde parou, em vez de começar do zero.

O que se segue?

Estabeleça ligação à sua instância de VM.
Saiba mais acerca dos guiões de encerramento.
Saiba como limitar o tempo de execução de uma VM.
Saiba mais acerca dos modelos de instâncias.
Saiba mais acerca dos MIGs.

Crie e use VMs do Spot Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Antes de começar

Console

gcloud

Terraform

REST

Crie uma VM do Spot

Consola

gcloud

Terraform

REST

Go

Java

Python

Inicie VMs do Spot

Identifique o modelo de aprovisionamento e a ação de rescisão de uma VM

Consola

gcloud

REST

Go

Java

Python

Faça a gestão da remoção de VMs do Spot

Faça a gestão da preempção com um script de encerramento

Detete a remoção preventiva de VMs do Spot

Consola

gcloud

REST

Teste as definições de antecipação

Práticas recomendadas

O que se segue?

Crie e use VMs do Spot