Suspendre ou réactiver une instance Compute Engine

Ce document explique comment suspendre ou réactiver des instances Compute Engine. Pour en savoir plus sur la suspension, l'arrêt ou la réinitialisation des instances, consultez Suspendre, arrêter ou réinitialiser des instances Compute Engine.

Si vous souhaitez conserver votre instance Compute Engine, mais que vous ne voulez pas qu'elle vous soit facturée lorsqu'elle n'est pas utilisée, vous pouvez la suspendre. La suspension d'une instance permet de la conserver et de migrer le contenu de sa mémoire vers le stockage. Une fois l'instance réactivée, Compute Engine migre la mémoire de l'instance de l'espace de stockage vers l'instance, et l'instance recommence à s'exécuter.

La suspension d'une instance Compute Engine est utile dans les cas suivants :

  • Environnements de développement et de test qui ne sont pas entièrement utilisés pendant les périodes creuses, comme le soir ou le week-end, et que vous souhaitez conserver pour économiser des coûts ou pour une initialisation plus rapide que la création de nouvelles instances.

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

Limites

Lorsque vous suspendez une instance de calcul, les limites suivantes s'appliquent :

  • Vous ne pouvez suspendre une instance que si l'OS invité le permet. Pour en savoir plus, consultez la page Détails des systèmes d'exploitation.

  • Vous ne pouvez suspendre une instance qui utilise les images d'OS suivantes que si vous configurez son OS, comme décrit dans ce document :

    • Debian 8 ou 9

    • N'importe quel OS Windows

  • Vous ne pouvez suspendre une instance que pendant 60 jours maximum avant que Compute Engine ne fasse automatiquement passer son état à TERMINATED.

  • Vous pouvez suspendre des VM Spot ou des instances préemptives. Toutefois, si Compute Engine préempte l'instance avant la fin de l'opération de suspension, il met fin à l'opération de suspension et préempte l'instance.

  • Vous ne pouvez pas suspendre des instances à l'aide des processus standards intégrés à leur environnement invité. Les commandes telles que systemctl suspend dans Ubuntu 16.04 ou version ultérieure ne sont pas acceptées. Si elle est appelée, Compute Engine ignore le signal en mode invité.

  • Vous ne pouvez pas suspendre les types d'instances suivants :

    • Instances Bare Metal

    • Confidential VMs.

    • Instances auxquelles des GPU ou des TPU sont associés.

    • Instances disposant de plus de 208 Go de mémoire.

    • Instances auxquelles des disques protégés par CSEK (obsolètes) sont associés.

