Arrêter ou redémarrer une instance Compute Engine

Ce document explique comment arrêter ou redémarrer une instance Compute Engine. Pour en savoir plus sur la suspension, l'arrêt ou la réinitialisation d'une instance, consultez la section Suspendre, arrêter ou réinitialiser des instances Compute Engine.

Arrêter une instance est utile lorsque vous ne l'utilisez plus ou pour modifier ses propriétés (par exemple, pour modifier son type de machine ou supprimer les disques associés et montés). Une fois l'instance arrêtée, vous pouvez effectuer les opérations suivantes:

  • Redémarrez-le pour reprendre votre charge de travail.

  • Supprimez-le si vous n'en avez plus besoin.

Pour automatiser l'arrêt ou le redémarrage d'une instance, consultez plutôt les articles suivants:

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
    2. Set a default region and zone.

      3. 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 arrêter ou redémarrer une instance Compute, demandez à votre administrateur de vous accorder le rôle IAM Administrateur d'instances Compute (v1) (roles/compute.instanceAdmin.v1) sur le projet. 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 arrêter ou redémarrer une instance de calcul. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Vous devez disposer des autorisations suivantes pour arrêter ou redémarrer une instance Compute Engine:

  • Pour arrêter une instance : compute.instances.stop sur l'instance
  • Pour arrêter une instance à partir de l'OS invité : compute.instances.setMetadata sur l'instance si elle utilise des clés SSH publiques au niveau de l'instance.
  • Pour redémarrer une instance : compute.instances.start sur l'instance
  • Pour redémarrer une instance qui utilise des clés de chiffrement : compute.instances.startWithEncryptionKey sur l'instance

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

Arrêter une instance

Lorsque vous arrêtez une instance de calcul ou que Compute Engine le fait pour une action planifiée, l'instance conserve ses ressources associées, ses paramètres de configuration, ses adresses IP internes, ses adresses MAC et ses métadonnées. Toutefois, l'instance perd ses données en mémoire et son état d'application. Si vous devez conserver ces états, suspendez plutôt l'instance.

Vous pouvez arrêter une instance à l'aide des méthodes suivantes, selon que des disques SSD locaux sont associés à l'instance et comment vous souhaitez gérer les scripts de fermeture:

  • Arrêter une instance sans disques SSD locaux

    Vous pouvez arrêter simultanément une ou plusieurs instances auxquelles aucun disque SSD local n'est associé. L'exécution de tous les scripts d'arrêt d'une instance doit se terminer pendant la période d'arrêt par défaut.

  • Arrêter une instance avec des disques SSD locaux

    Lorsque vous arrêtez simultanément une ou plusieurs instances associées à des disques SSD locaux, vous pouvez choisir de supprimer ou de conserver (Aperçu) les données de ces disques. Tous les scripts d'arrêt de l'instance doivent s'exécuter pendant la période d'arrêt par défaut.

  • Arrêter une instance à partir de l'OS invité

    Cette approche vous permet d'arrêter une seule instance uniquement une fois l'exécution de vos scripts d'arrêt terminée. Si vous avez activé l'arrêt correct, vous pouvez également arrêter l'instance sans l'arrêter correctement ou mettre fin à un arrêt correct en cours. Sauf si vous sauvegardez manuellement les données de tous les disques SSD locaux associés sur un volume de stockage durable, l'arrêt d'une instance à partir de son OS hôte supprime toutes les données de ces disques.

Arrêter une instance sans disques SSD locaux

Selon ce que vous souhaitez faire lorsque vous arrêtez une instance, utilisez les options suivantes:

  • Si vous avez activé l'arrêt correct dans l'instance, vous pouvez arrêter l'instance sans l'arrêter correctement ou mettre fin à un arrêt correct en cours à l'aide de la console Google Cloud, de la CLI gcloud ou de l'API REST.

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

