Sospendi o riprendi una VM

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

Se vuoi mantenere l'istanza VM a portata di mano ma non vuoi che ti vengano addebitati costi quando non è in uso, puoi sospenderla. Quando sospendi una VM, Google conserva la VM nel 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 conservare la memoria della VM. Attributi come gli indirizzi IP statici rimangono attivi per far sì che le funzioni di rete funzionino come previsto quando ripristini la VM. Dopo il ripristino, Google riporta all'istanza la memoria della VM dallo spazio di archiviazione e inizia ad addebitarti l'istanza VM in esecuzione.

La sospensione di un'istanza è l'ideale per:

  • Ambienti di sviluppo e test che non vengono utilizzati completamente nei periodi di inattività, ad esempio durante la sera o nei fine settimana, per risparmiare sui costi o inizializzare in modo più rapido 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 gestire la prima richiesta, ad esempio workstation virtuali per sviluppatori o applicazioni Java complesse.

Come funziona la sospensione

La sospensione di un'istanza invia un segnale di sospensione ACPI S3 al sistema operativo dell'istanza. La sospensione di un'istanza è analoga alla chiusura del coperchio del laptop e all'attivazione dello stato dell'istanza in SUSPENDED.

La sospensione di un'istanza è diversa dall'arresto di un'istanza per i seguenti modi:

Tutte le risorse collegate all'istanza rimangono collegate all'istanza e verranno addebitate, inclusi i dischi permanenti e gli indirizzi IP esterni statici o prenotati. 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. Per sospendere un'istanza, puoi solo utilizzare Google Cloud CLI o REST.

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. Questo non comporta costi di archiviazione aggiuntivi.

Prima di iniziare

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

    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. Installa Google Cloud CLI, quindi initialize eseguendo questo comando: 

      gcloud init
    2. Set a default region and zone.

      3. Go

      Per utilizzare gli Go esempi in questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura le 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 maggiori informazioni, consulta Set up authentication for a local development environment.

      Java

      Per utilizzare gli Java esempi in questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura le 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 maggiori informazioni, consulta Set up authentication for a local development environment.

      Node.js

      Per utilizzare gli Node.js esempi in questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura le 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 maggiori informazioni, consulta Set up authentication for a local development environment.

      PHP

      Per utilizzare gli PHP esempi in questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura le 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 maggiori informazioni, consulta Set up authentication for a local development environment.

      Python

      Per utilizzare gli Python esempi in questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura le 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 maggiori informazioni, consulta Set up authentication for a local development environment.

      REST

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

        Installa Google Cloud CLI, quindi initialize eseguendo questo comando: 

        gcloud init

      Per maggiori informazioni, consulta Autenticazione per l'utilizzo di REST nella documentazione sull'autenticazione di Google Cloud.

Limitazioni

A 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. L'indicatore "in-ospite" viene ignorato.
  • Puoi sospendere un'istanza solo per un massimo di 60 giorni prima che la VM venga arrestata automaticamente.
  • Non puoi sospendere istanze con più di 208 GB di memoria.
  • Puoi sospendere le istanze prerilasciabili, ma quest'ultima potrebbe essere terminata prima di essere sospesa.
  • 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 un SSD locale comporterà l'eliminazione di tutti i dati sulle unità SSD locali, lo stesso comportamento dell'arresto dell'istanza.

Per ulteriori dettagli, consulta la documentazione sulle unità SSD locali.

VM prerilasciabili

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

Compatibilità del sistema operativo

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

Prezzi

Quando sospendi un'istanza, ti vengono addebitati i costi per:

  • 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 (vedi Prezzi dei dischi permanenti).
  • Eventuali IP statici collegati all'istanza.
  • La sospensione delle VM potrebbe ridurre le tariffe per le licenze software. Ad esempio, se sospendi le VM Windows, non ti verranno addebitate le tariffe per la licenza di Windows. Le tariffe per la licenza di altre immagini potrebbero avere termini e condizioni diversi e comportare addebiti anche in caso di sospensione.

Sospendere 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, l'istanza deve essere completamente avviata (inclusi i 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 eliminare i dati degli SSD locali, seleziona Elimina i contenuti SSD. Quando l'istanza viene ripresa, tutti i dati degli SSD locali nell'istanza vengono eliminati.

gcloud

Per sospendere un'istanza in Google Cloud CLI:

 gcloud compute instances suspend VM_NAME

Dopo aver effettuato una richiesta di sospensione di un'istanza, potrebbe trascorrere un po' di tempo prima che Compute Engine conservi tutti i dati necessari per l'istanza. Durante questo periodo, l'istanza continuerà a esserti addebitata quando è 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 degli SSD locali, devi fornire il flag --discard-local-ssd:

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

Se utilizzi --discard-local-ssd o --discard-local-ssd=True, i contenuti dell'SSD locale verranno eliminati. Compute Engine --discard-local-ssd=False è attualmente in anteprima pubblica. L'uso di questo flag salverà i contenuti di un massimo di 16 dischi SSD locali durante la sospensione. Per ulteriori dettagli, consulta la documentazione sulle unità 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: ID progetto
  • ZONE: la zona della VM
  • VM_NAME: l'istanza che vuoi sospendere

Dopo aver effettuato una richiesta di sospensione di un'istanza, potrebbe trascorrere un po' di tempo prima che Compute Engine conservi tutti i dati necessari per l'istanza. Durante questo periodo, ti viene addebitato un costo per l'istanza 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 ignorare 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 sulle unità SSD locali.

Riprendi un'istanza sospesa

Puoi riprendere un'istanza solo se disponi di capacità sufficiente nella zona in cui si trova la VM. Nella maggior parte dei casi, questo non è un problema, ma se riscontri 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 effettuato una richiesta per ripristinare un'istanza, potrebbe trascorrere un po' di tempo prima che Compute Engine ripristini tutti i dati necessari per l'istanza. Durante questo periodo, ti verrà addebitato un costo per l'istanza mentre è in corso di ripristino.

Un'istanza viene ripresa quando viene contrassegnata come RUNNING. Controlla lo stato di un'istanza effettuando 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

Effettua 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 effettuato una richiesta per ripristinare un'istanza, potrebbe trascorrere un po' di tempo prima che Compute Engine ripristini tutti i dati necessari per l'istanza. Durante questo periodo, ti viene addebitato un costo per l'istanza mentre questa riprende

Compute Engine contrassegna l'istanza con lo stato RUNNING al termine del 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",
...

Sospensione del 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 di ACPI S3 entro un paio di minuti, Compute Engine annulla il tentativo di sospensione e restituisce la VM allo stato RUNNING.

La tabella seguente 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 riprendere, ma devono essere configurate in anticipo. Per configurare l'istanza Debian, completa uno dei seguenti set di istruzioni, l'opzione A o l'opzione B. Ti consigliamo di configurare l'ACPID, se possibile (opzione A).

Opzione A

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

  1. Connettiti alla tua 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 ACPID per gestire l'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 di sonno:

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

  5. Imposta 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 alla tua istanza VM tramite SSH:

    gcloud compute ssh VM_NAME

  2. Nell'istanza VM, installa dbus:

    sudo apt-get install dbus

  3. Riavvia logind:

    sudo systemctl restart systemd-logind.service

Passaggi successivi