Suspender ou retomar uma instância do Compute Engine

Neste documento, explicamos como suspender ou retomar instâncias do Compute Engine. Para saber mais sobre como suspender, interromper ou redefinir instâncias, consulte Suspender, interromper ou redefinir instâncias do Compute Engine.

Se você quiser manter a instância do Compute Engine, mas não quiser receber cobranças por ela quando não estiver em uso, suspenda a instância. A suspensão de uma instância preserva a instância e migra o conteúdo da memória dela para o armazenamento. Depois de retomar a instância, o Compute Engine migra a memória da instância do armazenamento de volta para a instância, e ela começa a ser executada novamente.

Suspender uma instância do Compute Engine é útil para:

  • Ambientes de desenvolvimento e teste que não estão sendo totalmente usados durante períodos de inatividade, como noites ou fins de semana, e que você quer manter para economizar custos ou ter uma inicialização mais rápida do que criar novas instâncias.

  • 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

Limitações

Ao suspender uma instância de computação, as seguintes limitações se aplicam:

  • Só é possível suspender uma instância se o SO convidado permitir. Para mais informações, consulte Detalhes do sistema operacional.

  • Só é possível suspender uma instância que usa as seguintes imagens do SO se você configurar o SO, conforme descrito neste documento:

    • Debian 8 ou 9

    • Qualquer SO Windows

  • É possível suspender uma instância por até 60 dias antes que o Compute Engine faça a transição automática do estado dela para TERMINATED.

  • É possível suspender VMs spot ou instâncias preemptivas. No entanto, se o Compute Engine fizer a preempção da instância antes da conclusão da operação de suspensão, o Compute Engine vai encerrar a operação de suspensão e fazer a preempção das instâncias.

  • Não é possível suspender instâncias usando os processos padrão integrados ao ambiente convidado. Comandos como systemctl suspend no Ubuntu 16.04 ou mais recente não são compatíveis. Se for chamado, o Compute Engine vai ignorar o sinal de convidado.

  • Não é possível suspender os seguintes tipos de instâncias:

    • Instâncias bare metal.

    • VMs confidenciais.

    • Instâncias com GPUs anexadas.

    • Instâncias com mais de 208 GB de memória.

    • Instâncias com discos protegidos por CSEK anexados.

Ativar operações de suspensão em um SO convidado

Se a instância de computação usar o Debian 8 ou 9 como SO convidado ou qualquer SO Windows, será necessário configurar o SO antes de suspender e retomar instâncias. Se a instância usar um SO convidado diferente, pule esta seção.

Ativar operações de suspensão no Debian 8 ou 9

Antes de suspender ou retomar instâncias de computação que usam o Debian 8 ou 9 como um SO convidado, configure o SO convidado usando um dos seguintes métodos:

Configurar o ACPID

Para ativar a operação de suspensão e retomada no Debian 8 ou 9, configure o daemon de eventos da Interface avançada de energia e configuração (ACPID) para processar o evento do botão de suspensão. Depois de ativar o evento do botão de suspensão profunda, você pode adicionar um script de shell para processar o evento de suspensão, conforme descrito nesta seção.

Para configurar o ACPID para aceitar operações de suspensão e retomada, faça o seguinte:

  1. Se você ainda não fez isso, conecte-se à sua instância do Linux.

  2. Crie a pasta events 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. Para que as mudanças entrem em vigor, reinicie o ACPID:

    sudo systemctl restart acpid.service

Instalar o D-Bus

Para ativar a operação de suspensão e retomada no Debian 8 ou 9, instale o D-Bus.

Para instalar o D-Bus no SO convidado da instância de computação quando o SO estiver usando o Debian 8 ou 9, faça o seguinte:

  1. Se você ainda não fez isso, conecte-se à sua instância do Linux.

  2. Instale o D-Bus:

    sudo apt-get install dbus

  3. Para que as mudanças entrem em vigor, reinicie o logind:

    sudo systemctl restart systemd-logind.service

Ativar operações de suspensão no Windows

Para suspender uma instância que usa um SO convidado do Windows, é necessário desativar a hibernação no SO. Se você importou uma imagem do Windows, a hibernação pode estar ativada por padrão, e você precisa desativá-la para suspender a instância.

Para desativar a hibernação no Windows, siga estas etapas:

  1. Conecte-se à sua instância do Windows, caso ainda não tenha feito isso.

  2. Abra o PowerShell como administrador.

  3. Desativar a hibernação:

    powercfg -h off

  4. Verifique se a hibernação está desativada:

    powercfg -a

Antes de começar

Funções exigidas

Para receber as permissões necessárias para suspender ou retomar uma instância de computação, peça ao administrador para conceder a você o papel do IAM de Administrador da instância do Compute (v1) (roles/compute.instanceAdmin.v1) na instância. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esse papel predefinido contém as permissões necessárias para suspender ou retomar uma instância de computação. Para acessar as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As seguintes permissões são necessárias para suspender ou retomar uma instância de computação:

  • Para suspender uma instância: compute.instances.suspend
  • Para retomar uma instância: compute.instances.resume

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

Suspender uma instância

Se o SO convidado da sua instância de computação estiver usando o Debian 8 ou 9, antes de suspender a instância, configure o SO convidado para oferecer suporte a operações de suspensão e retomada, conforme descrito neste documento.

Para suspender uma instância, use um dos seguintes métodos, dependendo se a instância tem discos SSD locais anexados:

Suspender uma instância sem discos SSD locais