Pour arrêter une ou plusieurs instances, 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 les instances en cours d'exécution à arrêter.

  3. Cliquez sur Arrêter.

  4. Dans la boîte de dialogue, procédez comme suit:

    1. Facultatif: Pour arrêter les instances sans les arrêter correctement ou pour mettre fin à un arrêt correct en cours, cochez la case Ignorer l'arrêt correct (le cas échéant).

    2. Pour confirmer, cliquez sur Arrêter.

gcloud

Pour arrêter une ou plusieurs instances dans la même zone, utilisez la commande gcloud compute instances stop:

gcloud compute instances stop 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

Si vous avez activé l'arrêt progressif dans une ou plusieurs instances, vous pouvez les arrêter sans les arrêter correctement ou mettre fin manuellement à un arrêt progressif en cours. Pour ce faire, exécutez la commande gcloud beta compute instances stop avec l'option --no-graceful-shutdown:

gcloud beta compute instances stop INSTANCE_NAMES \
    --no-graceful-shutdown \
    --zone=ZONE

Go

import (
	"context"
	"fmt"
	"io"

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

// stopInstance stops a started Google Compute Engine instance
func stopInstance(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.StopInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	op, err := instancesClient.Stop(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to stop 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 stopped\n")

	return nil
}

Java 


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.StopInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class StopInstance {

  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 stop.
     */
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    stopInstance(project, zone, instanceName);
  }

  // Stops a started Google Compute Engine instance.
  public static void stopInstance(String project, String zone, String instanceName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    /* Initialize client that will be used to send requests. This client only needs to be created
       once, and can be reused for multiple requests. After completing all of your requests, call
       the `instancesClient.close()` method on the client to safely
       clean up any remaining background resources. */
    try (InstancesClient instancesClient = InstancesClient.create()) {

      StopInstanceRequest stopInstanceRequest = StopInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstance(instanceName)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.stopAsync(
          stopInstanceRequest);
      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.getStatus() == Status.DONE) {
        System.out.println("Instance stopped successfully ! ");
      }
    }
  }
}

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');

