Suspender e retomar uma VM

Este documento descreve como suspender e retomar uma instância de máquina virtual (VM, na sigla em inglês). Para informações sobre como parar e iniciar uma instância, consulte Como parar e iniciar uma instância. Para informações sobre o ciclo de vida da instância, consulte a documentação do Ciclo de vida da instância.

Se você quiser manter a instância de VM, mas não quiser ser cobrado por ela quando não estiver em uso, suspenda a VM. Quando você suspende uma VM, o Google preserva a VM no projeto e move o conteúdo da memória da VM para o armazenamento. Enquanto a VM está suspensa, o Google cobra apenas pelo armazenamento usado para preservar a memória da VM. Os atributos, como endereços IP estáticos, permanecem em vigor para que as funções de rede funcionem conforme o esperado quando você retoma a VM. Após a retomada, o Google move a memória da VM do armazenamento de volta para a instância e começa a cobrar você pela instância de VM em execução.

Suspender uma instância é ideal para:

  • Ambientes de desenvolvimento e teste que não estão sendo totalmente utilizados durante períodos de inatividade, como durante noites ou fins de semana, para economizar custos ou inicialização mais rápida do que criar novas instâncias de VM
  • Aplicativos que exigem um longo período de inicialização depois que a instância inicializa, mas antes que o aplicativo esteja pronto para atender à primeira solicitação, como estações de trabalho de desenvolvedores virtuais ou aplicativos Java complexos

Como funciona a suspensão

Suspender uma instância envia um sinal ACPI S3 Suspend para o sistema operacional da instância. A suspensão de uma instância é análoga ao fechamento do laptop, colocando-a no estado SUSPENDED.

A suspensão de uma instância é diferente da interrupção de uma instância das seguintes maneiras:

Todos os recursos anexados à instância permanecem anexados a ela e serão cobrados, incluindo discos permanentes e endereços IP externos estáticos ou reservados. Todos esses recursos são cobrados de acordo com a tabela de preços, mesmo que uma instância seja suspensa.

Não é possível suspender uma instância usando os processos padrão integrados ao ambiente convidado. Não há comandos disponíveis, como o systemctl suspend no Ubuntu 16.04 e versões posteriores. Só é possível usar a Google Cloud CLI ou a REST para suspender uma instância.

Se você não se importa em restaurar a memória de uma instância e o estado do dispositivo ao retomar a instância posteriormente, é possível interromper a instância, o que não gera cobranças extras de armazenamento.

Antes de começar

  • 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 da seguinte maneira.

    Selecione a guia para como planeja usar as amostras nesta página:

    Console

    Quando você usa o console do Google Cloud para acessar os serviços e as APIs do Google Cloud, não é necessário configurar a autenticação.

    gcloud

    1. Instale a Google Cloud CLI e inicialize-a executando o seguinte comando: 

      gcloud init
    2. Defina uma região e uma zona padrão.

    Go

    Para usar as amostras de Go nesta página de um ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure o Application Default Credentials com as credenciais de usuário.

    1. Instale a CLI do Google Cloud.

    2. Para inicializar a CLI gcloud, execute o seguinte comando: 

      gcloud init

    3. Crie as credenciais de autenticação para sua Conta do Google: 

      gcloud auth application-default login

    Veja mais informações em: Configurar a autenticação para um ambiente de desenvolvimento local.

    Java

    Para usar as amostras de Java nesta página de um ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure o Application Default Credentials com as credenciais de usuário.

    1. Instale a CLI do Google Cloud.

    2. Para inicializar a CLI gcloud, execute o seguinte comando: 

      gcloud init

    3. Crie as credenciais de autenticação para sua Conta do Google: 

      gcloud auth application-default login

    Veja mais informações em: Configurar a autenticação para um ambiente de desenvolvimento local.

    Node.js

    Para usar as amostras de Node.js nesta página de um ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure o Application Default Credentials com as credenciais de usuário.

    1. Instale a CLI do Google Cloud.

    2. Para inicializar a CLI gcloud, execute o seguinte comando: 

      gcloud init

    3. Crie as credenciais de autenticação para sua Conta do Google: 

      gcloud auth application-default login

    Veja mais informações em: Configurar a autenticação para um ambiente de desenvolvimento local.

    PHP

    Para usar as amostras de PHP nesta página de um ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure o Application Default Credentials com as credenciais de usuário.

    1. Instale a CLI do Google Cloud.

    2. Para inicializar a CLI gcloud, execute o seguinte comando: 

      gcloud init

    3. Crie as credenciais de autenticação para sua Conta do Google: 

      gcloud auth application-default login

    Veja mais informações em: Configurar a autenticação para um ambiente de desenvolvimento local.

    Python

    Para usar as amostras de Python nesta página de um ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure o Application Default Credentials com as credenciais de usuário.

    1. Instale a CLI do Google Cloud.

    2. Para inicializar a CLI gcloud, execute o seguinte comando: 

      gcloud init

    3. Crie as credenciais de autenticação para sua Conta do Google: 

      gcloud auth application-default login

    Veja mais informações em: Configurar a autenticação para um ambiente de desenvolvimento local.

    REST

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

      Instale a Google Cloud CLI e inicialize-a executando o seguinte comando: 

      gcloud init

