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 l'espace de stockage. Une fois l'instance réactivée, Compute Engine migre sa mémoire de l'espace de stockage vers l'instance, et l'instance se remet à s'exécuter.

La suspension d'une instance Compute Engine est utile dans 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, et que vous souhaitez conserver pour réduire les coûts ou accélérer l'initialisation plutôt que de créer 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.

Avant de commencer

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

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

    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 la gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

      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.

      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.

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

    Pour en savoir plus, consultez la section 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 la gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

      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.

      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.

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

    Pour en savoir plus, consultez la section 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 la gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

      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.

      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.

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

    Pour en savoir plus, consultez la section 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 la gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

      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.

      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.

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

    Pour en savoir plus, consultez la section 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 la gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

      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.

      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.

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

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

    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 réactiver 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 la page 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 réactiver 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.

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 Debian 8 ou 9 comme OS invité que si vous configurez l'OS avant de suspendre l'instance.

  • Vous ne pouvez suspendre une instance que pendant une durée maximale de 60 jours 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 les instances.

  • Vous ne pouvez pas suspendre les instances auxquelles des GPU sont associés.

  • Vous ne pouvez pas suspendre les instances Bare Metal.

  • Vous ne pouvez pas suspendre les Confidential VM.

  • Vous ne pouvez pas suspendre d'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 compatibles. Si elle est appelée, Compute Engine ignore le signal en mode invité.

  • Vous ne pouvez pas suspendre des instances auxquelles des disques protégés par CSEK sont associés.

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

Si une instance de calcul exécute Debian 8 et 9 comme OS invité, vous devez activer les opérations de suspension et de réactivation avant de suspendre l'instance. Pour ce faire, procédez de l'une des manières 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 qu'il gère l'événement du bouton de mise en veille. Après avoir activé l'événement du bouton de mise en 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 l'ACPID afin qu'il prenne 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 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. Pour que les modifications soient appliquées, redémarrez ACPID :

    sudo systemctl restart acpid.service

Installer D-Bus

Pour activer la suspension et la 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, procédez comme suit :

  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

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 disque SSD local

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'exception des instances Z3), suspendez l'instance à l'aide de gcloud CLI ou de l'API REST.

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

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 et que des disques SSD locaux y sont associés, indiquez si vous souhaitez supprimer ou conserver les données des disques SSD locaux :

  • Pour supprimer les données de disque SSD local, exécutez 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, indiquez si vous souhaitez supprimer ou conserver les données des disques SSD locaux :

  • Pour supprimer les données d'un disque SSD local, 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ù elle se trouve. Cela ne pose généralement pas de problème. Si vous rencontrez des problèmes pour réactiver 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, consultez la section sur le remontage des disques non bootables sur les instances Linux ou les instances Windows.

Vous pouvez réactiver plusieurs instances 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, 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