Suspende o reanuda una instancia de Compute Engine

En este documento, se explica cómo suspender o reanudar instancias de Compute Engine. Para obtener más información sobre cómo suspender, detener o restablecer instancias, consulta Cómo suspender, detener o restablecer instancias de Compute Engine.

Si deseas conservar tu instancia de Compute Engine, pero no quieres que se te cobre por ella cuando no esté en uso, puedes suspenderla. Si suspendes una instancia, se conserva y se migra el contenido de la memoria de la instancia al almacenamiento. Después de reanudar la instancia, Compute Engine migra la memoria de la instancia del almacenamiento a la instancia, y esta vuelve a comenzar a ejecutarse.

Suspender una instancia de Compute Engine es útil para lo siguiente:

  • Entornos de prueba y desarrollo que no se usan por completo durante los períodos de inactividad, como las noches o los fines de semana, y que deseas mantener para reducir los costos o hacer una inicialización más rápida que la creación de instancias nuevas.

  • Aplicaciones que requieren un largo período de inicialización después de que la instancia termina de iniciarse, pero antes de que la aplicación esté lista para hacer su primera solicitud, como estaciones de trabajo de desarrolladores virtuales o aplicaciones complejas de Java.

Antes de comenzar

  • Si aún no lo hiciste, configura la autenticación. La autenticación es el proceso mediante el cual se verifica tu identidad para acceder a los servicios y las API de Google Cloud. Para ejecutar código o muestras desde un entorno de desarrollo local, puedes autenticarte en Compute Engine seleccionando una de las siguientes opciones:

    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 las muestras de Go de esta página en un entorno de desarrollo local, instala e inicializa gcloud CLI y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

      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.

      Para obtener más información, consulta Set up authentication for a local development environment.

      Java

      Para usar las muestras de Java de esta página en un entorno de desarrollo local, instala e inicializa gcloud CLI y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

      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.

      Para obtener más información, consulta Set up authentication for a local development environment.

      Node.js

      Para usar las muestras de Node.js de esta página en un entorno de desarrollo local, instala e inicializa gcloud CLI y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

      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.

      Para obtener más información, consulta Set up authentication for a local development environment.

      PHP

      Para usar las muestras de PHP de esta página en un entorno de desarrollo local, instala e inicializa gcloud CLI y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

      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.

      Para obtener más información, consulta Set up authentication for a local development environment.

      Python

      Para usar las muestras de Python de esta página en un entorno de desarrollo local, instala e inicializa gcloud CLI y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

      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.

      Para obtener más información, consulta Set up authentication for a local development environment.

      REST

      Para usar las muestras de la API de REST en esta página en un entorno de desarrollo local, debes usar las credenciales que proporcionas a la CLI de gcloud.

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

        gcloud init

      Si deseas obtener más información, consulta Autentica para usar REST en la documentación de autenticación de Google Cloud.

Roles obligatorios

Para obtener los permisos que necesitas para suspender o reanudar una instancia de procesamiento, pídele a tu administrador que te otorgue el rol de IAM Administrador de instancias de Compute (v1) (roles/compute.instanceAdmin.v1) en la instancia. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

Este rol predefinido contiene los permisos necesarios para suspender o reanudar una instancia de procesamiento. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

Se requieren los siguientes permisos para suspender o reanudar una instancia de procesamiento:

  • Para suspender una instancia, haz lo siguiente: compute.instances.suspend
  • Para reanudar una instancia, haz lo siguiente: compute.instances.resume

También puedes obtener estos permisos con roles personalizados o con otros roles predefinidos.

Limitaciones

