Sospendi o riprendi una VM

Questo documento descrive come sospendere o ripristinare una macchina virtuale (VM) in esecuzione in un'istanza Compute Engine.

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 la memoria della VM. Attributi come gli indirizzi IP statici rimangono presenti, 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 è l'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 Sospensione di ACPI S3 al sistema operativo dell'istanza. La sospensione di un'istanza è analoga alla chiusura del coperchio del laptop, inserendo l'istanza in un SUSPENDED stato.

La sospensione di un'istanza è diversa arresto di un'istanza nei seguenti modi:

• Le istanze sospese mantengono la memoria del sistema operativo guest, lo stato del dispositivo dell'applicazione.
• Google addebita il costo per lo spazio di archiviazione necessario per risparmiare memoria dell'istanza.
• Puoi sospendere un'istanza per un massimo di 60 giorni. Dopo 60 giorni, l'istanza viene spostato automaticamente allo stato TERMINATED.

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. Tutte queste risorse vengono addebitate in base Listino prezzi, anche se un'istanza è sospesa.

Non puoi sospendere un'istanza utilizzando i processi standard creati 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 è importante ripristinare la memoria e lo stato del dispositivo di un'istanza quando riprendi l'istanza in un secondo momento, Arresta l'istanza al posto tuo, che non comporta costi di archiviazione aggiuntivi.

Prima di iniziare

• Se non l'hai già 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. Installa Google Cloud CLI, quindi initialize eseguendo questo comando:

     gcloud init

     Nota: se hai già installato gcloud CLI in precedenza, assicurati di disporre della versione più recente eseguendo gcloud components update.
  2. Set a default region and zone.

  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 creati nell'ambiente ospite. Comandi, ad esempio systemctl suspend in Ubuntu 16.04 e successivi, non sono disponibili. L'indicatore "in-ospite" viene ignorato.
• Puoi sospendere un'istanza solo per un massimo di 60 giorni prima che la VM interrotto 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 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 che precede il prerilascio) prima del completamento dell'operazione, la sospensione termina viene prerilasciata.

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. Consulta la pagina dei dettagli del sistema operativo per vedere 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 vengono addebitati i costi per la licenza di Windows. Licenza le tariffe per altre immagini potrebbero avere termini e condizioni diversi e potrebbero di addebiti anche in caso di sospensione.

Sospendere un'istanza

Autorizzazioni richieste per questa attività

Per eseguire questa attività, devi disporre di quanto segue autorizzazioni:

• compute.instances.suspend nell'istanza

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

Non puoi sospendere un'istanza utilizzando i processi standard creati nell'ambiente ospite. Puoi utilizzare la console Google Cloud , il Google Cloud CLI o l'API per sospendere un'istanza.

L'operazione di sospensione può non riuscire se viene attivata troppo presto dopo l'istanza è stata avviata. 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 SSD. Quando l'istanza viene ripresa, qualsiasi SSD locale i dati dell'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 spazio di archiviazione 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 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, effettua una richiesta utilizzando 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, 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 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 sulle unità 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.

Autorizzazioni richieste per questa attività

Per eseguire questa attività, devi disporre di quanto segue autorizzazioni:

• compute.instances.resume nell'istanza

Per riprendere un'istanza sospesa, utilizza la console Google Cloud , il gcloud CLI, API oppure 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, l'istanza ti viene addebitata mentre è riprendi.

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

Compute Engine contrassegna l'istanza con RUNNING una volta completato il ripristino. 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",
...

Sospensione del processo

Quando effettui una richiesta di sospensione, invii un segnale di sospensione ACPI alla VM in esecuzione in un'istanza Compute Engine. 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 sul suo 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 collegate alle istanze VM. Se vuoi conservare la tua sessione IP, promuoverlo.
Configurazione delle VM (ad esempio tipo di macchina, metadati, etichette e così via)	Tutte le configurazioni delle VM, tranne gli indirizzi IP temporanei, vengono conservate e ripristinato quando viene ripresa l'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 una delle seguendo una 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 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

• Elimina un'istanza se non vuoi più ne hai bisogno.
• Arresta o riavvia un'istanza.
• Esamina il ciclo di vita dell'istanza.
• Consulta Risoluzione dei problemi relativi alla sospensione delle VM in caso di problemi nella sospensione di una VM.