Sospendi o riprendi una VM

Questo documento descrive come sospendere o ripristinare l'istanza di una macchina virtuale (VM).

Se vuoi mantenere l'istanza VM a disposizione, ma non vuoi ricevere addebiti quando non è in uso, puoi sospendere la VM. Quando sospendi una VM, Google conserva la VM nel tuo progetto e sposta i contenuti della memoria della VM nello spazio di archiviazione. Mentre la VM è sospesa, Google addebita solo lo spazio di archiviazione utilizzato per preservare la memoria della VM. Attributi come gli indirizzi IP statici rimangono attivi in modo che le funzioni di rete funzionino come previsto quando riprendi la VM. Dopo il ripristino, Google sposta la memoria della VM dallo spazio di archiviazione all'istanza e inizia ad addebitare i costi per l'istanza VM ora in esecuzione.

La sospensione di un'istanza è ideale per:

  • Ambienti di sviluppo e test che non vengono utilizzati completamente durante i periodi di inattività, ad esempio di sera o nei fine settimana, per risparmiare sui costi o eseguire un'inizializzazione più rapida rispetto alla creazione di nuove istanze VM.
  • Applicazioni che richiedono un lungo periodo di inizializzazione dopo il termine dell'avvio dell'istanza, ma prima che l'applicazione sia pronta per soddisfare la sua prima richiesta, ad esempio workstation di sviluppo virtuali o applicazioni Java complesse.

Come funziona la sospensione

La sospensione di un'istanza invia un segnale di sospensione di ACPI S3 al sistema operativo dell'istanza. La sospensione di un'istanza è analoga alla chiusura del coperchio del laptop, impostando lo stato SUSPENDED per l'istanza.

La sospensione di un'istanza presenta le seguenti differenze rispetto all'arresto di un'istanza:

Tutte le risorse collegate all'istanza rimangono collegate all'istanza e verranno addebitate, inclusi i dischi permanenti e gli indirizzi IP esterni statici o riservati. Tutte queste risorse vengono addebitate in base al listino prezzi, anche se un'istanza è sospesa.

Non puoi sospendere un'istanza utilizzando i processi standard integrati nell'ambiente guest. I comandi, come il comando systemctl suspend in Ubuntu 16.04 e versioni successive, non sono disponibili. Puoi utilizzare solo Google Cloud CLI o REST per sospendere un'istanza.

Se non ti interessa ripristinare la memoria e lo stato del dispositivo di un'istanza quando riprendi l'istanza in un secondo momento, puoi arrestare l'istanza, il che non comporta costi di archiviazione aggiuntivi.

Prima di iniziare

  • Se non l'hai ancora fatto, configura l'autenticazione. L'autenticazione è il processo mediante il quale viene verificata l'identità per l'accesso ai servizi e alle API Google Cloud. Per eseguire codice o esempi da un ambiente di sviluppo locale, puoi autenticarti in Compute Engine nel seguente modo.

    Seleziona la scheda relativa a come prevedi di utilizzare gli esempi in questa pagina:

    Console

    Quando utilizzi la console Google Cloud per accedere ai servizi e alle API di Google Cloud, non devi configurare l'autenticazione.

    gcloud

    1. Installa Google Cloud CLI, quindi initialize eseguendo questo comando: 

      gcloud init
    2. Imposta una regione e una zona predefinite.

    Go

    Per utilizzare gli esempi Go in questa pagina da un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

    1. Installa Google Cloud CLI.

    2. Per initialize gcloud CLI, esegui questo comando: 

      gcloud init

    3. Crea credenziali di autenticazione locali per il tuo Account Google: 

      gcloud auth application-default login

    Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

    Java

    Per utilizzare gli esempi Java in questa pagina da un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

    1. Installa Google Cloud CLI.

    2. Per initialize gcloud CLI, esegui questo comando: 

      gcloud init

    3. Crea credenziali di autenticazione locali per il tuo Account Google: 

      gcloud auth application-default login

    Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

    Node.js

    Per utilizzare gli esempi Node.js in questa pagina da un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

    1. Installa Google Cloud CLI.

    2. Per initialize gcloud CLI, esegui questo comando: 

      gcloud init

    3. Crea credenziali di autenticazione locali per il tuo Account Google: 

      gcloud auth application-default login

    Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

    PHP

    Per utilizzare gli esempi PHP in questa pagina da un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

    1. Installa Google Cloud CLI.

    2. Per initialize gcloud CLI, esegui questo comando: 

      gcloud init

    3. Crea credenziali di autenticazione locali per il tuo Account Google: 

      gcloud auth application-default login

    Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

    Python

    Per utilizzare gli esempi Python in questa pagina da un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

    1. Installa Google Cloud CLI.

    2. Per initialize gcloud CLI, esegui questo comando: 

      gcloud init

    3. Crea credenziali di autenticazione locali per il tuo Account Google: 

      gcloud auth application-default login

    Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

    REST

    Per utilizzare gli esempi di API REST in questa pagina in un ambiente di sviluppo locale, devi utilizzare le credenziali che fornisci a gcloud CLI.

      Installa Google Cloud CLI, quindi initialize eseguendo questo comando: 

      gcloud init

