Sospendi o riprendi una VM

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

Se vuoi mantenere l'istanza VM, ma non vuoi che ti venga addebitato un costo quando non è in uso, puoi sospenderla. Quando sospendi una VM, Google la conserva 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 conservare la memoria della VM. Attributi come gli indirizzi IP statici rimangono invariati in modo che le funzioni di rete funzionino come previsto quando riprendi la VM. Al termine della ripresa, Google sposta la memoria della VM dallo spazio di archiviazione all'istanza e inizia a addebitarti 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 riposo, ad esempio la sera o i fine settimana, per risparmiare sui costi o per un'inizializzazione più rapida rispetto alla creazione di nuove istanze VM.
  • Applicazioni che richiedono un lungo periodo di inizializzazione al 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 ACPI S3 suspend al sistema operativo dell'istanza. La sospensione di un'istanza è analoga alla chiusura del coperchio del laptop, che mette l'istanza in stato SUSPENDED.

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

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. Per tutte queste risorse viene addebitato il prezzo indicato nel listino dei prezzi, anche se un'istanza è sospesa.

Non puoi sospendere un'istanza utilizzando le procedure standard integrate nell'ambiente ospite. 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 la riprendi in un secondo momento, puoi interromperla, senza costi di archiviazione aggiuntivi.

Prima di iniziare

  • Se non l'hai ancora fatto, configura l'autenticazione. L'autenticazione è la procedura mediante la quale la tua identità viene verificata per l'accesso alle API e ai servizi Google Cloud. Per eseguire codice o esempi da un ambiente di sviluppo locale, puoi autenticarti su Compute Engine selezionando una delle seguenti opzioni:

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

    Console

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

    gcloud

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

      gcloud init
    2. Set a default region and zone.

      3. Vai

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

      1. Install the Google Cloud CLI.

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

        gcloud init

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

        gcloud auth application-default login

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

      Per ulteriori 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 l'interfaccia alla gcloud CLI, quindi configura le Credenziali predefinite dell'applicazione con le tue credenziali utente.

      1. Install the Google Cloud CLI.

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

        gcloud init

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

        gcloud auth application-default login

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

      Per ulteriori 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 l'interfaccia alla gcloud CLI, quindi configura le Credenziali predefinite dell'applicazione con le tue credenziali utente.

      1. Install the Google Cloud CLI.

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

        gcloud init

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

        gcloud auth application-default login

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

      Per ulteriori 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 l'interfaccia alla gcloud CLI, quindi configura le Credenziali predefinite dell'applicazione con le tue credenziali utente.

      1. Install the Google Cloud CLI.

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

        gcloud init

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

        gcloud auth application-default login

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

      Per ulteriori 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 l'interfaccia alla gcloud CLI, quindi configura le Credenziali predefinite dell'applicazione con le tue credenziali utente.

      1. Install the Google Cloud CLI.

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

        gcloud init

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

        gcloud auth application-default login

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

      Per ulteriori informazioni, consulta Set up authentication for a local development environment.

      REST

      Per utilizzare gli esempi dell'API REST in questa pagina in un ambiente di sviluppo locale, utilizza le credenziali fornite a gcloud CLI.

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

        gcloud init

      Per saperne di più, consulta Eseguire l'autenticazione per l'utilizzo di REST nella documentazione sull'autenticazione di Google Cloud.

Limitazioni

Per questa funzionalità si applicano le seguenti limitazioni:

  • Non puoi sospendere un'istanza che utilizza una GPU.
  • Non puoi sospendere un'istanza Bare Metal.
  • Non puoi sospendere un'istanza utilizzando le procedure standard integrate nell'ambiente ospite. I comandi, come il comando systemctl suspend in Ubuntu 16.04 e versioni successive, non sono disponibili. L'indicatore in-guest 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 preemibili, ma l'istanza preemibile potrebbe essere terminata prima di essere sospesa correttamente.
  • Non puoi sospendere una Confidential VM.
  • Non puoi sospendere una VM con dischi protetti tramite CSEK collegati.

SSD locali

Normalmente, la sospensione di un'istanza VM che utilizza un'unità SSD locale comporta l'eliminazione di 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 preassegnabile, ma se avviene la preassegnazione (non l'avviso che precede la preassegnazione) prima del completamento dell'operazione di sospensione, la sospensione esce e l'istanza viene preassegnata.

Compatibilità con il sistema operativo