Cuando se suspende una instancia de procesamiento, se aplican las siguientes limitaciones:

  • Solo puedes suspender una instancia si el SO invitado la admite. Para obtener más información, consulta Detalles de los sistemas operativos.

  • Solo puedes suspender una instancia que use Debian 8 o 9 como SO invitado si configuras el SO antes de suspender la VM.

  • Solo puedes suspender una instancia durante un máximo de 60 días antes de que Compute Engine cambie automáticamente su estado a TERMINATED.

  • Puedes suspender VMs Spot o instancias interrumpibles. Sin embargo, si Compute Engine interrumpe la instancia antes de que se complete la operación de suspensión, Compute Engine finaliza la operación de suspensión y, luego, interrumpe las instancias.

  • No puedes suspender instancias con GPUs conectadas.

  • No puedes suspender instancias de Bare Metal.

  • No puedes suspender las Confidential VMs.

  • No puedes suspender instancias mediante los procesos estándar integrados en su entorno de invitado. Los comandos como systemctl suspend en Ubuntu 16.04 o versiones posteriores no son compatibles. Si se realiza una llamada, Compute Engine ignora la señal del invitado.

  • No puedes suspender instancias con más de 208 GB de memoria.

  • No puedes suspender instancias que tengan discos adjuntos protegidos por CSEK.

Habilita las operaciones de suspensión en Debian 8 o 9

Si una instancia de procesamiento ejecuta Debian 8 y 9 como su SO invitado, antes de suspender la instancia, debes habilitar las operaciones de suspensión y reanudación. Para ello, realiza una de las siguientes acciones:

Configura el ACPID

Para habilitar la operación de suspensión y reanudación en Debian 8 o 9, puedes configurar el daemon de eventos de Interfaz avanzada y configuración avanzada (ACPID) para controlar el evento del botón de suspensión. Después de habilitar el evento del botón de suspensión profunda, puedes agregar una secuencia de comandos de shell para controlar el evento de suspensión, como se describe en esta sección.

Para configurar el ACPID para que admita operaciones de suspensión y reanudación, haz lo siguiente:

  1. Si aún no lo hiciste, conéctate a tu instancia de Linux.

  2. Crea la carpeta events en la carpeta acpi:

    sudo mkdir -p /etc/acpi/events/

  3. Configura el ACPID para controlar el evento del botón de suspensión:

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

  4. Crea la secuencia de comandos para controlar eventos de suspensión:

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

  5. Configura los permisos para la secuencia de comandos:

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

  6. Para que se apliquen los cambios, reinicia el ACPID:

    sudo systemctl restart acpid.service

Instala D-Bus

Para habilitar la operación de suspensión y reanudación en Debian 8 o 9, puedes instalar D-Bus.

Para instalar D-Bus en el SO invitado de tu instancia de procesamiento cuando el SO usa Debian 8 o 9, haz lo siguiente:

  1. Si aún no lo hiciste, conéctate a tu instancia de Linux.

  2. Instala D-Bus:

    sudo apt-get install dbus

  3. Para que se apliquen los cambios, reinicia logind:

    sudo systemctl restart systemd-logind.service

Suspende una instancia

Si el SO huésped de tu instancia de procesamiento usa Debian 8 o 9, antes de suspender la instancia, debes configurar el SO huésped para que admita las operaciones de suspensión y reanudación como se describe en este documento.

Para suspender una instancia, usa uno de los siguientes métodos según si la instancia tiene discos SSD locales conectados:

Cómo suspender una instancia sin discos SSD locales

Puedes suspender varias instancias de procesamiento de forma simultánea o individual. Para varias instancias, usa la consola de Google Cloud o, para instancias ubicadas en la misma zona, Google Cloud CLI. Para instancias individuales, selecciona cualquiera de las siguientes opciones:

Console

  1. En la consola de Google Cloud, ve a la página Instancias de VM.

    Ir a Instancias de VM

  2. Elige una o más instancias que desees suspender.

  3. Haz clic en Suspender y, luego, en Suspender para confirmar.

gcloud

Para suspender una o más instancias en una sola zona, usa el comando gcloud compute instances suspend:

gcloud compute instances suspend INSTANCE_NAMES \
    --zone=ZONE

Reemplaza lo siguiente:

  • INSTANCE_NAMES: Es una lista de nombres de instancias separados por espacios en blanco, por ejemplo, instance-01 instance-02 instance-03.

  • ZONE: Es la zona en la que se encuentran las instancias.

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 una instancia, realiza una solicitud POST al método instances.suspend:

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

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto en el que se encuentra la instancia.

  • ZONE: Es la zona en la que se encuentra la instancia.

  • INSTANCE_NAME: El nombre de la instancia.

Suspende una instancia con discos SSD locales