Limitazioni

Per questa funzionalità si applicano le seguenti limitazioni:

  • Non puoi sospendere un'istanza che utilizza una GPU.
  • Non puoi sospendere un'istanza utilizzando i processi standard integrati nell'ambiente guest. I comandi, come il comando systemctl suspend in Ubuntu 16.04 e versioni successive, non sono disponibili. Il segnale in presenza di ospiti viene ignorato.
  • Puoi sospendere un'istanza solo per un massimo di 60 giorni prima che la VM venga arrestata automaticamente.
  • Non puoi sospendere le istanze con più di 208 GB di memoria.
  • Puoi sospendere le istanze prerilasciabili, che però potrebbero essere terminate prima di essere sospese.
  • Non puoi sospendere una Confidential VM.
  • Non puoi sospendere una VM a cui sono collegati dischi protetti da CSEK.

SSD locali

Normalmente, la sospensione di un'istanza VM che utilizza SSD locale ignora tutti i dati sulle unità SSD locali, lo stesso comportamento dell'arresto dell'istanza.

Per ulteriori dettagli, consulta la documentazione relativa agli SSD locali.

VM prerilasciabili

Puoi sospendere una VM prerilasciabile ma, se si verifica il prerilascio (non l'avviso anticipato che precede il prerilascio) prima del completamento dell'operazione di sospensione, la sospensione e l'istanza vengono prerilasciate.

Compatibilità del sistema operativo

La maggior parte dei sistemi operativi (OS) offerti su Compute Engine supporta la funzionalità di sospensione e ripristino, ma alcuni non lo supportano. Consulta la pagina Dettagli del sistema operativo per l'elenco completo.

Prezzi

Quando sospendi un'istanza, ti viene addebitato quanto segue:

  • Memoria dell'istanza (consulta i prezzi delle istanze VM sospese).
  • Qualsiasi utilizzo di disco permanente per il disco di avvio ed eventuali dischi aggiuntivi collegati all'istanza (consulta Prezzi dei dischi permanenti).
  • Eventuali IP statici collegati all'istanza.
  • La sospensione delle VM potrebbe farti risparmiare sulle tariffe delle licenze software. Ad esempio, se sospendi delle VM Windows, non ti vengono addebitate le tariffe per la licenza Windows. Le tariffe per le licenze di altre immagini potrebbero avere termini e condizioni diversi e potrebbero comportare addebiti anche in caso di sospensione.

Sospendi un'istanza

Per sospendere un'istanza, utilizza la console Google Cloud, gcloud CLI, l'API o le librerie client di Cloud.

Non puoi sospendere un'istanza utilizzando i processi standard integrati nell'ambiente guest. Per sospendere un'istanza, puoi utilizzare la console Google Cloud, Google Cloud CLI o l'API.

L'operazione di sospensione può non riuscire se viene attivata troppo presto dopo l'avvio dell'istanza. Affinché l'operazione di sospensione vada a buon fine, è necessario che l'istanza sia stata avviata completamente, inclusi processi come l'agente guest.

Console

  1. Nella console Google Cloud, vai alla pagina Istanze VM.

    Vai alla pagina Istanze VM

  2. Seleziona una o più istanze da sospendere.

  3. Fai clic su Sospendi.

  4. Quando richiesto, se vuoi ignorare i dati degli SSD locali, seleziona Ignora i contenuti dell'SSD. Quando l'istanza viene ripresa, tutti i dati SSD locali dell'istanza verranno ignorati.

gcloud

Per sospendere un'istanza in Google Cloud CLI:

 gcloud compute instances suspend VM_NAME

Dopo aver effettuato una richiesta per sospendere un'istanza, Compute Engine può impiegare un po' di tempo per conservare tutti i dati necessari per l'istanza. Durante questo periodo, continuerai a ricevere l'addebito per l'istanza mentre è in esecuzione.

Un'istanza sospesa è contrassegnata dallo stato SUSPENDED. Controlla lo stato di un'istanza effettuando una richiesta describe:

gcloud compute instances describe VM_NAME

Per sospendere un'istanza con dati SSD locali, devi fornire il flag --discard-local-ssd:

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

L'utilizzo di --discard-local-ssd o --discard-local-ssd=True eliminerà i contenuti dell'SSD locale. Compute Engine --discard-local-ssd=False è attualmente in Anteprima pubblica. L'utilizzo di questo flag salverà i contenuti di un massimo di 16 dischi SSD locali durante la sospensione. Per ulteriori dettagli, consulta la documentazione relativa agli SSD locali.

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

Nell'API, effettua una richiesta utilizzando il metodo instances.suspend:

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

Sostituisci quanto segue:

  • PROJECT_ID: l'ID progetto
  • ZONE: la zona della VM
  • VM_NAME: l'istanza che vuoi sospendere

Dopo aver effettuato una richiesta per sospendere un'istanza, Compute Engine può impiegare un po' di tempo per conservare tutti i dati necessari per l'istanza. Durante questo periodo, l'istanza ti verrà addebitata mentre è in esecuzione.

Compute Engine contrassegna l'istanza sospesa con lo stato SUSPENDED. Controlla lo stato di un'istanza effettuando una richiesta GET:

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

Lo stato dell'istanza è visibile nel campo dello stato. Ad esempio:

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

Per sospendere un'istanza con più di 16 dischi SSD locali, devi eliminare i dati degli SSD locali fornendo il parametro di query discardLocalSsd come segue:

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

Per ulteriori informazioni, consulta la documentazione relativa agli SSD locali.

Riprendi un'istanza sospesa

Puoi riprendere un'istanza solo se c'è capacità sufficiente nella zona in cui si trova la VM. Nella maggior parte dei casi, non si tratta di un problema, ma se si verificano problemi di capacità, riprova a inviare la richiesta di ripristino in un secondo momento.

Per riprendere un'istanza sospesa, utilizza la console Google Cloud, gcloud CLI, l'API o le librerie client di Cloud.

Console

  1. Nella console Google Cloud, vai alla pagina Istanze VM.

    Vai alla pagina Istanze VM

  2. Seleziona una o più istanze da riprendere.

  3. Fai clic su Avvia/Riprendi.

gcloud

Per riprendere un'istanza in Google Cloud CLI:

 gcloud compute instances resume VM_NAME

Dopo aver inviato una richiesta per riprendere un'istanza, Compute Engine può impiegare un po' di tempo per ripristinare tutti i dati necessari per l'istanza. Durante questo periodo, ti viene addebitato l'importo per l'istanza mentre è in fase di ripresa.

Un'istanza viene ripresa quando è contrassegnata come RUNNING. Controlla lo stato di un'istanza inviando una richiesta di descrizione:

gcloud compute instances describe VM_NAME

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

Invia una richiesta al metodo instances.resume:

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

Sostituisci quanto segue:

  • PROJECT_ID: l'ID progetto per questa richiesta
  • ZONE: la zona della VM
  • VM_NAME: l'istanza da riprendere

Dopo aver inviato una richiesta per riprendere un'istanza, Compute Engine può impiegare un po' di tempo per ripristinare tutti i dati necessari per l'istanza. Durante questo periodo, ti verrà addebitato l'importo per l'istanza mentre viene ripresa

Compute Engine contrassegna l'istanza con lo stato RUNNING una volta completato il ripristino. Controlla lo stato di un'istanza effettuando una richiesta GET:

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

Lo stato dell'istanza è visibile nel campo dello stato. Ad esempio:

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

Sospendi processo

Quando effettui una richiesta di sospensione, invii un segnale di sospensione ACPI all'istanza VM. Se la VM non risponde al segnale di sospensione ACPI S3 entro un paio di minuti, Compute Engine annulla il tentativo di sospensione e riporta la VM allo stato RUNNING.

La seguente tabella descrive l'effetto della sospensione di un'istanza VM sulle risorse associate:

Risorsa Assistenza
Memoria Puoi sospendere solo le VM con meno o uguale a 208 GB di memoria
SSD locale I dati degli SSD locali vengono ignorati
Disco permanente I dischi HDD e SSD permanenti vengono conservati
Indirizzi IP Gli IP temporanei vengono rilasciati durante la sospensione, ma gli IP statici rimangono collegati alle istanze VM. Se vuoi conservare il tuo IP temporaneo, promuovilo.
Configurazione delle VM (ad esempio tipo di macchina, metadati, etichette e così via) Tutte le configurazioni delle VM, ad eccezione degli indirizzi IP temporanei, vengono conservate e ripristinate al riavvio dell'istanza.

Configurazione di una VM Debian per supportare la sospensione e il ripristino

Le VM che eseguono Debian 8 e 9 possono essere sospese e riprese, ma devono essere configurate in anticipo. Per configurare l'istanza Debian, completa uno dei seguenti insiemi di istruzioni, opzione A o opzione B. Ti consigliamo di configurare l'ACPID, se possibile (opzione A).

Opzione A

Questa opzione configura l'ACPID per la gestione dell'evento del pulsante Sonno e aggiunge uno script shell per la gestione dell'evento.

  1. Connettiti all'istanza VM tramite SSH:

    gcloud compute ssh VM_NAME

  2. Nell'istanza VM, crea una directory nella cartella acpi:

    sudo mkdir -p /etc/acpi/events/

  3. Configura l'ACPID per la gestione dell'evento del pulsante di sospensione:

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

  4. Crea lo script di gestione degli eventi del sonno:

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

  5. Configura le autorizzazioni per lo script:

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

  6. Riavvia ACPID:

    sudo systemctl restart acpid.service

Opzione B

  1. Connettiti all'istanza VM tramite SSH:

    gcloud compute ssh VM_NAME

  2. Sull'istanza VM, installa dbus:

    sudo apt-get install dbus

  3. Riavvia logind:

    sudo systemctl restart systemd-logind.service

Passaggi successivi