Suspendre ou réactiver une VM

Linux Windows

---

Ce document explique comment suspendre ou réactiver une instance de machine virtuelle (VM).

Si vous souhaitez conserver votre instance de VM sans qu'elle ne vous soit facturée lorsqu'elle n'est pas utilisée, vous pouvez la suspendre. Lorsque vous suspendez une VM, Google la conserve dans votre projet et déplace le contenu de sa mémoire vers un espace de stockage. Lorsque la VM est suspendue, Google ne facture que le stockage utilisé pour conserver la mémoire de la VM. Des attributs tels que les adresses IP statiques restent en place afin que les fonctions réseau fonctionnent comme prévu lorsque vous réactivez la VM. Une fois la VM réactivée, Google déplace sa mémoire de l'espace de stockage vers l'instance et commence à vous facturer l'instance de VM en cours d'exécution.

La suspension d'une instance est idéale pour les cas suivants :

• Pour les environnements de développement et de test qui ne sont pas pleinement utilisés pendant les périodes creuses, telles que le soir ou le week-end, pour réduire les coûts ou accélérer l'initialisation plutôt que de créer de nouvelles instances de VM.
• Pour les applications qui nécessitent une longue période d'initialisation après le démarrage de l'instance, mais avant que l'application soit prête à traiter sa première requête, telles que des postes de travail de développeur virtuel ou des applications Java complexes.

Fonctionnement de la suspension

La suspension d'une instance entraîne l'envoi d'un signal ACPI S3 Suspend au système d'exploitation de l'instance. La suspension d'une instance revient à fermer le capot de votre ordinateur portable, causant un état SUSPENDED.

Voici les différences entre la suspension et l'arrêt d'une instance :

• Les instances suspendues conservent la mémoire de l'OS invité, l'état de l'appareil et l'état de l'application.
• Google facture le stockage nécessaire pour économiser la mémoire de l'instance.
• Vous ne pouvez suspendre une instance que pendant 60 jours. Au-delà de cette période, l'instance passe automatiquement à l'état TERMINATED.

Toutes les ressources associées à l'instance le restent et sont facturées, y compris les disques persistants et les adresses IP externes statiques ou réservées. Toutes ces ressources sont facturées conformément à la grille tarifaire, même si une instance est suspendue.

Vous ne pouvez pas suspendre une instance à l'aide des processus standards intégrés à l'environnement invité. Les commandes, telles que la commande systemctl suspend dans Ubuntu 16.04 ou version ultérieure, ne sont pas disponibles. Vous ne pouvez utiliser que Google Cloud CLI ou REST pour suspendre une instance.

Si vous ne souhaitez pas restaurer l'état de la mémoire et de l'appareil lorsque vous réactivez l'instance, vous pouvez arrêter l'instance pour ne pas avoir à payer de frais de stockage supplémentaires.

Avant de commencer

• Si ce n'est pas déjà fait, configurez l'authentification. L'authentification est le processus permettant de valider votre identité pour accéder aux services et aux API Google Cloud. Pour exécuter du code ou des exemples depuis un environnement de développement local, vous pouvez vous authentifier auprès de Compute Engine en sélectionnant l'une des options suivantes:
  

  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

     Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
  2. Set a default region and zone.

  Go

  Pour utiliser les exemples Go de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

  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.

  Pour en savoir plus, consultez Set up authentication for a local development environment.

  Java

  Pour utiliser les exemples Java de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

  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.

  Pour en savoir plus, consultez Set up authentication for a local development environment.

  Node.js

  Pour utiliser les exemples Node.js de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

  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.

  Pour en savoir plus, consultez Set up authentication for a local development environment.

  PHP

  Pour utiliser les exemples PHP de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

  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.

  Pour en savoir plus, consultez Set up authentication for a local development environment.

  Python

  Pour utiliser les exemples Python de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

  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.

  Pour en savoir plus, consultez Set up authentication for a local development environment.

  REST

  Pour utiliser les exemples d'API REST de cette page dans un environnement de développement local, vous devez utiliser les identifiants que vous fournissez à gcloud CLI.

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

  gcloud init

  Pour en savoir plus, consultez la section S'authentifier pour utiliser REST dans la documentation sur l'authentification Google Cloud.

Limites

Les limites suivantes s'appliquent à cette fonctionnalité :