Según la cantidad de instancias de procesamiento que deseas suspender de forma simultánea y si necesitas conservar los datos de sus discos SSD locales conectados, haz lo siguiente:

  • Para preservar los datos de los discos SSD locales conectados a una instancia, suspende la instancia con gcloud CLI o la API de REST.

  • Para suspender varias instancias de forma simultánea, usa la consola de Google Cloud o, en el caso de las instancias ubicadas en la misma zona, gcloud CLI.

Para suspender una o más instancias que tengan discos SSD locales conectados, selecciona una de las siguientes opciones:

Console

  1. En la consola de Google Cloud, ve a la página Instancias de VM.

    Ir a Instancias de VM

  2. Elige una o más instancias que desees suspender.

  3. Haz clic en Suspender y, luego, en Suspender para confirmar.

gcloud

Cuando suspendas una o más instancias en una sola zona que tengan discos SSD locales conectados, especifica si quieres descartar o conservar los datos del SSD local de la siguiente manera:

  • Para descartar los datos del SSD local, usa el comando gcloud compute instances suspend con la marca --discard-local-ssd=true:

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

  • Para conservar los datos del SSD local, usa el comando gcloud beta compute instances suspend con la marca --discard-local-ssd=false:

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

Reemplaza lo siguiente:

  • INSTANCE_NAMES: Es una lista de nombres de instancias separados por espacios en blanco, por ejemplo, instance-01 instance-02 instance-03.

  • ZONE: Es la zona en la que se encuentran las instancias.

REST

Cuando suspendas una instancia que tiene discos SSD locales conectados, especifica si quieres descartar o preservar los datos de SSD locales de la siguiente manera:

  • Para descartar los datos del SSD local, realiza una solicitud POST al método instances.suspend. En la URL de la solicitud, incluye el parámetro de consulta discardLocalSsd configurado como true:

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

  • Para conservar los datos de las SSD locales, realiza una solicitud POST al método beta.instances.suspend. En la URL de la solicitud, incluye el parámetro de consulta discardLocalSsd configurado como false:

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

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto en el que se encuentra la instancia.

  • ZONE: Es la zona en la que se encuentra la instancia.

  • INSTANCE_NAME: El nombre de la instancia.

Reanuda una instancia suspendida

Antes de reanudar una instancia de procesamiento suspendida, ten en cuenta lo siguiente:

  • Solo puedes reanudar una instancia si hay capacidad suficiente en la zona en la que se encuentra. Por lo general, esto no es un problema. Si tienes problemas para reanudar una instancia, vuelve a intentarlo más tarde.

  • Si conectaste discos SSD locales a la instancia y elegiste conservar los datos de SSD locales cuando la suspendiste, es posible que debas volver a activar los discos SSD locales después de reanudarla. Para obtener más información, consulta cómo volver a activar discos que no son de inicio en instancias de Linux o instancias de Windows.

Puedes reanudar varias instancias de forma simultánea o individual. Para varias instancias, usa la consola de Google Cloud o, para instancias ubicadas en la misma zona, gcloud CLI. Para instancias individuales, selecciona cualquiera de las siguientes opciones:

Console

  1. En la consola de Google Cloud, ve a la página Instancias de VM.

    Ir a Instancias de VM

  2. Selecciona una o más instancias suspendidas que quieras reanudar.

  3. Haz clic en Iniciar / Reanudar y, luego, en Iniciar.

gcloud

Para reanudar una o más instancias suspendidas en una sola zona, usa el comando gcloud compute instances resume:

gcloud compute instances resume INSTANCE_NAMES \
    --zone=ZONE

Reemplaza lo siguiente:

  • INSTANCE_NAMES: Es una lista de nombres de instancias separados por espacios en blanco, por ejemplo, instance-01 instance-02 instance-03.

  • ZONE: Es la zona en la que se encuentran las instancias suspendidas.

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 reanudar una instancia suspendida, realiza una solicitud POST al método instances.resume:

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

Reemplaza lo siguiente:

  • INSTANCE_NAME: Es el nombre de la instancia suspendida que se reanudará.

  • PROJECT_ID: El ID del proyecto en el que se encuentra la instancia suspendida.

  • ZONE: Es la zona en la que se encuentra la instancia suspendida.

¿Qué sigue?