Limitações

As limitações a seguir são aplicáveis a esse recurso:

  • Não é possível suspender uma instância que usa uma GPU.
  • Não é possível suspender uma instância usando os processos padrão integrados ao ambiente convidado. Não há comandos disponíveis, como o systemctl suspend no Ubuntu 16.04 e versões posteriores. O sinal de convidado é ignorado.
  • A instância só pode ser suspensa por até 60 dias antes que a VM seja interrompida automaticamente.
  • Não é possível suspender instâncias com mais de 208 GB de memória.
  • É possível suspender instâncias preemptivas, mas elas podem ser encerradas antes de serem suspensas.
  • Não é possível suspender uma VM confidencial.
  • Não é possível suspender uma VM que tenha discos protegidos por CSEK anexados.

SSDs locais

Normalmente, suspender uma instância de VM que usa SSD local descartará todos os dados nos drives SSD locais, o mesmo comportamento de uma interrupção da instância.

Consulte a documentação do SSD local para mais detalhes.

VMs preemptivas

É possível suspender uma VM preemptiva, mas se a preempção (não o aviso antecipado que precede a preempção) ocorrer antes da conclusão da operação de suspensão, a suspensão será encerrada e a instância sofrerá preempção.

Compatibilidade do SO

A maioria dos sistemas operacionais oferecidos no Compute Engine é compatível com a funcionalidade de suspensão e retomada, mas alguns SOs não são compatíveis. Consulte a página de detalhes do SO para ver a lista completa.

Preços

Ao suspender uma instância, você é cobrado por:

  • Memória da instância (consulte os preços das instâncias de VM suspensas).
  • Qualquer uso de disco permanente relacionado ao disco de inicialização e quaisquer outros discos anexados à instância (consulte Preços de discos permanentes)
  • Quaisquer IPs estáticos anexados à instância
  • A suspensão de VMs pode economizar nas taxas de licenciamento de software. Por exemplo, se você suspender VMs do Windows, não receberá cobranças de licença do Windows. As taxas de licença para outras imagens podem ter Termos e Condições diferentes e podem resultar em cobranças, mesmo quando suspensas.

Suspender uma instância

Para suspender uma instância, use o console do Google Cloud, a CLI gcloud, a API ou as Bibliotecas de cliente do Cloud.

Não é possível suspender uma instância usando os processos padrão integrados ao ambiente convidado. Use o console do Google Cloud, a Google Cloud CLI ou a API para suspender uma instância.