É possível suspender várias instâncias de computação simultaneamente ou instâncias individuais. Para várias instâncias, use o console do Google Cloud ou, para instâncias localizadas na mesma zona, a Google Cloud CLI. Para instâncias individuais, selecione uma das seguintes opções:

Console

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

    Acessar instâncias de VM

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

  3. Clique em Suspender e, em seguida, em Suspender para confirmar.

gcloud

Para suspender uma ou mais instâncias em uma única zona, use o comando gcloud compute instances suspend:

gcloud compute instances suspend INSTANCE_NAMES \
    --zone=ZONE

Substitua:

  • INSTANCE_NAMES: uma lista separada por espaços em branco de nomes de instâncias, por exemplo, instance-01 instance-02 instance-03.

  • ZONE: a zona em que as instâncias estão localizadas.

Go

import (
	"context"
	"fmt"
	"io"

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

// 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 


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 

/**
 * 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 

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 

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

Para suspender uma instância, faça uma solicitação POST para o método instances.suspend:

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

Substitua:

  • PROJECT_ID: o ID do projeto em que a instância está localizada.

  • ZONE: a zona em que a instância está.

  • INSTANCE_NAME: o nome da instância.

Suspender uma instância com discos SSD locais

Com base em quantas instâncias de computação você quer suspender simultaneamente e se é necessário preservar os dados dos discos SSD locais anexados, faça o seguinte:

  • Para preservar os dados dos discos SSD locais anexados a uma instância (exceto instâncias com discos SSD Titanium), suspenda a instância usando a CLI gcloud ou a API REST.

  • Para suspender várias instâncias simultaneamente, use o console Google Cloud ou, no caso de instâncias localizadas na mesma zona, a CLI gcloud.

Para suspender uma ou mais instâncias com discos SSD locais anexados, selecione uma das seguintes opções:

Console

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

    Acessar instâncias de VM

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

  3. Clique em Suspender e, em seguida, em Suspender para confirmar.

gcloud

Ao suspender uma ou mais instâncias em uma única zona que têm discos SSD locais anexados, especifique se os dados do SSD local serão descartados ou preservados da seguinte maneira:

  • Para descartar dados da SSD local, use o comando gcloud compute instances suspend com a flag --discard-local-ssd=true:

    gcloud compute instances suspend INSTANCE_NAMES \
    --discard-local-ssd=true \
    --zone=ZONE

  • Para preservar os dados da SSD local, use o comando gcloud beta compute instances suspend com a flag --discard-local-ssd=false:

    gcloud beta compute instances suspend INSTANCE_NAMES \
    --discard-local-ssd=false \
    --zone=ZONE

Substitua:

  • INSTANCE_NAMES: uma lista separada por espaços em branco de nomes de instâncias, por exemplo, instance-01 instance-02 instance-03.

  • ZONE: a zona em que as instâncias estão localizadas.

REST

Ao suspender uma instância com discos SSD locais anexados, especifique se os dados do SSD local serão descartados ou preservados da seguinte maneira:

  • Para descartar dados da SSD local, faça uma solicitação POST ao método instances.suspend. No URL da solicitação, inclua o parâmetro de consulta discardLocalSsd definido como true:

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

  • Para preservar os dados do SSD local, faça uma solicitação POST para o método beta.instances.suspend. No URL da solicitação, inclua o parâmetro de consulta discardLocalSsd definido como false:

    POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/suspend?discardLocalSsd=false

Substitua:

  • PROJECT_ID: o ID do projeto em que a instância está localizada.

  • ZONE: a zona em que a instância está.

  • INSTANCE_NAME: o nome da instância.

Retome uma instância suspensa.

Antes de retomar uma instância de computação suspensa, considere o seguinte:

  • Só será possível retomar uma instância se houver capacidade suficiente na zona em que ela está localizada. Isso geralmente não é um problema. Se você tiver problemas para retomar uma instância, tente de novo mais tarde.

  • Se você anexou discos SSD locais à instância e escolheu preservar os dados do SSD local ao suspender, talvez seja necessário remontar os discos SSD locais após a retomada. Para mais informações, consulte como remontar discos que não são de inicialização em instâncias do Linux ou instâncias do Windows.

É possível retomar várias instâncias simultaneamente ou instâncias individuais. Para várias instâncias, use o console do Google Cloud ou, para instâncias localizadas na mesma zona, a CLI gcloud. Para instâncias individuais, selecione uma das seguintes opções:

Console

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

    Acessar instâncias de VM

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

  3. Clique em Iniciar / continuar e em Iniciar.

gcloud

Para retomar uma ou mais instâncias suspensas em uma única zona, use o comando gcloud compute instances resume:

gcloud compute instances resume INSTANCE_NAMES \
    --zone=ZONE

Substitua:

  • INSTANCE_NAMES: uma lista separada por espaços em branco de nomes de instâncias, por exemplo, instance-01 instance-02 instance-03.

  • ZONE: a zona em que as instâncias suspensas estão localizadas.

Go

import (
	"context"
	"fmt"
	"io"

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

// 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 


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 

/**
 * 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 

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 

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

Para retomar uma instância suspensa, faça uma solicitação POST para o método instances.resume:

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

Substitua:

  • INSTANCE_NAME: o nome da instância suspensa a ser retomada.

  • PROJECT_ID: o ID do projeto em que a instância suspensa está.

  • ZONE: a zona em que a instância suspensa está localizada.

A seguir