async function stopInstance() {
  const instancesClient = new compute.InstancesClient();

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

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

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

stopInstance();

PHP 

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

/**
 * Stops 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 stop.
  *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function stop_instance(
    string $projectId,
    string $zone,
    string $instanceName
) {
    // Stop the Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new StopInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->stop($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Instance %s stopped successfully' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Failed to stop 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 stop_instance(project_id: str, zone: str, instance_name: str) -> None:
    """
    Stops 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 your want to stop.
    """
    instance_client = compute_v1.InstancesClient()

    operation = instance_client.stop(
        project=project_id, zone=zone, instance=instance_name
    )
    wait_for_extended_operation(operation, "instance stopping")

REST

Pour arrêter une instance, envoyez une requête POST à la méthode instances.stop:

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

Remplacez les éléments suivants :

  • INSTANCE_NAME : nom de l'instance.

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

  • ZONE : zone où se trouve l'instance

Si vous avez activé l'arrêt correct dans une instance, vous pouvez arrêter l'instance sans l'arrêter correctement ou mettre fin manuellement à un arrêt correct en cours. Pour ce faire, envoyez une requête POST à la méthode instances.stop. Dans l'URL de la requête, incluez le paramètre de requête noGracefulShutdown=true:

 POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/stop?noGracefulShutdown=true
 ```

Arrêter une instance avec des disques SSD locaux

Selon ce que vous souhaitez faire lorsque vous arrêtez une instance de calcul, utilisez les options suivantes:

  • Si vous avez activé l'arrêt correct dans l'instance, vous pouvez arrêter l'instance sans l'arrêter correctement ou mettre fin à un arrêt correct en cours à l'aide de la console Google Cloud, de la gcloud CLI ou de l'API REST.

  • Pour conserver les données des disques SSD locaux associés à une instance (à l'exception des instances Z3), arrêtez l'instance à l'aide de la gcloud CLI ou de l'API REST.

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

Pour arrêter une ou plusieurs instances auxquelles des disques SSD locaux sont associés, 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 les instances en cours d'exécution à arrêter.

  3. Cliquez sur Arrêter.

  4. Dans la boîte de dialogue, procédez comme suit:

    1. Facultatif: Pour arrêter les instances sans les arrêter correctement ou pour mettre fin à un arrêt correct en cours, cochez la case Ignorer l'arrêt correct (le cas échéant).

    2. Pour confirmer, cliquez sur Arrêter.

gcloud

Lorsque vous arrêtez une ou plusieurs instances de la même 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 stop avec l'option --discard-local-ssd=true:

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

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

    gcloud beta compute instances stop 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

Si vous avez activé l'arrêt progressif dans une ou plusieurs instances, vous pouvez les arrêter sans les arrêter correctement ou mettre fin à un arrêt progressif en cours. Pour ce faire, exécutez la commande gcloud beta compute instances stop avec l'option --no-graceful-shutdown:

gcloud beta compute instances stop INSTANCE_NAMES \
    --discard-local-ssd=DISCARD_LOCAL_SSD \
    --no-graceful-shutdown \
    --zone=ZONE

Remplacez DISCARD_LOCAL_SSD par true pour supprimer les données des disques SSD locaux ou par false pour les conserver.

REST

Lorsque vous arrêtez une instance à laquelle des disques SSD locaux sont associés, indiquez si vous souhaitez supprimer ou conserver les données des disques SSD locaux comme suit:

  • Pour supprimer les données de SSD locaux, envoyez une requête POST à la méthode instances.stop. 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/stop?discardLocalSsd=true

  • Pour conserver les données du SSD local, envoyez une requête POST à la méthode beta.instances.stop. 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/stop?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.

Si vous avez activé l'arrêt progressif dans une instance, vous pouvez l'arrêter sans l'arrêter correctement ou mettre fin manuellement à un arrêt progressif en cours. Pour ce faire, envoyez une requête POST à la méthode instances.stop. Dans l'URL de la requête, incluez le paramètre de requête noGracefulShutdown=true:

 POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/stop?discardLocalSsd=DISCARD_LOCAL_SSD&noGracefulShutdown=true
 ```

Replace `DISCARD_LOCAL_SSD` with `true` to discard the data
in the Local SSD disks, or `false` to preserve the data.

Arrêter une instance à partir de l'OS invité

Si des disques SSD locaux sont associés à une instance de calcul, l'arrêt du système d'exploitation invité supprime automatiquement les données du disque SSD local. Pour conserver ces données, copiez-les manuellement vers une option de stockage persistant avant d'arrêter l'instance.

Pour arrêter une instance à partir du système d'exploitation invité, sélectionnez l'une des options suivantes:

Linux

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

  2. Pour arrêter l'instance, sélectionnez l'une des méthodes suivantes:

    • Pour un arrêt normal permettant à l'instance d'exécuter des scripts d'arrêt avant d'arrêter l'OS invité, exécutez la commande suivante:

      sudo shutdown -h now

    • Sinon, pour forcer l'arrêt, exécutez la commande suivante :

      sudo poweroff

Windows

  1. Si vous ne l'avez pas déjà fait, connectez-vous à l'instance à l'aide de l'une des méthodes suivantes:

  2. Pour arrêter l'instance, sélectionnez l'une des méthodes suivantes:

    • Pour arrêter correctement l'instance et lui permettre d'exécuter des scripts d'arrêt avant d'arrêter le système d'exploitation invité, exécutez la commande suivante:

      shutdown /s

    • Pour forcer l'arrêt, exécutez la commande suivante:

      shutdown /f

Redémarrer une instance

Vous pouvez redémarrer une instance de calcul qui a été complètement arrêtée, c'est-à-dire lorsque son état est TERMINATED.

Si vous avez choisi de conserver les données de vos disques SSD locaux lorsque vous avez arrêté l'instance, vous devrez peut-être les réinstaller après l'avoir redémarrée. Pour en savoir plus sur l'installation de disques SSD locaux, consultez la section Formater et installer un disque SSD local.

Pour redémarrer une instance, utilisez l'une des méthodes suivantes, selon que des disques chiffrés sont associés à l'instance:

Redémarrer une instance sans disques chiffrés

Vous pouvez redémarrer 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 CLI gcloud. 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.

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

gcloud

Pour redémarrer une ou plusieurs instances dans la même zone, exécutez la commande gcloud compute instances start:

gcloud compute instances start 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"
)

// startInstance starts a stopped Google Compute Engine instance (with unencrypted disks).
func startInstance(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.StartInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	op, err := instancesClient.Start(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to start 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 started\n")

	return nil
}

Java 


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.StartInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class StartInstance {

  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 start. */
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    startInstance(project, zone, instanceName);
  }

  // Starts a stopped Google Compute Engine instance (with unencrypted disks).
  public static void startInstance(String project, String zone, String instanceName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    /* Initialize client that will be used to send requests. This client only needs to be created
       once, and can be reused for multiple requests. After completing all of your requests, call
       the `instancesClient.close()` method on the client to safely
       clean up any remaining background resources. */
    try (InstancesClient instancesClient = InstancesClient.create()) {

      // Create the request.
      StartInstanceRequest startInstanceRequest = StartInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstance(instanceName)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.startAsync(
          startInstanceRequest);

      // Wait for the operation to complete.
      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.getStatus() == Status.DONE) {
        System.out.println("Instance started successfully ! ");
      }
    }
  }
}

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');