A operação de suspensão poderá falhar se for acionada logo após a instância ser iniciada. A instância precisa ser totalmente iniciada (incluindo processos como o Agente convidado) para que a operação de suspensão seja bem-sucedida.

Console

  1. No console do Google Cloud, acesse a página Instâncias de VMs.

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

  2. Selecione uma ou mais instâncias a serem suspensas.

  3. Clique em Suspender.

  4. Quando solicitado, se quiser descartar os dados do SSD local, selecione Descartar o conteúdo do SSD. Quando a instância for retomada, todos os dados de SSD locais da instância terão sido descartados.

gcloud

Para suspender uma instância na Google Cloud CLI, faça o seguinte:

 gcloud compute instances suspend VM_NAME

Depois que você faz uma solicitação para suspender uma instância, pode levar algum tempo para o Compute Engine preservar todos os dados necessários para a instância. Durante esse período, você continuará sendo cobrado pela instância enquanto ela continuar em execução.

Uma instância suspensa é marcada com o status SUSPENDED. Verifique o status de uma instância fazendo uma solicitação describe:

gcloud compute instances describe VM_NAME

Para suspender uma instância com dados da SSD local, é preciso fornecer a sinalização --discard-local-ssd:

gcloud compute instances suspend VM_NAME --discard-local-ssd

Usar --discard-local-ssd ou --discard-local-ssd=True descartará o conteúdo do SSD local. O Compute Engine --discard-local-ssd=False está atualmente em pré-lançamento público. O uso dessa sinalização salvará o conteúdo de até 16 discos SSD locais durante a suspensão. Consulte a documentação do SSD local para mais detalhes.

Go

compute/instances/suspend-resume/suspend.go 
import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
)

// suspendInstance suspends a running Google Compute Engine instance.
func suspendInstance(w io.Writer, projectID, zone, instanceName string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"

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

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

	op, err := instancesClient.Suspend(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to suspend instance: %w", err)
	}

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

	fmt.Fprintf(w, "Instance suspended\n")

	return nil
}

Java

compute/cloud-client/src/main/java/compute/SuspendInstance.java 

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

public class SuspendInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // project: project ID or project number of the Cloud project your instance belongs to.
    // zone: name of the zone your instance belongs to.
    // instanceName: name of the instance your want to suspend.

    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    suspendInstance(project, zone, instanceName);
  }

  // Suspend a running Google Compute Engine instance.
  // For limitations and compatibility on which instances can be suspended,
  // see: https://cloud.google.com/compute/docs/instances/suspend-resume-instance#limitations
  public static void suspendInstance(String project, String zone, String instanceName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Instantiates a client.
    try (InstancesClient instancesClient = InstancesClient.create()) {

      Operation operation = instancesClient.suspendAsync(project, zone, instanceName)
          .get(300, TimeUnit.SECONDS);

      if (operation.hasError() || !instancesClient.get(project, zone, instanceName).getStatus()
          .equalsIgnoreCase(Status.SUSPENDED.toString())) {
        System.out.println("Cannot suspend instance. Try again!");
        return;
      }

      System.out.printf("Instance suspended successfully ! %s", instanceName);
    }
  }
}

Node.js

compute/instances/suspend-resume/suspend.js 
/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const instanceName = 'YOUR_INSTANCE_NAME';

const compute = require('@google-cloud/compute');

// Suspends a running Google Compute Engine instance.
async function suspendInstance() {
  const instancesClient = new compute.InstancesClient();

  const [response] = await instancesClient.suspend({
    project: projectId,
    zone,
    instance: instanceName,
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

  // Wait for the create operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await operationsClient.wait({
      operation: operation.name,
      project: projectId,
      zone: operation.zone.split('/').pop(),
    });
  }

  console.log('Instance suspended.');
}

suspendInstance();

PHP

compute/instances/src/suspend_instance.php 
use Google\Cloud\Compute\V1\Client\InstancesClient;
use Google\Cloud\Compute\V1\SuspendInstanceRequest;

