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 Suspende, detén o restablece 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. Cuando suspendes una instancia, se conserva y se migra el contenido de su memoria al almacenamiento. Después de reanudar la instancia, Compute Engine migra la memoria de la instancia del almacenamiento a la instancia y esta comienza a ejecutarse de nuevo.

Suspender una instancia de Compute Engine es útil por los siguientes motivos:

  • 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.

Limitaciones

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

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

  • Solo puedes suspender una instancia que use las siguientes imágenes de SO si configuras su SO, como se describe en este documento:

    • Debian 8 o 9

    • Cualquier SO de Windows

  • 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 las VMs Spot o las 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 la instancia se interrumpe.

  • No puedes suspender instancias con los procesos estándar integrados en su entorno invitado. No se admiten comandos como systemctl suspend en Ubuntu 16.04 o versiones posteriores. Si se llama, Compute Engine ignora la señal del invitado.

  • No puedes suspender los siguientes tipos de instancias:

    • Instancias de equipos físicos

    • Confidential VMs

    • Son instancias que tienen GPUs adjuntas.

    • Instancias con más de 208 GB de memoria

    • Instancias que tienen discos protegidos por CSEK adjuntos

Habilita las operaciones de suspensión en un SO invitado

Si tu instancia de procesamiento usa Debian 8 o 9 como SO invitado, o cualquier SO de Windows, debes configurar el SO antes de poder suspender y reanudar instancias. Si tu instancia usa un SO invitado diferente, omite esta sección.

Cómo habilitar las operaciones de suspensión en Debian 8 o 9

Antes de que puedas suspender o reanudar instancias de procesamiento que usan Debian 8 o 9 como SO invitado, debes configurar el SO invitado con uno de los siguientes métodos:

Configura ACPID

Para habilitar la operación de suspensión y reanudación en Debian 8 o 9, puedes configurar el daemon de eventos de la interfaz avanzada de configuración y energía (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 de modo 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 los cambios se apliquen, reinicia 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 los cambios se apliquen, reinicia logind:

    sudo systemctl restart systemd-logind.service

Cómo habilitar las operaciones de suspensión en Windows

Para suspender una instancia que usa un SO invitado de Windows, debes inhabilitar la hibernación en el SO. Si importaste una imagen de Windows, es posible que la hibernación esté habilitada de forma predeterminada, por lo que debes inhabilitarla para suspender la instancia.

Para inhabilitar la hibernación en Windows, sigue estos pasos:

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

  2. Abre PowerShell como administrador.

  3. Inhabilita la hibernación:

    powercfg -h off

  4. Verifica que la hibernación esté inhabilitada:

    powercfg -a

Antes de comenzar

  • Si aún no lo hiciste, configura la autenticación. La autenticación verifica tu identidad para acceder a los servicios y las APIs 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:

    Selecciona la pestaña que corresponda a la forma en que planeas usar las muestras de esta página:

    Console

    Cuando usas la consola de Google Cloud para acceder a los servicios y las APIs de Google Cloud , no necesitas configurar la autenticación.

    gcloud

    1. Instala Google Cloud CLI. Después de la instalación, inicializa Google Cloud CLI con el siguiente comando: 

      gcloud init

      Si usas un proveedor de identidad externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.

  • Configura una región y una zona predeterminadas.

    • 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. Instala Google Cloud CLI.

    2. Si usas un proveedor de identidad (IdP) externo, primero debes acceder a gcloud CLI con tu identidad federada.

    3. Si usas un shell local, crea credenciales de autenticación locales para tu cuenta de usuario: 

      gcloud auth application-default login

      No es necesario que lo hagas si usas Cloud Shell.

      Si se devuelve un error de autenticación y usas un proveedor de identidad (IdP) externo, confirma que accediste a la gcloud CLI con tu identidad federada.

    Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

    Java

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

    1. Instala Google Cloud CLI.

    2. Si usas un proveedor de identidad (IdP) externo, primero debes acceder a gcloud CLI con tu identidad federada.

    3. Si usas un shell local, crea credenciales de autenticación locales para tu cuenta de usuario: 

      gcloud auth application-default login

      No es necesario que lo hagas si usas Cloud Shell.

      Si se devuelve un error de autenticación y usas un proveedor de identidad (IdP) externo, confirma que accediste a la gcloud CLI con tu identidad federada.

    Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

    Node.js

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

    1. Instala Google Cloud CLI.

    2. Si usas un proveedor de identidad (IdP) externo, primero debes acceder a gcloud CLI con tu identidad federada.

    3. Si usas un shell local, crea credenciales de autenticación locales para tu cuenta de usuario: 

      gcloud auth application-default login

      No es necesario que lo hagas si usas Cloud Shell.

      Si se devuelve un error de autenticación y usas un proveedor de identidad (IdP) externo, confirma que accediste a la gcloud CLI con tu identidad federada.

    Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

    PHP

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

    1. Instala Google Cloud CLI.

    2. Si usas un proveedor de identidad (IdP) externo, primero debes acceder a gcloud CLI con tu identidad federada.

    3. Si usas un shell local, crea credenciales de autenticación locales para tu cuenta de usuario: 

      gcloud auth application-default login

      No es necesario que lo hagas si usas Cloud Shell.

      Si se devuelve un error de autenticación y usas un proveedor de identidad (IdP) externo, confirma que accediste a la gcloud CLI con tu identidad federada.

    Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

    Python

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

    1. Instala Google Cloud CLI.

    2. Si usas un proveedor de identidad (IdP) externo, primero debes acceder a gcloud CLI con tu identidad federada.

    3. Si usas un shell local, crea credenciales de autenticación locales para tu cuenta de usuario: 

      gcloud auth application-default login

      No es necesario que lo hagas si usas Cloud Shell.

      Si se devuelve un error de autenticación y usas un proveedor de identidad (IdP) externo, confirma que accediste a la gcloud CLI con tu identidad federada.

    Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

    REST

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

      Instala Google Cloud CLI.

      Si usas un proveedor de identidad externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.

    Para obtener más información, consulta Autentícate 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 Compute, 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.

Suspende una instancia

Si el SO invitado de tu instancia de procesamiento usa Debian 8 o 9, antes de suspender la instancia, debes configurar el SO invitado para que admita 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:

Suspende una instancia sin discos SSD locales

Puedes suspender varias instancias de procesamiento de forma simultánea o instancias individuales. Para varias instancias, usa la consola de Google Cloud o, para las 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 quieras suspender de forma simultánea y si necesitas conservar los datos de sus discos SSD locales conectados, haz lo siguiente:

  • Para conservar los datos de los discos SSD locales conectados a una instancia (excepto las instancias con discos SSD de Titanium), suspende la instancia con gcloud CLI o la API de REST.

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

Para suspender una o más instancias que tienen 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 deseas descartar o conservar los datos de SSD locales 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 tenga discos SSD locales conectados, especifica si deseas descartar o conservar 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 SSD local, haz 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 las SSD locales cuando la suspendiste, es posible que debas volver a conectar los discos SSD locales después de reanudarla. Para obtener más información, consulta cómo volver a activar discos que no sean de arranque en instancias de Linux o instancias de Windows.

Puedes reanudar varias instancias simultáneamente o instancias individuales. Para varias instancias, usa la consola de Google Cloud o, para las instancias ubicadas en la misma zona, gcloud CLI. En el caso de las 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 para reanudarlas.

  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: Es 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?