async function startInstance() {
  const instancesClient = new compute.InstancesClient();

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

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

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

startInstance();

PHP 

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

/**
 * Starts a stopped 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 stop.
  *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function start_instance(
    string $projectId,
    string $zone,
    string $instanceName
) {
    // Start the Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new StartInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->start($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Instance %s started successfully' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Failed to start 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 start_instance(project_id: str, zone: str, instance_name: str) -> None:
    """
    Starts a stopped 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 your want to start.
    """
    instance_client = compute_v1.InstancesClient()

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

    wait_for_extended_operation(operation, "instance start")

REST

Pour redémarrer une instance, envoyez une requête POST à la méthode instances.start:

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

Remplacez les éléments suivants :

  • INSTANCE_NAME: nom de l'instance à redémarrer.

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

  • ZONE : zone où se trouve l'instance

Redémarrer une instance avec des disques chiffrés

Lorsque vous redémarrez une instance de calcul arrêtée dont les disques associés ont été chiffrés à l'aide de clés de chiffrement fournies par le client, vous devez fournir les informations de clé de chiffrement.

Vous pouvez redémarrer 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 les instances à redémarrer.

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

  4. Spécifiez la clé de chiffrement de chaque disque chiffré associé aux instances, puis cliquez sur Démarrer.

gcloud

Pour redémarrer une ou plusieurs instances qui utilisent des disques chiffrés dans la même zone, exécutez la commande gcloud compute instances start avec l'option --csek-key-file. Si vous utilisez une clé encapsulée en RSA, exécutez plutôt la commande gcloud beta compute instances start avec l'indicateur --csek-key-file:

gcloud compute instances start INSTANCE_NAMES \
    --csek-key-file=ENCRYPTION_KEY_FILE \
    --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).

  • ENCRYPTION_KEY_FILE : chemin relatif au fichier JSON contenant la clé de chiffrement fournie par le client. Vous ne pouvez redémarrer plusieurs instances simultanément que si elles utilisent la même clé de chiffrement fournie par le client.

  • 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"
	"google.golang.org/protobuf/proto"
)

// startInstanceWithEncKey starts a stopped Google Compute Engine instance (with encrypted disks).
func startInstanceWithEncKey(w io.Writer, projectID, zone, instanceName, key string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// key := "your_encryption_key"

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

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

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

	req := &computepb.StartWithEncryptionKeyInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
		InstancesStartWithEncryptionKeyRequestResource: &computepb.InstancesStartWithEncryptionKeyRequest{
			Disks: []*computepb.CustomerEncryptionKeyProtectedDisk{
				{
					Source: proto.String(instance.GetDisks()[0].GetSource()),
					DiskEncryptionKey: &computepb.CustomerEncryptionKey{
						RawKey: proto.String(key),
					},
				},
			},
		},
	}

	op, err := instancesClient.StartWithEncryptionKey(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to start instance with encryption key: %w", err)
	}

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

	fmt.Fprintf(w, "Instance with encryption key started\n")

	return nil
}

Java 


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.CustomerEncryptionKey;
import com.google.cloud.compute.v1.CustomerEncryptionKeyProtectedDisk;
import com.google.cloud.compute.v1.GetInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.InstancesStartWithEncryptionKeyRequest;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.StartWithEncryptionKeyInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class StartEncryptedInstance {

  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 start.
       key: bytes object representing a raw base64 encoded key to your machines boot disk.
            For more information about disk encryption see:
            https://cloud.google.com/compute/docs/disks/customer-supplied-encryption#specifications
     */
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";
    String key = "raw-key";

    startEncryptedInstance(project, zone, instanceName, key);
  }

  // Starts a stopped Google Compute Engine instance (with encrypted disks).
  public static void startEncryptedInstance(String project, String zone, String instanceName,
      String key)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    /* Initialize client that will be used to send requests. This client only needs to be created
       once, and can be reused for multiple requests. After completing all of your requests, call
       the `instancesClient.close()` method on the client to safely
       clean up any remaining background resources. */
    try (InstancesClient instancesClient = InstancesClient.create()) {

      GetInstanceRequest getInstanceRequest = GetInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstance(instanceName).build();

      Instance instance = instancesClient.get(getInstanceRequest);

      // Prepare the information about disk encryption.
      CustomerEncryptionKeyProtectedDisk protectedDisk = CustomerEncryptionKeyProtectedDisk
          .newBuilder()
          /* Use raw_key to send over the key to unlock the disk
             To use a key stored in KMS, you need to provide:
             `kms_key_name` and `kms_key_service_account`
           */
          .setDiskEncryptionKey(CustomerEncryptionKey.newBuilder()
              .setRawKey(key).build())
          .setSource(instance.getDisks(0).getSource())
          .build();

      InstancesStartWithEncryptionKeyRequest startWithEncryptionKeyRequest =
          InstancesStartWithEncryptionKeyRequest.newBuilder()
              .addDisks(protectedDisk).build();

      StartWithEncryptionKeyInstanceRequest encryptionKeyInstanceRequest =
          StartWithEncryptionKeyInstanceRequest.newBuilder()
              .setProject(project)
              .setZone(zone)
              .setInstance(instanceName)
              .setInstancesStartWithEncryptionKeyRequestResource(startWithEncryptionKeyRequest)
              .build();

      OperationFuture<Operation, Operation> operation = instancesClient.startWithEncryptionKeyAsync(
          encryptionKeyInstanceRequest);
      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.getStatus() == Status.DONE) {
        System.out.println("Encrypted instance started successfully ! ");
      }
    }
  }

}

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 key = 'YOUR_KEY_STRING'

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

