Suspender ou retomar uma instância do Compute Engine

Este documento explica 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 sua instância do Compute Engine, mas não quiser gerar cobranças por ela quando ela 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.

A suspensão de uma instância do Compute Engine é útil 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, 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 é inicializada, mas antes que o aplicativo esteja pronto para atender à primeira solicitação, como estações de trabalho de desenvolvedores virtuais ou aplicativos Java complexos.

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 selecionando uma das seguintes opções:

    Select the tab for how you plan to use the samples on this page:

    Console

    When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

    gcloud

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

      gcloud init
    2. Set a default region and zone.

      3. Go

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

      1. Install the Google Cloud CLI.

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

        gcloud init

      3. If you're using a local shell, then create local authentication credentials for your user account: 

        gcloud auth application-default login

        You don't need to do this if you're using Cloud Shell.

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

      Java

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

      1. Install the Google Cloud CLI.

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

        gcloud init

      3. If you're using a local shell, then create local authentication credentials for your user account: 

        gcloud auth application-default login

        You don't need to do this if you're using Cloud Shell.

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

      Node.js

      Para usar os exemplos Node.js desta página em um ambiente de desenvolvimento local, instale e inicialize o gcloud CLI e e configure o Application Default Credentials com suas credenciais de usuário.

      1. Install the Google Cloud CLI.

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

        gcloud init

      3. If you're using a local shell, then create local authentication credentials for your user account: 

        gcloud auth application-default login

        You don't need to do this if you're using Cloud Shell.

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

      PHP

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

      1. Install the Google Cloud CLI.

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

        gcloud init

      3. If you're using a local shell, then create local authentication credentials for your user account: 

        gcloud auth application-default login

        You don't need to do this if you're using Cloud Shell.

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

      Python

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

      1. Install the Google Cloud CLI.

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

        gcloud init

      3. If you're using a local shell, then create local authentication credentials for your user account: 

        gcloud auth application-default login

        You don't need to do this if you're using Cloud Shell.

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

      REST

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

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

        gcloud init

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

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 da computação (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 conferir as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As permissões a seguir 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.

Limitações

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

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

  • Só é possível suspender uma instância que usa o Debian 8 ou 9 como SO convidado se você configurar o SO antes de suspender a VM.

  • A instância só pode ser suspensa por até 60 dias antes que o Compute Engine faça a transição automática do estado para TERMINATED.

  • É possível suspender VMs do Spot ou instâncias preemptivas. No entanto, se o Compute Engine interromper a instância antes da conclusão da operação de suspensão, ele encerrará a operação de suspensão e forçará a interrupção das instâncias.

  • Não é possível suspender instâncias com GPUs anexadas.

  • Não é possível suspender instâncias do Bare Metal.

  • Não é possível suspender VMs confidenciais.

  • Não é possível suspender instâncias usando os processos padrão integrados ao ambiente convidado. Não há suporte para comandos como systemctl suspend no Ubuntu 16.04 ou versões mais recentes. Se for chamado, o Compute Engine vai ignorar o indicador de convidado.

  • Não é possível suspender instâncias com mais de 208 GB de memória.

  • Não é possível suspender instâncias com discos protegidos por CSEK anexados.

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

Se uma instância de computação estiver executando o Debian 8 e 9 como SO convidado, antes de suspender a instância, será necessário ativar as operações de suspensão e retomada fazendo uma das seguintes ações:

Configurar o ACPID

Para ativar a operação de suspensão e retomada no Debian 8 ou 9, configure o Daemon de eventos de configuração avançada e interface de energia (ACPID, na sigla em inglês) para processar o evento do botão de suspensão. Depois de ativar o evento do botão de suspensão profunda, é possível adicionar um script de shell para processar o evento de suspensão, conforme descrito nesta seção.

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

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

  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 na instância de computação do SO convidado quando ele estiver usando o Debian 8 ou 9, faça o seguinte:

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

  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

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, você precisará configurar 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 métodos a seguir com base em se a instância tem discos SSD locais conectados:

Suspender uma instância sem discos SSD locais

É possível suspender várias instâncias de computação simultaneamente ou individualmente. 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 VMs.

    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á localizada.

  • INSTANCE_NAME: o nome da instância.

Suspender uma instância com discos SSD locais

Com base no número de instâncias de computação que você quer suspender simultaneamente e se é necessário preservar os dados dos discos SSD locais conectados, faça o seguinte:

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

  • Para suspender várias instâncias ao mesmo tempo, use o console do 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 conectados, selecione uma das seguintes opções:

Console

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

    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 com discos SSD locais anexados, especifique se os dados do SSD local serão descartados ou preservados da seguinte forma:

  • 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 do 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 conectados, 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á localizada.

  • 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 novamente mais tarde.

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

É possível retomar várias instâncias simultaneamente ou individualmente. 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 VMs.

    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 de suspensão a ser retomada.

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

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

A seguir