La maggior parte dei sistemi operativi (SO) offerti su Compute Engine supporta la funzionalità di sospensione e ripresa, ma alcuni non lo fanno. Per l'elenco completo, consulta la pagina Dettagli sistema operativo.

Prezzi

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

  • Memoria dell'istanza (consulta i prezzi per le istanze VM sospese).
  • Eventuale utilizzo di disco permanente per il disco di avvio e per eventuali dischi aggiuntivi collegati all'istanza (vedi Prezzi dei dischi permanenti).
  • Eventuali IP statici associati all'istanza.
  • La sospensione delle VM potrebbe farti risparmiare sulle tariffe di licenza del software. Ad esempio, se sospendi le VM Windows, non devi sostenere costi per le licenze di Windows. Le commissioni 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 le procedure standard integrate nell'ambiente ospite. Puoi utilizzare la console Google Cloud, Google Cloud CLI o l'API per sospendere un'istanza.

L'operazione di sospensione può non riuscire se viene attivata troppo presto dopo l'avvio dell'istanza. L'istanza deve essere completamente avviata (incluse procedure come Guest Agent) perché l'operazione di sospensione vada a buon fine.

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. Se vuoi eliminare i dati dell'unità SSD locale, quando richiesto, seleziona Elimina contenuti dell'unità SSD. Quando l'istanza viene ripresa, tutti i dati dell'SSD locale sull'istanza verranno eliminati.

gcloud

Per sospendere un'istanza in Google Cloud CLI:

 gcloud compute instances suspend VM_NAME

Dopo aver inviato una richiesta di sospensione di un'istanza, può essere necessario del tempo prima che Compute Engine conservi tutti i dati necessari per l'istanza. Durante questo periodo, continuerai a ricevere gli addebiti per l'istanza finché rimane in esecuzione.

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

gcloud compute instances describe VM_NAME

Per sospendere un'istanza con dati dell'SSD locale, 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'unità SSD locale verranno eliminati. Compute Engine --discard-local-ssd=False è attualmente in Anteprima pubblica. L'utilizzo di questo flag consente di salvare i contenuti di massimo 32 dischi SSD locali durante la sospensione. Per ulteriori dettagli, consulta la documentazione relativa agli SSD locali.

Vai 

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 inviato una richiesta di sospensione di un'istanza, può essere necessario del tempo prima che Compute Engine conservi tutti i dati necessari per l'istanza. Durante questo periodo, ti viene addebitato il costo dell'istanza finché rimane in esecuzione.

Compute Engine contrassegna l'istanza sospesa con lo stato SUSPENDED. Controlla lo stato di un'istanza inviando 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 32 dischi SSD locali, devi eliminare i dati dell'SSD locale 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.

Ripristinare un'istanza sospesa

Puoi riprendere un'istanza solo se la zona in cui risiede la VM dispone di capacità sufficiente. Nella maggior parte dei casi, non si tratta di un problema, ma se riscontri problemi di capacità, riprova a inviare la richiesta di ripresa 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 di ripresa di un'istanza, potrebbe essere necessario del tempo prima che Compute Engine ripristini tutti i dati necessari per l'istanza. Durante questo periodo, ti viene addebitato il costo dell'istanza mentre viene ripresa.

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

gcloud compute instances describe VM_NAME

Vai 

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 di ripresa di un'istanza, potrebbe essere necessario del tempo prima che Compute Engine ripristini tutti i dati necessari per l'istanza. Durante questo periodo, ti viene addebitato l'utilizzo dell'istanza durante la ripresa

Al termine del ripristino, Compute Engine contrassegna l'istanza con lo stato RUNNING. Controlla lo stato di un'istanza inviando una richiestaGET:

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 reimposta la VM in uno stato RUNNING.

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

Risorsa Assistenza
Memoria È possibile sospendere solo le VM con una memoria inferiore o uguale a 208 GB
SSD locale I dati dell'unità SSD locale 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 associati alle istanze VM. Se vuoi conservare il tuo IP temporaneo, promuovilo.
Configurazione della 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 la ripresa

Le VM che eseguono Debian 8 e 9 possono essere sospese e riattivate, ma devono essere configurate in precedenza. Per configurare l'istanza Debian, completa una delle seguenti serie 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 gestire l'evento del tasto di sospensione e aggiunge un script shell per la gestione dell'evento di sospensione.

  1. Connettiti all'istanza VM utilizzando 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 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 dell'evento di sospensione:

    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. Riavviare l'ACPID:

    sudo systemctl restart acpid.service

Opzione B

  1. Connettiti all'istanza VM utilizzando 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