• Vous ne pouvez pas suspendre une instance qui utilise un GPU.
• Vous ne pouvez pas suspendre une instance Bare Metal.
• Vous ne pouvez pas suspendre une instance à l'aide des processus standards intégrés à l'environnement invité. Les commandes, telles que la commande systemctl suspend dans Ubuntu 16.04 ou version ultérieure, ne sont pas disponibles. Le signal en mode invité est ignoré.
• Vous ne pouvez suspendre une instance que pendant une durée maximale de 60 jours avant l'arrêt automatique de la VM.
• Vous ne pouvez pas suspendre des instances disposant de plus de 208 Go de mémoire.
• Vous pouvez suspendre des instances préemptives, mais celles-ci peuvent être arrêtées avant d'être correctement suspendues.
• Vous ne pouvez pas suspendre une Confidential VM.
• Vous ne pouvez pas suspendre une VM associée à des disques protégés par une CSEK.

Disques SSD locaux

Normalement, la suspension d'une instance de VM utilisant des SSD locaux supprime toutes les données stockées sur ces disques, comme quand on arrête l'instance.

Pour en savoir plus, consultez la documentation sur les SSD locaux.

VM préemptives

Vous pouvez suspendre une VM préemptive. Toutefois, si la préemption (et non l'avertissement préalable précédant la préemption) se produit avant la fin de l'opération de suspension, celle-ci est interrompue et l'instance est préemptée.

Compatibilité de l'OS

La plupart des systèmes d'exploitation proposés sur Compute Engine sont compatibles avec les fonctionnalités de suspension et de réactivation, mais certains ne le permettent pas. Consultez la page Informations sur les systèmes d'exploitation pour obtenir la liste complète.

Tarifs

Lorsque vous suspendez une instance, les éléments suivants vous sont facturés :

• Mémoire de l'instance (voir les tarifs des instances de VM suspendues)
• Toute utilisation de disque persistant pour le disque de démarrage et les disques supplémentaires associés à l'instance (consultez la section Tarifs des disques persistants)
• Toutes les adresses IP statiques associées à l'instance
• La suspension de VM peut vous permettre de réduire vos frais de licence logicielle. Par exemple, si vous suspendez des VM Windows, les frais de licence Windows ne vous sont pas facturés. Les frais de licence d'autres images peuvent présenter des conditions d'utilisation différentes et entraîner des frais même lorsqu'ils sont suspendus.

Suspendre une instance

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes :

• compute.instances.suspend sur l'instance

Pour suspendre une instance, utilisez la console Google Cloud, gcloud CLI, l'API ou les bibliothèques clientes Cloud.

Vous ne pouvez pas suspendre une instance à l'aide des processus standards intégrés à l'environnement invité. Vous pouvez utiliser la console Google Cloud, Google Cloud CLI ou l'API pour suspendre une instance.

L'opération de suspension peut échouer si elle est déclenchée trop tôt après le démarrage de l'instance. L'instance doit être entièrement démarrée (y compris les processus tels que l'agent invité) pour que l'opération de suspension aboutisse.

Console

1. Dans Google Cloud Console, accédez à la page Instances de VM.

   Accéder à la page "Instances de VM"

2. Sélectionnez une ou plusieurs instances à suspendre.

3. Cliquez sur Suspendre.

4. Lorsque vous y êtes invité, sélectionnez Supprimer le contenu des disques SSD locaux si vous souhaitez supprimer les données qu'ils contiennent. Lorsque votre instance est réactivée, toutes les données de disques SSD locaux qui lui sont associées ont été supprimées.

gcloud

Pour suspendre une instance dans Google Cloud CLI, procédez comme suit :

 gcloud compute instances suspend VM_NAME

Après que vous avez envoyé une requête pour suspendre une instance, Compute Engine peut prendre un certain temps pour conserver toutes les données nécessaires à l'instance. Pendant cette période, des frais vous seront facturés tant que l'instance reste en cours d'exécution.

Une instance suspendue est indiquée par l'état SUSPENDED. Pour vérifier l'état d'une instance, envoyez une requête describe :

gcloud compute instances describe VM_NAME

Pour suspendre une instance qui contient des données de SSD locaux, vous devez fournir l'option --discard-local-ssd:

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

L'utilisation de --discard-local-ssd ou --discard-local-ssd=True entraîne la suppression du contenu du SSD local. Compute Engine --discard-local-ssd=False est actuellement disponible en version Preview publique. Utilisez cette option pour enregistrer le contenu de jusqu'à 32 disques SSD locaux au maximum pendant la suspension. Pour en savoir plus, consultez la documentation sur les SSD locaux.

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
)