Avant de commencer

  • Vérifiez que votre projet dispose d'un quota Persistent disk standard (GB) suffisant dans la région où se trouve l'instance. Lorsque vous suspendez une instance, Compute Engine stocke la mémoire de l'instance dans un espace de stockage persistant, ce qui consomme le quota Persistent disk standard (GB). Cette exigence s'applique à toutes les instances, y compris celles qui n'ont que des volumes Google Cloud Hyperdisk associés. Pour en savoir plus, consultez Quotas de disque et Résoudre les problèmes liés à un quota de disque insuffisant.
  • Si ce n'est pas déjà fait, configurez l'authentification. L'authentification permet 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 :

    Sélectionnez l'onglet correspondant à la façon dont vous prévoyez d'utiliser les exemples de cette page :

    Console

    Lorsque vous utilisez la console Google Cloud pour accéder aux services et aux API Google Cloud , vous n'avez pas besoin de configurer l'authentification.

    gcloud

    1. Installez la Google Cloud CLI. Une fois que la Google Cloud CLI est installée, initialisez-la en exécutant la commande suivante : 

      gcloud init

      Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

  • Définissez une région et une zone par défaut.

    • Go

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

    1. Installez la Google Cloud CLI.

    2. Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

    3. Si vous utilisez un shell local, créez des identifiants d'authentification locaux pour votre compte utilisateur : 

      gcloud auth application-default login

      Vous n'avez pas besoin de le faire si vous utilisez Cloud Shell.

      Si une erreur d'authentification est renvoyée et que vous utilisez un fournisseur d'identité (IdP) externe, vérifiez que vous vous êtes connecté à la gcloud CLI avec votre identité fédérée.

    Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

    Java

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

    1. Installez la Google Cloud CLI.

    2. Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

    3. Si vous utilisez un shell local, créez des identifiants d'authentification locaux pour votre compte utilisateur : 

      gcloud auth application-default login

      Vous n'avez pas besoin de le faire si vous utilisez Cloud Shell.

      Si une erreur d'authentification est renvoyée et que vous utilisez un fournisseur d'identité (IdP) externe, vérifiez que vous vous êtes connecté à la gcloud CLI avec votre identité fédérée.

    Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

    Node.js

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

    1. Installez la Google Cloud CLI.

    2. Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

    3. Si vous utilisez un shell local, créez des identifiants d'authentification locaux pour votre compte utilisateur : 

      gcloud auth application-default login

      Vous n'avez pas besoin de le faire si vous utilisez Cloud Shell.

      Si une erreur d'authentification est renvoyée et que vous utilisez un fournisseur d'identité (IdP) externe, vérifiez que vous vous êtes connecté à la gcloud CLI avec votre identité fédérée.

    Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

    PHP

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

    1. Installez la Google Cloud CLI.

    2. Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

    3. Si vous utilisez un shell local, créez des identifiants d'authentification locaux pour votre compte utilisateur : 

      gcloud auth application-default login

      Vous n'avez pas besoin de le faire si vous utilisez Cloud Shell.

      Si une erreur d'authentification est renvoyée et que vous utilisez un fournisseur d'identité (IdP) externe, vérifiez que vous vous êtes connecté à la gcloud CLI avec votre identité fédérée.

    Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

    Python

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

    1. Installez la Google Cloud CLI.

    2. Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

    3. Si vous utilisez un shell local, créez des identifiants d'authentification locaux pour votre compte utilisateur : 

      gcloud auth application-default login

      Vous n'avez pas besoin de le faire si vous utilisez Cloud Shell.

      Si une erreur d'authentification est renvoyée et que vous utilisez un fournisseur d'identité (IdP) externe, vérifiez que vous vous êtes connecté à la gcloud CLI avec votre identité fédérée.

    Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

    REST

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

      Installez la Google Cloud CLI.

      Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

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

Rôles requis

Pour obtenir les autorisations nécessaires pour suspendre ou reprendre une instance de calcul, demandez à votre administrateur de vous accorder le rôle IAM Administrateur d'instances Compute (v1) (roles/compute.instanceAdmin.v1) sur l'instance. Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Ce rôle prédéfini contient les autorisations requises pour suspendre ou reprendre une instance de calcul. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour suspendre ou réactiver une instance de calcul :

  • Pour suspendre une instance : compute.instances.suspend
  • Pour réactiver une instance : compute.instances.resume

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis.

Activer les opérations de suspension sur un OS invité

Si votre instance de calcul utilise Debian 8 ou 9 comme OS invité, ou un OS Windows, vous devez configurer l'OS avant de pouvoir suspendre et reprendre des instances. Si votre instance utilise un autre OS invité, ignorez cette section.

Activer les opérations de suspension sur Debian 8 ou 9

Avant de pouvoir suspendre ou reprendre des instances de calcul qui utilisent Debian 8 ou 9 comme OS invité, vous devez configurer l'OS invité à l'aide de l'une des méthodes suivantes :

Configurer l'ACPID

Pour activer l'opération de suspension et de reprise dans Debian 8 ou 9, vous pouvez configurer le démon ACPID (Advanced Configuration and Power Interface events Daemon) pour gérer l'événement du bouton de veille. Après avoir activé l'événement du bouton de veille prolongée, vous pouvez ajouter un script shell pour gérer l'événement de mise en veille, comme décrit dans cette section.

