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 a portata di mano ma non vuoi che ti vengano addebitati dei costi quando non è in uso, puoi sospendere la VM. Quando sospendi una VM, Google conserva la VM nel progetto e sposta i contenuti della memoria della VM 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. Dopo il giorno quando riprenda, Google sposta la memoria della VM dallo spazio di archiviazione e inizierà ad addebitare i costi per l'istanza VM in esecuzione.

La sospensione di un'istanza è ideale per:

  • Ambienti di sviluppo e test che non vengono utilizzati completamente durante periodi di pausa, ad esempio durante la sera o i fine settimana, per risparmiare o accelerare anziché la creazione di nuove istanze VM.
  • Applicazioni che richiedono un lungo periodo di inizializzazione dopo l'istanza abbia terminato l'avvio, ma prima che l'applicazione sia pronta a servire il suo primo come workstation virtuali di sviluppo 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 da arresto di un'istanza nei seguenti modi:

Tutte le risorse collegate all'istanza rimangono collegate all'istanza e verrà addebitato un costo, inclusi i dischi permanenti e i dischi permanenti statici o riservati e gli indirizzi IP esterni. Per tutte queste risorse viene addebitato l'importo indicato nel listino dei prezzi, anche se un'istanza è sospesa.

Non puoi sospendere un'istanza utilizzando le procedure standard integrate nell'ambiente ospite. Comandi, ad esempio systemctl suspend in Ubuntu 16.04 e successivi, 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. Autenticazione è Il processo di verifica dell'identità per l'accesso ai servizi e alle API di Google Cloud. Per eseguire codice o esempi da un ambiente di sviluppo locale, puoi eseguire l'autenticazione 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. 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 a riga di comando gcloud, 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 a riga di comando gcloud, 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 una località dell'ambiente di sviluppo, installare e inizializzare gcloud CLI quindi configura 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, vedi Set up authentication for a local development environment.

      PHP

      Per utilizzare gli PHP esempi in questa pagina in una località dell'ambiente di sviluppo, installare e inizializzare gcloud CLI quindi configura 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, vedi 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 a riga di comando gcloud, 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, vedi 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 ulteriori informazioni, vedi Esegui 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. Comandi, ad esempio systemctl suspend in Ubuntu 16.04 e successivi, non sono disponibili. L'indicatore in-guest viene ignorato.
  • Puoi sospendere un'istanza solo per un massimo di 60 giorni prima che la VM automaticamente.
  • Non puoi sospendere istanze con più di 208 GB di memoria.
  • Puoi sospendere le istanze prerilasciabili, ma quest'ultima potrebbe essere è stato risolto prima della sospensione.
  • 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 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 relativa agli SSD locali.

VM prerilasciabili

Puoi sospendere una VM preassegnabile, ma se avviene la preassegnazione (non l'avviso che la precede) prima del completamento dell'operazione di sospensione, la sospensione esce e l'istanza viene preassegnata.

Compatibilità del sistema operativo

La maggior parte dei sistemi operativi (OS) offerti su Compute Engine supportano la funzionalità di sospensione e ripristino, ma alcuni sistemi operativi non lo supportano. 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 dischi permanenti per il disco di avvio e per 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 vengono addebitati i costi per la licenza 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 i processi standard creati 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 (inclusi processi come Ospite speciale) affinché l'operazione di sospensione venga completata correttamente.

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 dell'unità SSD. Quando l'istanza viene ripresa, qualsiasi SSD locale i dati sull'istanza verranno 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, può essere necessario un po' di tempo Compute Engine per conservare tutti i dati necessari per l'istanza. Durante questa volta, l'istanza continuerà a esserti addebitata finché sarà 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'uso di questo flag salverà i contenuti di un massimo di 32 dischi SSD locali durante la sospensione. Per ulteriori dettagli, consulta la documentazione sulle unità 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, invia 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 di sospensione di un'istanza, può essere necessario un po' di tempo Compute Engine per conservare tutti i dati necessari per l'istanza. Durante questa volta, ti verrà 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 32 i dischi SSD locali, deve ignorare i dati degli SSD locali fornendo la 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 dispone di capacità sufficiente nella zona in cui su cui risiede la VM. Nella maggior parte dei casi, questo non è un problema, ma se 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 riprendere un'istanza, potrebbe essere necessario un po' di tempo in Compute Engine di ripristinare 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

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 riprendere un'istanza, potrebbe essere necessario un po' di tempo in Compute Engine di ripristinare tutti i dati necessari per l'istanza. Durante questa volta, ti viene addebitato l'importo per l'istanza mentre è in corso il ripristino

Al termine del ripristino, Compute Engine contrassegna l'istanza con lo stato RUNNING. Controlla lo stato di un'istanza eseguendo una Richiesta di 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 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 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 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 riprendere, ma devono essere configurate in anticipo. 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 pulsante di sospensione e aggiunge uno script shell per la gestione dell'evento di sonno.

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