// suspendInstance suspends a running Google Compute Engine instance.
func suspendInstance(w io.Writer, projectID, zone, instanceName string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"

	ctx := context.Background()
	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer instancesClient.Close()

	req := &computepb.SuspendInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	op, err := instancesClient.Suspend(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to suspend instance: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Instance suspended\n")

	return nil
}

Java

import com.google.cloud.compute.v1.Instance.Status;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class SuspendInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // project: project ID or project number of the Cloud project your instance belongs to.
    // zone: name of the zone your instance belongs to.
    // instanceName: name of the instance your want to suspend.

    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    suspendInstance(project, zone, instanceName);
  }

  // Suspend a running Google Compute Engine instance.
  // For limitations and compatibility on which instances can be suspended,
  // see: https://cloud.google.com/compute/docs/instances/suspend-resume-instance#limitations
  public static void suspendInstance(String project, String zone, String instanceName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Instantiates a client.
    try (InstancesClient instancesClient = InstancesClient.create()) {

      Operation operation = instancesClient.suspendAsync(project, zone, instanceName)
          .get(300, TimeUnit.SECONDS);

      if (operation.hasError() || !instancesClient.get(project, zone, instanceName).getStatus()
          .equalsIgnoreCase(Status.SUSPENDED.toString())) {
        System.out.println("Cannot suspend instance. Try again!");
        return;
      }

      System.out.printf("Instance suspended successfully ! %s", instanceName);
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const instanceName = 'YOUR_INSTANCE_NAME';

const compute = require('@google-cloud/compute');

// Suspends a running Google Compute Engine instance.
async function suspendInstance() {
  const instancesClient = new compute.InstancesClient();

  const [response] = await instancesClient.suspend({
    project: projectId,
    zone,
    instance: instanceName,
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

  // Wait for the create operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await operationsClient.wait({
      operation: operation.name,
      project: projectId,
      zone: operation.zone.split('/').pop(),
    });
  }

  console.log('Instance suspended.');
}

suspendInstance();

PHP

use Google\Cloud\Compute\V1\Client\InstancesClient;
use Google\Cloud\Compute\V1\SuspendInstanceRequest;

/**
 * Suspend a running Google Compute Engine instance.
 *
 * @param string $projectId Project ID or project number of the Cloud project your instance belongs to.
 * @param string $zone Name of the zone your instance belongs to.
 * @param string $instanceName Name of the instance you want to suspend.
  *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function suspend_instance(
    string $projectId,
    string $zone,
    string $instanceName
) {
    // Suspend the running Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new SuspendInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->suspend($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Instance %s suspended successfully' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Failed to suspend instance: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python

from __future__ import annotations

import sys
from typing import Any

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


def suspend_instance(project_id: str, zone: str, instance_name: str) -> None:
    """
    Suspend a running Google Compute Engine instance.
    Args:
        project_id: project ID or project number of the Cloud project your instance belongs to.
        zone: name of the zone your instance belongs to.
        instance_name: name of the instance you want to suspend.
    """
    instance_client = compute_v1.InstancesClient()

    operation = instance_client.suspend(
        project=project_id, zone=zone, instance=instance_name
    )

    wait_for_extended_operation(operation, "suspend instance")

REST

Dans l'API, exécutez une requête à l'aide de la méthode instances.suspend :

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

Remplacez les éléments suivants :

• PROJECT_ID : ID du projet
• ZONE : zone de la VM
• VM_NAME : instance que vous souhaitez suspendre

Après que vous avez envoyé une requête pour suspendre une instance, Compute Engine peut prendre un certain temps pour conserver toutes les données nécessaires à l'instance. Pendant cette période, des frais vous seront facturés tant que l'instance reste en cours d'exécution.

Compute Engine indique que l'instance est suspendue avec l'état SUSPENDED. Pour vérifier l'état d'une instance, effectuez une requête GET :

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

L'état de l'instance est visible dans le champ "status" (état). Exemple :

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

Pour suspendre une instance avec plus de 32 disques SSD locaux, vous devez supprimer les données du SSD local en fournissant le paramètre de requête discardLocalSsd comme suit:

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

Pour en savoir plus, consultez la documentation sur les SSD locaux.

Réactiver une instance suspendue

Vous ne pouvez réactiver une instance que si la capacité est suffisante dans la zone où se trouve la VM. Dans la plupart des cas, cela ne pose pas de problème. Toutefois, si vous rencontrez des problèmes de capacité, renvoyez votre demande de réactivation ultérieurement.

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes :

• compute.instances.resume sur l'instance

Pour réactiver une instance suspendue, utilisez la console Google Cloud, gcloud CLI, l'API ou les bibliothèques clientes Cloud.

Console

1. Dans Google Cloud Console, accédez à la page Instances de VM.

   Accéder à la page "Instances de VM"

2. Sélectionnez une ou plusieurs instances à réactiver.

3. Cliquez sur Démarrer/Réactiver.

gcloud

Pour réactiver une instance dans Google Cloud CLI, procédez comme suit :

 gcloud compute instances resume VM_NAME

Après que vous avez envoyé une requête pour réactiver une instance, Compute Engine peut prendre un certain temps pour restaurer toutes les données nécessaires à l'instance. Pendant cette période, des frais vous seront facturés pendant la réactivation de l'instance.

Une instance réactivée porte l'indication RUNNING. Pour vérifier l'état d'une instance, envoyez une requête "describe" :

gcloud compute instances describe VM_NAME

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
)

// resumeInstance resumes a suspended Google Compute Engine instance
// (with unencrypted disks).
func resumeInstance(w io.Writer, projectID, zone, instanceName string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"

	ctx := context.Background()
	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer instancesClient.Close()

	getInstanceReq := &computepb.GetInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	instance, err := instancesClient.Get(ctx, getInstanceReq)
	if err != nil {
		return fmt.Errorf("unable to get instance: %w", err)
	}

	if instance.GetStatus() != "SUSPENDED" {
		return fmt.Errorf(
			"only suspended instances can be resumed, instance %s is in %s state",
			instanceName,
			instance.GetStatus(),
		)
	}

	resumeInstanceReq := &computepb.ResumeInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	op, err := instancesClient.Resume(ctx, resumeInstanceReq)
	if err != nil {
		return fmt.Errorf("unable to resume instance: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Instance resumed\n")

	return nil
}

Java

import com.google.cloud.compute.v1.Instance.Status;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ResumeInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // project: project ID or project number of the Cloud project your instance belongs to.
    // zone: name of the zone your instance belongs to.
    // instanceName: name of the instance your want to resume.

    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    resumeInstance(project, zone, instanceName);
  }

  // Resume a suspended Google Compute Engine instance (with unencrypted disks).
  // Instance state changes to RUNNING, if successfully resumed.
  public static void resumeInstance(String project, String zone, String instanceName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Instantiates a client.
    try (InstancesClient instancesClient = InstancesClient.create()) {

      String currentInstanceState = instancesClient.get(project, zone, instanceName).getStatus();

      // Check if the instance is currently suspended.
      if (!currentInstanceState.equalsIgnoreCase(Status.SUSPENDED.toString())) {
        throw new RuntimeException(
            String.format("Only suspended instances can be resumed. Instance %s is in %s state.",
                instanceName, currentInstanceState));
      }

      Operation operation = instancesClient.resumeAsync(project, zone, instanceName)
          .get(300, TimeUnit.SECONDS);

      if (operation.hasError() || !instancesClient.get(project, zone, instanceName).getStatus()
          .equalsIgnoreCase(
              Status.RUNNING.toString())) {
        System.out.println("Cannot resume instance. Try again!");
        return;
      }

      System.out.printf("Instance resumed successfully ! %s", instanceName);
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const instanceName = 'YOUR_INSTANCE_NAME';

const compute = require('@google-cloud/compute');

// Resumes a suspended Google Compute Engine instance (with unencrypted disks).
async function resumeInstance() {
  const instancesClient = new compute.InstancesClient();

  const [instance] = await instancesClient.get({
    project: projectId,
    zone,
    instance: instanceName,
  });

  if (instance.status !== 'SUSPENDED') {
    throw new Error(
      'Only suspended instances can be resumed.' +
        `Instance ${instanceName} is in ${instance.status} state.`
    );
  }

  const [response] = await instancesClient.resume({
    project: projectId,
    zone,
    instance: instanceName,
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

  // Wait for the create operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await operationsClient.wait({
      operation: operation.name,
      project: projectId,
      zone: operation.zone.split('/').pop(),
    });
  }

  console.log('Instance resumed.');
}

resumeInstance();

PHP

use Google\Cloud\Compute\V1\Client\InstancesClient;
use Google\Cloud\Compute\V1\ResumeInstanceRequest;

/**
 * Resume a suspended Google Compute Engine instance (with unencrypted disks).
 *
 * @param string $projectId Project ID or project number of the Cloud project your instance belongs to.
 * @param string $zone Name of the zone your instance belongs to.
 * @param string $instanceName Name of the instance you want to resume.
  *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function resume_instance(
    string $projectId,
    string $zone,
    string $instanceName
) {
    // Resume the suspended Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new ResumeInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->resume($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Instance %s resumed successfully' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Failed to resume instance: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python

from __future__ import annotations

import sys
from typing import Any

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


def resume_instance(project_id: str, zone: str, instance_name: str) -> None:
    """
    Resume a suspended Google Compute Engine instance (with unencrypted disks).
    Args:
        project_id: project ID or project number of the Cloud project your instance belongs to.
        zone: name of the zone your instance belongs to.
        instance_name: name of the instance you want to resume.
    """
    instance_client = compute_v1.InstancesClient()

    instance = instance_client.get(
        project=project_id, zone=zone, instance=instance_name
    )
    if instance.status != compute_v1.Instance.Status.SUSPENDED.name:
        raise RuntimeError(
            f"Only suspended instances can be resumed. "
            f"Instance {instance_name} is in {instance.status} state."
        )

    operation = instance_client.resume(
        project=project_id, zone=zone, instance=instance_name
    )

    wait_for_extended_operation(operation, "instance resumption")

REST

Envoyez une requête à la méthode instances.resume.

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

Remplacez les éléments suivants :

• PROJECT_ID : ID du projet pour cette requête
• ZONE : zone de la VM
• VM_NAME : instance à réactiver

Après que vous avez envoyé une requête pour réactiver une instance, Compute Engine peut prendre un certain temps pour restaurer toutes les données nécessaires à l'instance. Pendant cette période, des frais vous seront facturés pendant la réactivation de l'instance.

Compute Engine indique l'état RUNNING dès que la réactivation de l'instance est terminée. Pour vérifier l'état d'une instance, envoyez une requête GET :

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

L'état de l'instance est visible dans le champ "status" (état). Exemple :

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

Procédure de suspension

Lorsque vous effectuez une requête de suspension, vous envoyez un signal ACPI de suspension à l'instance de VM. Si la VM ne répond pas au signal ACPI S3 de suspension au bout de quelques minutes, Compute Engine annule la tentative de suspension et renvoie la VM à l'état RUNNING.

Le tableau suivant décrit l'effet de la suspension d'une instance de VM sur les ressources associées :

Ressource	Assistance
Memory	Seules les VM dont la mémoire est inférieure ou égale à 208 Go peuvent être suspendues.
SSD local	Les données des disques SSD locaux sont supprimées.
Disque persistant	Les disques HDD et SSD persistants sont conservés.
Adresses IP	Les adresses IP éphémères sont libérées pendant la suspension, mais les adresses IP statiques restent associées aux instances de VM. Si vous souhaitez conserver votre ID éphémère, convertissez-le.
Configuration de la VM (type de machine, métadonnées, libellés, etc.)	Toutes les configurations de la VM autres que les adresses IP éphémères sont conservées et restaurées lorsque l'instance est réactivée.

Configurer une VM Debian pour la suspension et la réactivation

Les VM exécutant Debian 8 et 9 sont compatibles avec la suspension et la réactivation, mais elles doivent être configurées au préalable. Pour configurer votre instance Debian, suivez l'un des ensembles d'instructions suivants (option A ou option B). Si possible, nous vous recommandons de configurer l'ACPID (option A).

Option A

Cette option configure l'ACPID afin qu'il gère l'événement du bouton de mise en veille et ajoute un script shell pour gérer cet événement.

1. Connectez-vous à votre instance de VM à l'aide de SSH :

   gcloud compute ssh VM_NAME
   

2. Sur l'instance de VM, créez un répertoire sous le dossier acpi :

   sudo mkdir -p /etc/acpi/events/
   

3. Configurez l'ACPID pour qu'il gère l'événement du bouton de mise en veille :

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

4. Créez le script de gestion des événements de mise en veille :

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

5. Configurez les autorisations pour le script :

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

6. Redémarrez l'ACPID :

   sudo systemctl restart acpid.service
   

Option B

1. Connectez-vous à votre instance de VM à l'aide de SSH :

   gcloud compute ssh VM_NAME
   

2. Installez dbus sur l'instance de VM :

   sudo apt-get install dbus
   

3. Redémarrez logind :

   sudo systemctl restart systemd-logind.service
   

Étapes suivantes

• Supprimez une instance si vous n'en avez plus besoin.
• Arrêtez ou redémarrez une instance.
• Examinez le cycle de vie d'une instance.
• Consultez la page Résoudre les problèmes liés à la suspension des VM si vous rencontrez des problèmes lors de la suspension d'une VM.