Pour configurer ACPID afin de prendre en charge les opérations de suspension et de réactivation, procédez comme suit :

  1. Si ce n'est pas déjà fait, connectez-vous à votre instance Linux.

  2. Créez le dossier events dans le dossier acpi :

    sudo mkdir -p /etc/acpi/events/

  3. Configurez l'ACPID pour gérer 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. Pour que les modifications soient appliquées, redémarrez ACPID :

    sudo systemctl restart acpid.service

Installer D-Bus

Pour activer l'opération de suspension et de réactivation dans Debian 8 ou 9, vous pouvez installer D-Bus.

Pour installer D-Bus dans l'OS invité de votre instance de calcul lorsque l'OS utilise Debian 8 ou 9 :

  1. Si ce n'est pas déjà fait, connectez-vous à votre instance Linux.

  2. Installez D-Bus :

    sudo apt-get install dbus

  3. Pour que les modifications soient appliquées, redémarrez logind :

    sudo systemctl restart systemd-logind.service

Activer les opérations de suspension sur Windows

Pour suspendre une instance qui utilise un OS invité Windows, vous devez désactiver la mise en veille prolongée dans l'OS. Si vous avez importé une image Windows, la mise en veille prolongée peut être activée par défaut. Vous devez la désactiver pour suspendre l'instance.

Pour désactiver la mise en veille prolongée sous Windows, procédez comme suit :

  1. Si ce n'est pas déjà fait, connectez-vous à votre instance Windows.

  2. Ouvrez PowerShell en tant qu'administrateur.

  3. Désactiver l'hibernation :

    powercfg -h off

  4. Vérifiez que l'hibernation est désactivée :

    powercfg -a

Suspendre une instance

Si l'OS invité de votre instance de calcul utilise Debian 8 ou 9, vous devez configurer l'OS invité pour qu'il prenne en charge les opérations de suspension et de reprise, comme décrit dans ce document, avant de suspendre l'instance.

Pour suspendre une instance, utilisez l'une des méthodes suivantes selon que des disques SSD locaux sont associés ou non à l'instance :

Suspendre une instance sans disques SSD locaux

Vous pouvez suspendre plusieurs instances de calcul simultanément ou des instances individuelles. Pour plusieurs instances, utilisez la console Google Cloud ou, pour les instances situées dans la même zone, Google Cloud CLI. Pour les instances individuelles, sélectionnez l'une des options suivantes :

Console

  1. Dans la console Google Cloud , 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, puis sur Suspendre pour confirmer.

gcloud

Pour suspendre une ou plusieurs instances dans une même zone, utilisez la commande gcloud compute instances suspend :

gcloud compute instances suspend INSTANCE_NAMES \
    --zone=ZONE

Remplacez les éléments suivants :

  • INSTANCE_NAMES : liste de noms d'instances séparés par des espaces (par exemple, instance-01 instance-02 instance-03).

  • ZONE : zone où se trouvent les instances.

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

Pour suspendre une instance, envoyez une requête POST à la méthode instances.suspend :

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/suspend

Remplacez les éléments suivants :

  • PROJECT_ID : ID du projet dans lequel se trouve l'instance

  • ZONE : zone où se trouve l'instance

  • INSTANCE_NAME : nom de l'instance.

Suspendre une instance avec des disques SSD locaux