async function startInstanceWithEncryptionKey() {
  const instancesClient = new compute.InstancesClient();

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

  const [response] = await instancesClient.startWithEncryptionKey({
    project: projectId,
    zone,
    instance: instanceName,
    instancesStartWithEncryptionKeyRequestResource: {
      disks: [
        {
          source: instance.disks[0].source,
          diskEncryptionKey: {
            rawKey: key,
          },
        },
      ],
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

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

  console.log('Instance with encryption key started.');
}

startInstanceWithEncryptionKey();

PHP 

use Google\Cloud\Compute\V1\Client\InstancesClient;
use Google\Cloud\Compute\V1\CustomerEncryptionKey;
use Google\Cloud\Compute\V1\CustomerEncryptionKeyProtectedDisk;
use Google\Cloud\Compute\V1\GetInstanceRequest;
use Google\Cloud\Compute\V1\InstancesStartWithEncryptionKeyRequest;
use Google\Cloud\Compute\V1\StartWithEncryptionKeyInstanceRequest;

/**
 * Starts a stopped Google Compute Engine instance (with encrypted 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 stop.
 * @param string $key Bytes object representing a raw base64 encoded key to your instance's boot disk.
 *                    For more information about disk encryption see:
 *                    https://cloud.google.com/compute/docs/disks/customer-supplied-encryption#specifications
 *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function start_instance_with_encryption_key(
    string $projectId,
    string $zone,
    string $instanceName,
    string $key
) {
    // Initiate the InstancesClient.
    $instancesClient = new InstancesClient();

    // Get data about the instance.
    $request = (new GetInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $instanceData = $instancesClient->get($request);

    // Use `setRawKey` to send over the key to unlock the disk
    // To use a key stored in KMS, you need to use `setKmsKeyName` and `setKmsKeyServiceAccount`
    $customerEncryptionKey = (new CustomerEncryptionKey())
        ->setRawKey($key);

    /** @var \Google\Cloud\Compute\V1\AttachedDisk */
    $disk = $instanceData->getDisks()[0];

    // Prepare the information about disk encryption.
    $diskData = (new CustomerEncryptionKeyProtectedDisk())
        ->setSource($disk->getSource())
        ->setDiskEncryptionKey($customerEncryptionKey);

    // Set request with one disk.
    $instancesStartWithEncryptionKeyRequest = (new InstancesStartWithEncryptionKeyRequest())
        ->setDisks(array($diskData));

    // Start the instance with encrypted disk.
    $request2 = (new StartWithEncryptionKeyInstanceRequest())
        ->setInstance($instanceName)
        ->setInstancesStartWithEncryptionKeyRequestResource($instancesStartWithEncryptionKeyRequest)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->startWithEncryptionKey($request2);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Instance %s started successfully' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Starting instance failed: %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 start_instance_with_encryption_key(
    project_id: str, zone: str, instance_name: str, key: bytes
) -> None:
    """
    Starts a stopped Google Compute Engine instance (with encrypted 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 your want to start.
        key: bytes object representing a raw base64 encoded key to your machines boot disk.
            For more information about disk encryption see:
            https://cloud.google.com/compute/docs/disks/customer-supplied-encryption#specifications
    """
    instance_client = compute_v1.InstancesClient()

    instance_data = instance_client.get(
        project=project_id, zone=zone, instance=instance_name
    )

    # Prepare the information about disk encryption
    disk_data = compute_v1.CustomerEncryptionKeyProtectedDisk()
    disk_data.source = instance_data.disks[0].source
    disk_data.disk_encryption_key = compute_v1.CustomerEncryptionKey()
    # Use raw_key to send over the key to unlock the disk
    # To use a key stored in KMS, you need to provide `kms_key_name` and `kms_key_service_account`
    disk_data.disk_encryption_key.raw_key = key
    enc_data = compute_v1.InstancesStartWithEncryptionKeyRequest()
    enc_data.disks = [disk_data]

    operation = instance_client.start_with_encryption_key(
        project=project_id,
        zone=zone,
        instance=instance_name,
        instances_start_with_encryption_key_request_resource=enc_data,
    )

    wait_for_extended_operation(operation, "instance start (with encrypted disk)")

REST

Pour redémarrer une instance qui utilise des disques chiffrés, envoyez une requête POST à la méthode instances.startWithEncryptionKey:

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

{
  "disks": [
    {
      "source": "DISK_URL",
      "diskEncryptionKey": {
        "ENCRYPTION_TYPE": "ENCRYPTION_KEY"
      }
    }
  ]
}

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.

  • DISK_URL : URL de la ressource correspondant au nom complet de la ressource du disque associé qui est chiffré avec une clé de chiffrement fournie par le client.

  • ENCRYPTION_TYPE : type de chiffrement de disque que vous utilisez, à savoir rawKey, kmsKeyName ou rsaEncryptedKey. Si vous utilisez le type rsaEncryptedKey, envoyez une requête POST à la méthode beta.instances.startWithEncryptionKey.

  • ENCRYPTION_KEY: clé de chiffrement utilisée pour chiffrer les disques persistants associés à l'instance. Les clés rawKey ou rsaEncryptedKey doivent être encodées en base64. En outre, pour préparer une clé rsaEncryptedKey, consultez la section Encapsuler une clé RSA.

Étape suivante