Suspendre ou réactiver une instance Compute Engine

Linux Windows

---

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 d'instances, consultez Suspendre, arrêter ou réinitialiser des instances Compute Engine.

Si vous souhaitez conserver votre instance Compute Engine, mais que vous ne souhaitez pas qu'elle vous soit facturée lorsqu'elle n'est pas utilisée, vous pouvez la suspendre. La suspension d'une instance la conserve et migre 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 recommence à s'exécuter.

Suspendre 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 est le processus permettant de valider votre identité pour accéder aux Google Cloud services et aux API. 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.

Rôles requis

Pour obtenir les autorisations nécessaires pour suspendre ou reprendre une instance Compute, 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 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 reprendre 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 passe automatiquement à l'é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 des instances auxquelles des GPU sont associés.

• Vous ne pouvez pas suspendre des instances Bare Metal.

• Vous ne pouvez pas suspendre de Confidential VMs.

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

• Vous ne pouvez pas suspendre des instances disposant de plus de 208 Go de mémoire.

• 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 reprise avant de suspendre l'instance en procédant comme suit:

• Recommandation: Configurer l'ACPID

• Installer D-Bus

Configurer l'ACPID

Pour activer l'opération de suspension et de reprise dans Debian 8 ou 9, vous pouvez configurer le daemon d'événements ACPI (Advanced Configuration and Power Interface) (ACPID) 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 profonde, 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 pour qu'il prenne en charge les opérations de suspension et de reprise, 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 prennent effet, redémarrez l'ACPID:

   sudo systemctl restart acpid.service
   

Installer D-Bus

Pour activer la suspension et la reprise 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 prennent effet, 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 à l'instance:

• Si aucun disque SSD local n'est associé à votre instance, consultez la section Suspendre une instance sans disque SSD local.

• Si des disques SSD locaux sont associés à votre instance et que vous souhaitez supprimer ou conserver (Aperçu) les données de ces disques, consultez Suspendre une instance avec des disques SSD locaux.

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, la Google Cloud CLI. Pour des 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 seule zone, exécutez 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 si vous devez 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.

  Attention :Compute Engine utilise un stockage persistant pour stocker vos données SSD locales. Avant de suspendre une instance, assurez-vous de disposer d'un quota suffisant pour l'espace de stockage utilisé. Sinon, la suspension de l'instance échoue. Pour en savoir plus, consultez la section Arrêter ou suspendre une VM avec des disques SSD locaux.

• 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 seule zone associées à des disques SSD locaux, indiquez si vous souhaitez supprimer ou conserver les données des disques SSD locaux comme suit:

• Pour supprimer les données de 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 du SSD local, utilisez la commande gcloud beta compute instances suspend avec l'option --discard-local-ssd=false:

  Preview — The --discard-local-ssd=false flag

  This feature is subject to the "Pre-GA Offerings Terms" in the General Service Terms section of the Service Specific Terms. Pre-GA features are available "as is" and might have limited support. For more information, see the launch stage descriptions.

  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 de SSD locaux comme suit:

• Pour supprimer les données de 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 du SSD local, 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:

  Preview — The discardLocalSsd=false query parameter

  This feature is subject to the "Pre-GA Offerings Terms" in the General Service Terms section of the Service Specific Terms. Pre-GA features are available "as is" and might have limited support. For more information, see the launch stage descriptions.

  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. Ce n'est généralement pas un problème. Si vous ne parvenez pas à 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 lors de la suspension, vous devrez peut-être les réinstaller après la reprise. Pour en savoir plus, découvrez comment réinstaller des disques non de démarrage sur des instances Linux ou des instances Windows.

Vous pouvez reprendre 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 CLI gcloud. Pour des 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 seule 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 de suspension à reprendre.

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

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

Étape suivante

• Supprimer une instance Compute Engine

• Arrêter ou redémarrer une instance Compute Engine

• Résoudre les problèmes liés à la suspension de VM