En fonction du nombre d'instances de calcul que vous souhaitez suspendre simultanément et de la nécessité de conserver les données de leurs disques SSD locaux associés, procédez comme suit :

  • Pour conserver les données des disques SSD locaux associés à une instance (à l'exclusion des instances avec des disques SSD Titanium), suspendez l'instance à l'aide de la gcloud CLI ou de l'API REST.

  • Pour suspendre plusieurs instances simultanément, utilisez la console Google Cloud , ou la gcloud CLI pour les instances situées dans la même zone.

Pour suspendre une ou plusieurs instances auxquelles sont associés des disques SSD locaux, sélectionnez l'une des options suivantes :

Console

  1. Dans la console Google Cloud , 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, puis sur Suspendre pour confirmer.

gcloud

Lorsque vous suspendez une ou plusieurs instances dans une même zone auxquelles des disques SSD locaux sont associés, spécifiez si vous souhaitez supprimer ou conserver les données des disques SSD locaux comme suit :

  • Pour supprimer les données de SSD locaux, utilisez la commande gcloud compute instances suspend avec l'option --discard-local-ssd=true :

    gcloud compute instances suspend INSTANCE_NAMES \
    --discard-local-ssd=true \
    --zone=ZONE

  • Pour conserver les données des SSD locaux, utilisez la commande gcloud beta compute instances suspend avec l'option --discard-local-ssd=false :

    gcloud beta compute instances suspend INSTANCE_NAMES \
    --discard-local-ssd=false \
    --zone=ZONE

Remplacez les éléments suivants :

  • INSTANCE_NAMES : liste de noms d'instances séparés par des espaces (par exemple, instance-01 instance-02 instance-03).

  • ZONE : zone où se trouvent les instances.

REST

Lorsque vous suspendez une instance à laquelle des disques SSD locaux sont associés, spécifiez si vous souhaitez supprimer ou conserver les données des disques SSD locaux comme suit :

  • Pour supprimer les données des disques SSD locaux, envoyez une requête POST à la méthode instances.suspend. Dans l'URL de la requête, incluez le paramètre de requête discardLocalSsd défini sur true :

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

  • Pour conserver les données des disques SSD locaux, envoyez une requête POST à la méthode beta.instances.suspend. Dans l'URL de la requête, incluez le paramètre de requête discardLocalSsd défini sur false :

    POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/suspend?discardLocalSsd=false

Remplacez les éléments suivants :

  • PROJECT_ID : ID du projet dans lequel se trouve l'instance

  • ZONE : zone où se trouve l'instance

  • INSTANCE_NAME : nom de l'instance.

Réactiver une instance suspendue

Avant de réactiver une instance de calcul suspendue, tenez compte des points suivants :

  • Vous ne pouvez réactiver une instance que si la capacité est suffisante dans la zone où se trouve l'instance. En général, cela ne pose pas de problème. Si vous rencontrez des difficultés pour reprendre une instance, réessayez plus tard.

  • Si vous avez associé des disques SSD locaux à l'instance et que vous avez choisi de conserver les données des disques SSD locaux lorsque vous l'avez suspendue, vous devrez peut-être remonter les disques SSD locaux après l'avoir réactivée. Pour en savoir plus, découvrez comment réinstaller des disques non amorçables sur des instances Linux ou des instances Windows.

Vous pouvez réactiver plusieurs instances simultanément ou réactiver des instances individuelles. Pour plusieurs instances, utilisez la console Google Cloud ou, pour les instances situées dans la même zone, la gcloud CLI. Pour les instances individuelles, sélectionnez l'une des options suivantes :

Console

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

    Accéder à la page Instances de VM

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

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

gcloud

Pour réactiver une ou plusieurs instances suspendues dans une même zone, utilisez la commande gcloud compute instances resume :

gcloud compute instances resume INSTANCE_NAMES \
    --zone=ZONE

Remplacez les éléments suivants :

  • INSTANCE_NAMES : liste de noms d'instances séparés par des espaces (par exemple, instance-01 instance-02 instance-03).

  • ZONE : zone où se trouvent les instances suspendues.

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

Pour réactiver une instance suspendue, envoyez une requête POST à la méthode instances.resume :

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/resume

Remplacez les éléments suivants :

  • INSTANCE_NAME : nom de l'instance suspendue à réactiver.

  • PROJECT_ID : ID du projet dans lequel se trouve l'instance suspendue.

  • ZONE : zone où se trouve l'instance suspendue.

Étapes suivantes