/**
 * Suspend a running Google Compute Engine instance.
 *
 * @param string $projectId Project ID or project number of the Cloud project your instance belongs to.
 * @param string $zone Name of the zone your instance belongs to.
 * @param string $instanceName Name of the instance you want to suspend.
  *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function suspend_instance(
    string $projectId,
    string $zone,
    string $instanceName
) {
    // Suspend the running Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new SuspendInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->suspend($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Instance %s suspended successfully' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Failed to suspend instance: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python

compute/client_library/snippets/instances/suspend.py 
from __future__ import annotations

import sys
from typing import Any

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

def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result

def suspend_instance(project_id: str, zone: str, instance_name: str) -> None:
    """
    Suspend a running Google Compute Engine instance.
    Args:
        project_id: project ID or project number of the Cloud project your instance belongs to.
        zone: name of the zone your instance belongs to.
        instance_name: name of the instance you want to suspend.
    """
    instance_client = compute_v1.InstancesClient()

    operation = instance_client.suspend(
        project=project_id, zone=zone, instance=instance_name
    )

    wait_for_extended_operation(operation, "suspend instance")

REST

Na API, faça uma solicitação usando o método instances.suspend:

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

Substitua o seguinte:

  • PROJECT_ID: o ID do projeto;
  • ZONE: a zona da VM;
  • VM_NAME: a instância que você quer suspender.

Depois que você faz uma solicitação para suspender uma instância, pode levar algum tempo para o Compute Engine preservar todos os dados necessários para a instância. Durante esse período, você será cobrado pela instância enquanto ela permanecer em execução.

O Compute Engine marca a instância suspensa com o status SUSPENDED. Verifique o status de uma instância fazendo uma solicitação GET:

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

O status da instância é visível no campo de status. Exemplo:

...
"zone": "https://content.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a",
"status": "SUSPENDED",
"name": "example-vm",
...

Para suspender uma instância com mais de {maximum_local_ssd_disks_for_suspend}}disco SSD local, você precisa descartar os dados do SSD local fornecendo o parâmetro de consulta discardLocalSsd:

https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/suspend?discardLocalSsd=true

Retome uma instância suspensa.

Só será possível retomar uma instância se houver capacidade suficiente na zona em que a VM reside. Na maioria dos casos, isso não é um problema, mas se você tiver problemas de capacidade, tente fazer a solicitação de retomada novamente mais tarde.

Para retomar uma instância suspensa, use o console do Google Cloud , a CLI gcloud , a API ou as Bibliotecas de cliente do Cloud.

Console

  1. No console do Google Cloud, acesse a página Instâncias de VMs.

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

  2. Selecione uma ou mais instâncias para retomar.

  3. Clique em Iniciar / continuar.

gcloud

Para retomar uma instância na Google Cloud CLI, faça o seguinte:

 gcloud compute instances resume VM_NAME

Depois de fazer uma solicitação para retomar uma instância, pode levar algum tempo para o Compute Engine restaurar todos os dados necessários para ela. Durante esse período, você será cobrado pela instância enquanto ela estiver sendo retomada.

Uma instância é retomada quando está marcada como RUNNING. Verifique o status de uma instância fazendo uma solicitação de descrição:

gcloud compute instances describe VM_NAME

Go

compute/instances/suspend-resume/resume.go 
import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
)

// resumeInstance resumes a suspended Google Compute Engine instance
// (with unencrypted disks).
func resumeInstance(w io.Writer, projectID, zone, instanceName string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"

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

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

	instance, err := instancesClient.Get(ctx, getInstanceReq)
	if err != nil {
		return fmt.Errorf("unable to get instance: %w", err)
	}

	if instance.GetStatus() != "SUSPENDED" {
		return fmt.Errorf(
			"only suspended instances can be resumed, instance %s is in %s state",
			instanceName,
			instance.GetStatus(),
		)
	}

	resumeInstanceReq := &computepb.ResumeInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	op, err := instancesClient.Resume(ctx, resumeInstanceReq)
	if err != nil {
		return fmt.Errorf("unable to resume instance: %w", err)
	}

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

	fmt.Fprintf(w, "Instance resumed\n")

	return nil
}

Java

compute/cloud-client/src/main/java/compute/ResumeInstance.java 

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

public class ResumeInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // project: project ID or project number of the Cloud project your instance belongs to.
    // zone: name of the zone your instance belongs to.
    // instanceName: name of the instance your want to resume.

    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    resumeInstance(project, zone, instanceName);
  }

  // Resume a suspended Google Compute Engine instance (with unencrypted disks).
  // Instance state changes to RUNNING, if successfully resumed.
  public static void resumeInstance(String project, String zone, String instanceName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Instantiates a client.
    try (InstancesClient instancesClient = InstancesClient.create()) {

      String currentInstanceState = instancesClient.get(project, zone, instanceName).getStatus();

      // Check if the instance is currently suspended.
      if (!currentInstanceState.equalsIgnoreCase(Status.SUSPENDED.toString())) {
        throw new RuntimeException(
            String.format("Only suspended instances can be resumed. Instance %s is in %s state.",
                instanceName, currentInstanceState));
      }

      Operation operation = instancesClient.resumeAsync(project, zone, instanceName)
          .get(300, TimeUnit.SECONDS);

      if (operation.hasError() || !instancesClient.get(project, zone, instanceName).getStatus()
          .equalsIgnoreCase(
              Status.RUNNING.toString())) {
        System.out.println("Cannot resume instance. Try again!");
        return;
      }

      System.out.printf("Instance resumed successfully ! %s", instanceName);
    }
  }
}

Node.js

compute/instances/suspend-resume/resume.js 
/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const instanceName = 'YOUR_INSTANCE_NAME';

const compute = require('@google-cloud/compute');

// Resumes a suspended Google Compute Engine instance (with unencrypted disks).
async function resumeInstance() {
  const instancesClient = new compute.InstancesClient();

  const [instance] = await instancesClient.get({
    project: projectId,
    zone,
    instance: instanceName,
  });

  if (instance.status !== 'SUSPENDED') {
    throw new Error(
      'Only suspended instances can be resumed.' +
        `Instance ${instanceName} is in ${instance.status} state.`
    );
  }

  const [response] = await instancesClient.resume({
    project: projectId,
    zone,
    instance: instanceName,
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

  // Wait for the create operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await operationsClient.wait({
      operation: operation.name,
      project: projectId,
      zone: operation.zone.split('/').pop(),
    });
  }

  console.log('Instance resumed.');
}

resumeInstance();

PHP

compute/instances/src/resume_instance.php 
use Google\Cloud\Compute\V1\Client\InstancesClient;
use Google\Cloud\Compute\V1\ResumeInstanceRequest;

/**
 * Resume a suspended Google Compute Engine instance (with unencrypted disks).
 *
 * @param string $projectId Project ID or project number of the Cloud project your instance belongs to.
 * @param string $zone Name of the zone your instance belongs to.
 * @param string $instanceName Name of the instance you want to resume.
  *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function resume_instance(
    string $projectId,
    string $zone,
    string $instanceName
) {
    // Resume the suspended Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new ResumeInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->resume($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Instance %s resumed successfully' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Failed to resume instance: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python

compute/client_library/snippets/instances/resume.py 
from __future__ import annotations

import sys
from typing import Any

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

def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result

def resume_instance(project_id: str, zone: str, instance_name: str) -> None:
    """
    Resume a suspended Google Compute Engine instance (with unencrypted disks).
    Args:
        project_id: project ID or project number of the Cloud project your instance belongs to.
        zone: name of the zone your instance belongs to.
        instance_name: name of the instance you want to resume.
    """
    instance_client = compute_v1.InstancesClient()

    instance = instance_client.get(
        project=project_id, zone=zone, instance=instance_name
    )
    if instance.status != compute_v1.Instance.Status.SUSPENDED.name:
        raise RuntimeError(
            f"Only suspended instances can be resumed. "
            f"Instance {instance_name} is in {instance.status} state."
        )

    operation = instance_client.resume(
        project=project_id, zone=zone, instance=instance_name
    )

    wait_for_extended_operation(operation, "instance resumption")

REST

Faça uma solicitação ao método instances.resume:

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

Substitua o seguinte:

  • PROJECT_ID: o ID do projeto desta solicitação;
  • ZONE: a zona da VM;
  • VM_NAME: a instância a ser retomada.

Depois de fazer uma solicitação para retomar uma instância, pode levar algum tempo para o Compute Engine restaurar todos os dados necessários para ela. Durante esse período, você será cobrado pela instância enquanto ela estiver sendo retomada.

O Compute Engine marca a instância com o status RUNNING quando a retomada é concluída. Verifique o status de uma instância fazendo uma solicitação GET:

GET https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/instances/example-instance

O status da instância é visível no campo de status. Exemplo:

...
"zone": "https://content.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a",
"status": "RUNNING",
"name": "example-instance",
...

Processo de suspensão

Ao fazer uma solicitação de suspensão, você envia um sinal de suspensão ACPI para a instância da VM. Se a VM não responder ao sinal de suspensão ACPI S3 em alguns minutos, o Compute Engine cancelará a tentativa de suspensão e retornará a VM para um estado RUNNING.

A tabela a seguir descreve o efeito da suspensão de uma instância de VM nos recursos associados:

Recurso Suporte
Memória Somente VMs com 208 GB ou menos de memória podem ser suspensas.
SSD local Os dados do SSD local são descartados.
Disco permanente Os discos SSD e HDD permanentes são mantidos.
Endereços IP Os IPs temporários são liberados durante a suspensão, mas os IPs estáticos permanecem anexados às instâncias de VM. Se você quiser manter o ID temporário, promova-o.
Configuração de VM (como tipo de máquina, metadados, rótulos etc.) Todas as configurações de VM, exceto os endereços IP temporários, são preservadas e restauradas quando a instância é retomada.

Como configurar uma VM do Debian para aceitar a suspensão e a retomada

As VMs que executam o Debian 8 e 9 podem suspender e retomar, mas precisam ser configuradas com antecedência. Para configurar sua instância do Debian, conclua um dos seguintes conjuntos de instruções, opção A ou B. Recomendamos que você configure o ACPID, se possível (opção A).

Opção A

Essa opção configura o ACPID para processar o evento do botão de suspensão e adiciona um script de shell para manipular o evento de suspensão.

  1. Conecte-se à instância de VM com ssh:

    gcloud compute ssh VM_NAME

  2. Na instância da VM, crie um diretório na pasta acpi:

    sudo mkdir -p /etc/acpi/events/

  3. Configure o ACPID para processar o evento do botão de suspensão:

    cat <<EOF | sudo tee /etc/acpi/events/sleepbtn-acpi-support
event=button[ /]sleep
action=/etc/acpi/sleepbtn-acpi-support.sh
EOF

  4. Crie o script de manipulação de eventos de suspensão:

    cat <<EOF | sudo tee /etc/acpi/sleepbtn-acpi-support.sh
#!/bin/sh
echo mem > /sys/power/state
EOF

  5. Configure as permissões do script:

    sudo chmod 755 /etc/acpi/sleepbtn-acpi-support.sh

  6. Reinicie o ACPID:

    sudo systemctl restart acpid.service

Opção B

  1. Conecte-se à instância de VM com ssh:

    gcloud compute ssh VM_NAME

  2. Na instância da VM, instale dbus:

    sudo apt-get install dbus

  3. Restart logind:

    sudo systemctl restart systemd-logind.service

A seguir