Effectuer une restauration à partir d'un instantané

Un disque est un disque de démarrage utilisé pour démarrer et exécuter le système d'exploitation sur une instance de machine virtuelle (VM), ou un disque non amorçable qu'une VM utilise uniquement pour le stockage de données

Vous pouvez utiliser des instantanés pour sauvegarder et restaurer les données de disque des manières suivantes :

Après avoir pris un instantané d'un disque de démarrage ou non amorçable, créez un disque basé sur l'instantané.
Après avoir pris un instantané d'un disque de démarrage, créez une VM basée sur l'instantané du disque de démarrage.
Après avoir pris un instantané d'un disque non amorçable, créez une VM avec un nouveau disque non amorçable basé sur l'instantané.

Avant de commencer

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

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

Lorsque vous utilisez la console Google Cloud pour accéder aux services et aux API Google Cloud, vous n'avez pas besoin de configurer l'authentification.
gcloud
1. Installez Google Cloud CLI, puis initialisez-la en exécutant la commande suivante :
```
gcloud init
```
  Remarque : Si vous avez déjà installé gcloud CLI, assurez-vous que vous disposez de la dernière version en exécutant gcloud components update.
2. Définissez une région et une zone par défaut.
Go

Pour utiliser les exemples Go de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.
1. Installez Google Cloud CLI.
2. Pour initialiser gcloudCLI, exécutez la commande suivante :
```
gcloud init
```
3. Créez des identifiants d'authentification locaux pour votre compte Google :
```
gcloud auth application-default login
```
Pour en savoir plus, consultez les sections sur Configurer l'authentification pour un environnement de développement local.
Java

Pour utiliser les exemples Java de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.
1. Installez Google Cloud CLI.
2. Pour initialiser gcloudCLI, exécutez la commande suivante :
```
gcloud init
```
3. Créez des identifiants d'authentification locaux pour votre compte Google :
```
gcloud auth application-default login
```
Pour en savoir plus, consultez les sections sur Configurer l'authentification pour un environnement de développement local.
Node.js

Pour utiliser les exemples Node.js de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.
1. Installez Google Cloud CLI.
2. Pour initialiser gcloudCLI, exécutez la commande suivante :
```
gcloud init
```
3. Créez des identifiants d'authentification locaux pour votre compte Google :
```
gcloud auth application-default login
```
Pour en savoir plus, consultez les sections sur Configurer l'authentification pour un environnement de développement local.
Python

Pour utiliser les exemples Python de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.
1. Installez Google Cloud CLI.
2. Pour initialiser gcloudCLI, exécutez la commande suivante :
```
gcloud init
```
3. Créez des identifiants d'authentification locaux pour votre compte Google :
```
gcloud auth application-default login
```
Pour en savoir plus, consultez les sections sur Configurer l'authentification pour un environnement de développement local.
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.

Rôles requis

Pour obtenir les autorisations nécessaires pour restaurer un instantané, demandez à votre administrateur de vous accorder le rôle Administrateur d'instances Compute (v1) (roles/compute.instanceAdmin.v1) rôle IAM sur le projet. Pour en savoir plus sur l'attribution de rôles, consultez la section Gérer les accès.

Ce rôle prédéfini contient les autorisations requises pour effectuer une restauration à partir d'un instantané. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour effectuer une restauration à partir d'un instantané:

Créer un disque à partir d'un instantané :
- compute.disks.create sur le projet
- compute.instances.attachDisk sur la VM
- compute.disks.use sur le disque à associer
- compute.snapshots.useReadOnly, compute.snapshots.create ou compute.disks.createSnapshot sur le projet
Pour créer une VM à partir d'un instantané de disque de démarrage et de disque non amorçable, procédez comme suit :
- compute.instances.create sur le projet
- Pour créer la VM à l'aide d'une image personnalisée : compute.images.useReadOnly sur l'image
- Pour créer la VM à l'aide d'un instantané : compute.snapshots.useReadOnly sur l'instantané
- Pour créer la VM à l'aide d'un modèle d'instance : compute.instanceTemplates.useReadOnly sur le modèle d'instance
- Pour attribuer un ancien réseau à la VM : compute.networks.use sur le projet
- Pour spécifier une adresse IP statique pour la VM : compute.addresses.use sur le projet
- Pour attribuer une adresse IP externe à la VM, en cas d'utilisation d'un ancien réseau : compute.networks.useExternalIp sur le projet
- Pour spécifier un sous-réseau pour la VM : compute.subnetworks.use sur le projet ou sur le sous-réseau choisi
- Pour attribuer une adresse IP externe à la VM, en cas d'utilisation d'un réseau VPC : compute.subnetworks.useExternalIp sur le projet ou sur le sous-réseau choisi
- Pour définir les métadonnées d'instance de VM pour la VM : compute.instances.setMetadata sur le projet
- Pour définir des tags pour la VM : compute.instances.setTags sur la VM
- Pour définir des libellés pour la VM : compute.instances.setLabels sur la VM
- Pour définir un compte de service à utiliser avec la VM : compute.instances.setServiceAccount sur la VM
- Pour créer un disque pour la VM : compute.disks.create sur le projet
- Pour associer un disque existant en mode lecture seule ou en mode lecture-écriture : compute.disks.use sur le disque
- Pour associer un disque existant en mode lecture seule : compute.disks.useReadOnly sur le disque

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

Créer un disque à partir d'un instantané et l'associer à une VM

Si vous avez sauvegardé un disque de démarrage ou non amorçable avec un instantané, vous pouvez créer un disque basé sur l'instantané.

Restrictions

Le nouveau disque doit avoir la même taille que le disque source d'origine pour l'instantané. Si vous créez un disque d'une taille supérieure au disque source d'origine pour l'instantané, vous devez redimensionner le système de fichiers de ce disque persistant pour inclure l'espace disque supplémentaire. Selon le système d'exploitation et le type de système de fichiers, vous devrez peut-être utiliser un autre outil de redimensionnement des systèmes de fichiers. Pour en savoir plus, consultez la documentation de votre système d'exploitation.
Vous pouvez créer un disque zonal ou régional à partir d'un instantané au maximum une fois toutes les dix minutes. Ainsi, si vous souhaitez effectuer une série de requêtes d'instantanés sur vos disques, vous ne pouvez pas émettre plus de six requêtes en 60 minutes. Cette limite ne s'applique pas à la création de disques régionaux à partir d'un instantané. Pour en savoir plus, consultez la section Limites de fréquence des instantanés.

Console

Dans Google Cloud Console, accédez à la page Instantanés.

Accéder à la section "Instantanés"
Recherchez le nom de l'instantané que vous souhaitez restaurer.
Accédez à la page Disques.

Accéder à la page Disques
Cliquez sur Créer un disque.
Spécifiez les paramètres de configuration suivants :
- Le nom du disque.
- Le type de disque.
- Si vous le souhaitez, vous pouvez également remplacer la région et la zone par défaut. Vous pouvez sélectionner n'importe quelle région et zone, quel que soit l'emplacement de stockage de l'instantané source.
Sous Type de source, cliquez sur Instantané.
Sélectionnez le nom de l'instantané à restaurer.
Sélectionnez la taille du nouveau disque en Go. Ce nombre doit être supérieur ou égal au disque source d'origine de l'instantané.
Cliquez sur Créer pour créer le disque.

Vous pouvez éventuellement associer le nouveau disque à une instance existante.

Accédez à la page Instances de VM.
Accéder à la page Instances de VM
Cliquez sur le nom de l'instance sur laquelle vous souhaitez restaurer le disque non amorçable.
Cliquez sur Modifier en haut de la page des détails de l'instance.
Sous Disques supplémentaires, cliquez sur Associer un disque existant.
Sélectionnez le nom du nouveau disque créé à partir de votre instantané.
Cliquez sur OK pour associer le disque.
En bas de la page des détails de l'instance, cliquez sur Enregistrer pour appliquer vos modifications à l'instance.

gcloud

Exécutez la commande gcloud compute snapshots list pour trouver le nom de l'instantané que vous souhaitez restaurer :
```
gcloud compute snapshots list
```
Exécutez la commande gcloud compute snapshots describe pour connaître la taille de l'instantané que vous souhaitez restaurer :
```
gcloud compute snapshots describe SNAPSHOT_NAME
```
Remplacez SNAPSHOT_NAME par le nom de l'instantané à restaurer.
Exécutez la commande gcloud compute disks create pour créer un disque régional ou zonal à partir de votre instantané. Si vous avez besoin d'un disque persistant SSD pour obtenir un débit ou un taux d'IOPS plus élevés, ajoutez l'option --type et spécifiez pd-ssd.
```
gcloud compute disks create DISK_NAME \
    --size=DISK_SIZE \
    --source-snapshot=SNAPSHOT_NAME \
    --type=DISK_TYPE
```
Remplacez l'élément suivant :
- DISK_NAME : le nom du nouveau disque.
- DISK_SIZE : taille du nouveau disque en Go. Ce nombre doit être supérieur ou égal au disque source d'origine de l'instantané.
- SNAPSHOT_NAME : nom de l'instantané qui va être restauré.
- DISK_TYPE : URL complète ou partielle du type du disque. Exemple : https://www.googleapis.com/compute/v1/projects/PROJECT_ID /zones/ZONE/diskTypes/pd-ssd.
Facultatif : Associez le nouveau disque à une instance existante à l'aide de la commande gcloud compute instances attach-disk :
```
gcloud compute instances attach-disk INSTANCE_NAME \
    --disk DISK_NAME
```
Remplacez les éléments suivants :
- INSTANCE_NAME est le nom de l'instance.
- DISK_NAME est le nom du disque créé à partir de l'instantané.

Go

Avant d'essayer cet exemple, suivez les instructions de configuration pour Go décrites dans le Guide de démarrage rapide de Compute Engine à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Go Compute Engine.

Pour vous authentifier auprès de Compute Engine, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
	"google.golang.org/protobuf/proto"
)

// createDiskFromSnapshot creates a new disk in a project in given zone.
func createDiskFromSnapshot(
	w io.Writer,
	projectID, zone, diskName, diskType, snapshotLink string,
	diskSizeGb int64,
) error {
	// projectID := "your_project_id"
	// zone := "us-west3-b" // should match diskType below
	// diskName := "your_disk_name"
	// diskType := "zones/us-west3-b/diskTypes/pd-ssd"
	// snapshotLink := "projects/your_project_id/global/snapshots/snapshot_name"
	// diskSizeGb := 120

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

	req := &computepb.InsertDiskRequest{
		Project: projectID,
		Zone:    zone,
		DiskResource: &computepb.Disk{
			Name:           proto.String(diskName),
			Zone:           proto.String(zone),
			Type:           proto.String(diskType),
			SourceSnapshot: proto.String(snapshotLink),
			SizeGb:         proto.Int64(diskSizeGb),
		},
	}

	op, err := disksClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create disk: %w", err)
	}

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

	fmt.Fprintf(w, "Disk created\n")

	return nil
}

Java

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java décrites dans le Guide de démarrage rapide de Compute Engine à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Java Compute Engine.

Afficher sur GitHub Commentaires


import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.InsertDiskRequest;
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 CreateDiskFromSnapshot {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.

    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";

    // Name of the zone in which you want to create the disk.
    String zone = "europe-central2-b";

    // Name of the disk you want to create.
    String diskName = "YOUR_DISK_NAME";

    // The type of disk you want to create. This value uses the following format:
    // "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
    // For example: "zones/us-west3-b/diskTypes/pd-ssd"
    String diskType = String.format("zones/%s/diskTypes/pd-ssd", zone);

    // Size of the new disk in gigabytes.
    long diskSizeGb = 10;

    // The full path and name of the snapshot that you want to use as the source for the new disk.
    // This value uses the following format:
    // "projects/{projectName}/global/snapshots/{snapshotName}"
    String snapshotLink = String.format("projects/%s/global/snapshots/%s", projectId,
        "SNAPSHOT_NAME");

    createDiskFromSnapshot(projectId, zone, diskName, diskType, diskSizeGb, snapshotLink);
  }

  // Creates a new disk in a project in given zone, using a snapshot.
  public static void createDiskFromSnapshot(String projectId, String zone, String diskName,
      String diskType, long diskSizeGb, String snapshotLink)
      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 `disksClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (DisksClient disksClient = DisksClient.create()) {

      // Set the disk properties and the source snapshot.
      Disk disk = Disk.newBuilder()
          .setName(diskName)
          .setZone(zone)
          .setSizeGb(diskSizeGb)
          .setType(diskType)
          .setSourceSnapshot(snapshotLink)
          .build();

      // Create the insert disk request.
      InsertDiskRequest insertDiskRequest = InsertDiskRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setDiskResource(disk)
          .build();

      // Wait for the create disk operation to complete.
      Operation response = disksClient.insertAsync(insertDiskRequest)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Disk creation failed!" + response);
        return;
      }
      System.out.println("Disk created. Operation Status: " + response.getStatus());
    }
  }
}

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js décrites dans le Guide de démarrage rapide de Compute Engine à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Node.js Compute Engine.

Afficher sur GitHub Commentaires

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const diskName = 'YOUR_DISK_NAME';
// const diskType = 'zones/us-west3-b/diskTypes/pd-ssd';
// const diskSizeGb = 10;
// const snapshotLink = 'projects/project_name/global/snapshots/snapshot_name';

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

async function createDiskFromSnapshot() {
  const disksClient = new compute.DisksClient();

  const [response] = await disksClient.insert({
    project: projectId,
    zone,
    diskResource: {
      sizeGb: diskSizeGb,
      name: diskName,
      zone,
      type: diskType,
      sourceSnapshot: snapshotLink,
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

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

  console.log('Disk created.');
}

createDiskFromSnapshot();

Python

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python décrites dans le Guide de démarrage rapide de Compute Engine à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Python Compute Engine.

Afficher sur GitHub Commentaires

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 create_disk_from_snapshot(
    project_id: str,
    zone: str,
    disk_name: str,
    disk_type: str,
    disk_size_gb: int,
    snapshot_link: str,
) -> compute_v1.Disk:
    """
    Creates a new disk in a project in given zone.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone in which you want to create the disk.
        disk_name: name of the disk you want to create.
        disk_type: the type of disk you want to create. This value uses the following format:
            "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "zones/us-west3-b/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        snapshot_link: a link to the snapshot you want to use as a source for the new disk.
            This value uses the following format: "projects/{project_name}/global/snapshots/{snapshot_name}"

    Returns:
        An unattached Disk instance.
    """
    disk_client = compute_v1.DisksClient()
    disk = compute_v1.Disk()
    disk.zone = zone
    disk.size_gb = disk_size_gb
    disk.source_snapshot = snapshot_link
    disk.type_ = disk_type
    disk.name = disk_name
    operation = disk_client.insert(project=project_id, zone=zone, disk_resource=disk)

    wait_for_extended_operation(operation, "disk creation")

    return disk_client.get(project=project_id, zone=zone, disk=disk_name)

REST

Envoyez une requête GET à snapshots.list pour afficher la liste des instantanés de votre projet.
```
GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/snapshots
```
Remplacez PROJECT_ID par l'ID du projet.
Envoyez une requête POST pour créer un disque régional ou zonal à l'aide de la méthode disks.insert correspondante :
- Pour les disques zonaux : disks.insert
- Pour les disques régionaux : regionDisks.insert pour les disques régionaux
Incluez les propriétés name, sizeGb et type. Pour restaurer un disque à l'aide d'un instantané, vous devez inclure la propriété sourceSnapshot.

Par exemple, les requêtes suivantes créent un disque zonal :
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/disks

{
 "name": "DISK_NAME",
 "sizeGb": "DISK_SIZE",
 "type": "zones/ZONE/diskTypes/DISK_TYPE"
 "sourceSnapshot": "SNAPSHOT_NAME"
}
```
Remplacez les éléments suivants :
- PROJECT_ID : ID de votre projet.
- ZONE : la zone où se trouvent l'instance et le nouveau disque.
- DISK_NAME : le nom du nouveau disque.
- DISK_SIZE : la taille du nouveau disque en Go. Ce nombre doit être supérieur ou égal au disque source d'origine de l'instantané.
- DISK_TYPE : URL complète ou partielle du type du disque. Par exemple : https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ ZONE/diskTypes/pd-ssd
- SNAPSHOT_NAME est l'instantané source du disque que vous restaurez.
Vous pouvez éventuellement associer le nouveau disque à une instance existante en envoyant une requête POST à la méthode instances.attachDisk, en incluant l'URL du disque que vous venez de créer à partir de votre instantané.

Pour les disques régionaux, remplacez zones/ZONE par regions/REGION.
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/attachDisk

{
 "source": "/compute/v1/projects/PROJECT_ID/zones/ZONE/disks/DISK_NAME"
}
```
Remplacez les éléments suivants :
- PROJECT_ID est l'ID de votre projet.
- ZONE est la zone où se trouvent l'instance et le nouveau disque.
- INSTANCE_NAME est le nom de l'instance à laquelle vous ajoutez le disque.
- DISK_NAME est le nom du nouveau disque.

Après avoir créé et associé un disque à une instance, vous devez installer le disque pour que le système d'exploitation puisse utiliser l'espace de stockage disponible.

Important : Si vous créez une instance de VM à partir d'un instantané de disque basé sur une image de VM protégée, la référence initiale garantissant l'intégrité est supprimée et remplacée par une référence composée du premier ensemble de mesures associées à la séquence de démarrage de la nouvelle instance de VM. Étant donné que ce nouvel ensemble de mesures n'a pas été vérifié, validez l'intégrité du démarrage de l'instance de VM une fois la restauration effectuée à partir d'un instantané. Pour ce faire, examinez manuellement le journal de démarrage et vérifiez que les clés appropriées sont chargées dans la base de données SecureBoot et que la version de noyau attendue est en cours d'exécution. De plus, les secrets enregistrés dans le module vTPM sur l'instance d'origine de la machine virtuelle ne sont pas accessibles depuis les instances de VM restaurées à partir d'un instantané de cette instance.

Créer une VM à partir de disques existants

Vous pouvez créer un disque de démarrage et des disques de données à partir d'instantanés, puis les associer à une nouvelle VM.

Go

Afficher sur GitHub Commentaires

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
	"google.golang.org/protobuf/proto"
)

// createWithExistingDisks create a new VM instance using selected disks.
// The first disk in diskNames will be used as boot disk.
func createWithExistingDisks(
	w io.Writer,
	projectID, zone, instanceName string,
	diskNames []string,
) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// diskNames := []string{"boot_disk", "disk1", "disk2"}

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

	disksClient, err := compute.NewDisksRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewDisksRESTClient: %w", err)
	}
	defer disksClient.Close()

	disks := [](*computepb.Disk){}

	for _, diskName := range diskNames {
		reqDisk := &computepb.GetDiskRequest{
			Project: projectID,
			Zone:    zone,
			Disk:    diskName,
		}

		disk, err := disksClient.Get(ctx, reqDisk)
		if err != nil {
			return fmt.Errorf("unable to get disk: %w", err)
		}

		disks = append(disks, disk)
	}

	attachedDisks := [](*computepb.AttachedDisk){}

	for _, disk := range disks {
		attachedDisk := &computepb.AttachedDisk{
			Source: proto.String(disk.GetSelfLink()),
		}
		attachedDisks = append(attachedDisks, attachedDisk)
	}

	attachedDisks[0].Boot = proto.Bool(true)

	instanceResource := &computepb.Instance{
		Name:        proto.String(instanceName),
		Disks:       attachedDisks,
		MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/n1-standard-1", zone)),
		NetworkInterfaces: []*computepb.NetworkInterface{
			{
				Name: proto.String("global/networks/default"),
			},
		},
	}

	req := &computepb.InsertInstanceRequest{
		Project:          projectID,
		Zone:             zone,
		InstanceResource: instanceResource,
	}

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

	return nil
}

Java

Afficher sur GitHub Commentaires


import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateInstanceWithExistingDisks {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.

    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";

    // Name of the zone to create the instance in. For example: "us-west3-b"
    String zone = "europe-central2-b";

    // Name of the new virtual machine (VM) instance.
    String instanceName = "YOUR_INSTANCE_NAME";

    // Array of disk names to be attached to the new virtual machine.
    // First disk in this list will be used as the boot disk.
    List<String> diskNames = List.of("your-boot-disk", "another-disk1", "another-disk2");

    createInstanceWithExistingDisks(projectId, zone, instanceName, diskNames);
  }

  // Create a new VM instance using the selected disks.
  // The first disk in diskNames will be used as the boot disk.
  public static void createInstanceWithExistingDisks(String projectId, String zone,
      String instanceName, List<String> diskNames)
      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();
        DisksClient disksClient = DisksClient.create()) {

      if (diskNames.size() == 0) {
        throw new Error("At least one disk should be provided");
      }

      // Create the list of attached disks to be used in instance creation.
      List<AttachedDisk> attachedDisks = new ArrayList<>();
      for (int i = 0; i < diskNames.size(); i++) {
        String diskName = diskNames.get(i);
        Disk disk = disksClient.get(projectId, zone, diskName);
        AttachedDisk attDisk = null;

        if (i == 0) {
          // Make the first disk in the list as the boot disk.
          attDisk = AttachedDisk.newBuilder()
              .setSource(disk.getSelfLink())
              .setBoot(true)
              .build();
        } else {
          attDisk = AttachedDisk.newBuilder()
              .setSource(disk.getSelfLink())
              .build();
        }
        attachedDisks.add(attDisk);
      }

      // Create the instance.
      Instance instance = Instance.newBuilder()
          .setName(instanceName)
          // Add the attached disks to the instance.
          .addAllDisks(attachedDisks)
          .setMachineType(String.format("zones/%s/machineTypes/n1-standard-1", zone))
          .addNetworkInterfaces(
              NetworkInterface.newBuilder().setName("global/networks/default").build())
          .build();

      // Create the insert instance request.
      InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setInstanceResource(instance)
          .build();

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

      if (response.hasError()) {
        System.out.println("Instance creation failed!" + response);
        return;
      }
      System.out.println("Operation Status: " + response.getStatus());

    }
  }
}

Node.js

Afficher sur GitHub Commentaires

/**
 * 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 diskNames = ['boot_disk', 'disk1', 'disk2'];

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

async function createWithExistingDisks() {
  const instancesClient = new compute.InstancesClient();
  const disksClient = new compute.DisksClient();

  if (diskNames.length < 1) {
    throw new Error('At least one disk should be provided');
  }

  const disks = [];
  for (const diskName of diskNames) {
    const [disk] = await disksClient.get({
      project: projectId,
      zone,
      disk: diskName,
    });
    disks.push(disk);
  }

  const attachedDisks = [];

  for (const disk of disks) {
    attachedDisks.push({
      source: disk.selfLink,
    });
  }

  attachedDisks[0].boot = true;

  const [response] = await instancesClient.insert({
    project: projectId,
    zone,
    instanceResource: {
      name: instanceName,
      disks: attachedDisks,
      machineType: `zones/${zone}/machineTypes/n1-standard-1`,
      networkInterfaces: [
        {
          name: 'global/networks/default',
        },
      ],
    },
  });
  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 created.');
}

createWithExistingDisks();

Python

Afficher sur GitHub Commentaires

from __future__ import annotations

import re
import sys
from typing import Any
import warnings

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

def get_disk(project_id: str, zone: str, disk_name: str) -> compute_v1.Disk:
    """
    Gets a disk from a project.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone where the disk exists.
        disk_name: name of the disk you want to retrieve.
    """
    disk_client = compute_v1.DisksClient()
    return disk_client.get(project=project_id, zone=zone, disk=disk_name)

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 create_instance(
    project_id: str,
    zone: str,
    instance_name: str,
    disks: list[compute_v1.AttachedDisk],
    machine_type: str = "n1-standard-1",
    network_link: str = "global/networks/default",
    subnetwork_link: str = None,
    internal_ip: str = None,
    external_access: bool = False,
    external_ipv4: str = None,
    accelerators: list[compute_v1.AcceleratorConfig] = None,
    preemptible: bool = False,
    spot: bool = False,
    instance_termination_action: str = "STOP",
    custom_hostname: str = None,
    delete_protection: bool = False,
) -> compute_v1.Instance:
    """
    Send an instance creation request to the Compute Engine API and wait for it to complete.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        disks: a list of compute_v1.AttachedDisk objects describing the disks
            you want to attach to your new instance.
        machine_type: machine type of the VM being created. This value uses the
            following format: "zones/{zone}/machineTypes/{type_name}".
            For example: "zones/europe-west3-c/machineTypes/f1-micro"
        network_link: name of the network you want the new instance to use.
            For example: "global/networks/default" represents the network
            named "default", which is created automatically for each project.
        subnetwork_link: name of the subnetwork you want the new instance to use.
            This value uses the following format:
            "regions/{region}/subnetworks/{subnetwork_name}"
        internal_ip: internal IP address you want to assign to the new instance.
            By default, a free address from the pool of available internal IP addresses of
            used subnet will be used.
        external_access: boolean flag indicating if the instance should have an external IPv4
            address assigned.
        external_ipv4: external IPv4 address to be assigned to this instance. If you specify
            an external IP address, it must live in the same region as the zone of the instance.
            This setting requires `external_access` to be set to True to work.
        accelerators: a list of AcceleratorConfig objects describing the accelerators that will
            be attached to the new instance.
        preemptible: boolean value indicating if the new instance should be preemptible
            or not. Preemptible VMs have been deprecated and you should now use Spot VMs.
        spot: boolean value indicating if the new instance should be a Spot VM or not.
        instance_termination_action: What action should be taken once a Spot VM is terminated.
            Possible values: "STOP", "DELETE"
        custom_hostname: Custom hostname of the new VM instance.
            Custom hostnames must conform to RFC 1035 requirements for valid hostnames.
        delete_protection: boolean value indicating if the new virtual machine should be
            protected against deletion or not.
    Returns:
        Instance object.
    """
    instance_client = compute_v1.InstancesClient()

    # Use the network interface provided in the network_link argument.
    network_interface = compute_v1.NetworkInterface()
    network_interface.network = network_link
    if subnetwork_link:
        network_interface.subnetwork = subnetwork_link

    if internal_ip:
        network_interface.network_i_p = internal_ip

    if external_access:
        access = compute_v1.AccessConfig()
        access.type_ = compute_v1.AccessConfig.Type.ONE_TO_ONE_NAT.name
        access.name = "External NAT"
        access.network_tier = access.NetworkTier.PREMIUM.name
        if external_ipv4:
            access.nat_i_p = external_ipv4
        network_interface.access_configs = [access]

    # Collect information into the Instance object.
    instance = compute_v1.Instance()
    instance.network_interfaces = [network_interface]
    instance.name = instance_name
    instance.disks = disks
    if re.match(r"^zones/[a-z\d\-]+/machineTypes/[a-z\d\-]+$", machine_type):
        instance.machine_type = machine_type
    else:
        instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"

    instance.scheduling = compute_v1.Scheduling()
    if accelerators:
        instance.guest_accelerators = accelerators
        instance.scheduling.on_host_maintenance = (
            compute_v1.Scheduling.OnHostMaintenance.TERMINATE.name
        )

    if preemptible:
        # Set the preemptible setting
        warnings.warn(
            "Preemptible VMs are being replaced by Spot VMs.", DeprecationWarning
        )
        instance.scheduling = compute_v1.Scheduling()
        instance.scheduling.preemptible = True

    if spot:
        # Set the Spot VM setting
        instance.scheduling.provisioning_model = (
            compute_v1.Scheduling.ProvisioningModel.SPOT.name
        )
        instance.scheduling.instance_termination_action = instance_termination_action

    if custom_hostname is not None:
        # Set the custom hostname for the instance
        instance.hostname = custom_hostname

    if delete_protection:
        # Set the delete protection bit
        instance.deletion_protection = True

    # Prepare the request to insert an instance.
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

    # Wait for the create operation to complete.
    print(f"Creating the {instance_name} instance in {zone}...")

    operation = instance_client.insert(request=request)

    wait_for_extended_operation(operation, "instance creation")

    print(f"Instance {instance_name} created.")
    return instance_client.get(project=project_id, zone=zone, instance=instance_name)

def create_with_existing_disks(
    project_id: str, zone: str, instance_name: str, disk_names: list[str]
) -> compute_v1.Instance:
    """
    Create a new VM instance using selected disks. The first disk in disk_names will
    be used as boot disk.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        disk_names: list of disk names to be attached to the new virtual machine.
            First disk in this list will be used as the boot device.

    Returns:
        Instance object.
    """
    assert len(disk_names) >= 1
    disks = [get_disk(project_id, zone, disk_name) for disk_name in disk_names]
    attached_disks = []
    for disk in disks:
        adisk = compute_v1.AttachedDisk()
        adisk.source = disk.self_link
        attached_disks.append(adisk)
    attached_disks[0].boot = True
    instance = create_instance(project_id, zone, instance_name, attached_disks)
    return instance

Créer une VM à partir d'un instantané de disque de démarrage

Si vous avez sauvegardé le disque de démarrage d'une VM avec un instantané, vous pouvez l'utiliser pour créer une VM.

Pour créer une VM avec un disque de démarrage sous forme de disque persistant régional créé à partir d'un instantané, utilisez Google Cloud CLI ou l'API Compute Engine.

Console

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

Accéder à la page Instances de VM
Sélectionnez le projet et cliquez sur Continuer.
Cliquez sur Create instance (Créer une instance).
Spécifiez un nom pour votre VM. Pour en savoir plus, consultez Recommandation pour l'attribution de noms aux ressources.
Facultatif : modifiez la zone de cette VM. Compute Engine choisit de manière aléatoire la liste des zones de chaque région pour encourager l'utilisation dans plusieurs zones.
Sélectionnez une configuration de machine pour votre VM.
Dans la section Disque de démarrage, cliquez sur Modifier, puis procédez comme suit :
1. Cliquez sur l'onglet Instantanés.
2. Dans la liste des Instantanés, cliquez sur un instantané.
3. Spécifiez le type et la taille du disque de démarrage.
4. Facultatif : pour afficher les options de configuration avancées, cliquez sur Afficher les configurations avancées.
5. Cliquez sur Sélectionner pour confirmer vos options de disque de démarrage.
Dans la section Pare-feu, pour autoriser le trafic HTTP ou HTTPS vers la VM, sélectionnez Autoriser le trafic HTTP ou Autoriser le trafic HTTPS.

La console Google Cloud ajoute un tag réseau à votre VM et crée la règle de pare-feu d'entrée correspondante, qui autorise l'intégralité du trafic entrant sur le port tcp:80 (HTTP) ou tcp:443 (HTTPS). Le tag réseau associe la règle de pare-feu à la VM. Pour plus d'informations, consultez la page Présentation des règles de pare-feu dans la documentation sur Virtual Private Cloud.
Pour créer et démarrer la VM, cliquez sur Créer.

gcloud

Disque de démarrage sous forme de disque persistant

Exécutez la commande gcloud compute instances create en incluant l'option --source-snapshot.

gcloud compute instances create VM_NAME  \
    --source-snapshot=BOOT_SNAPSHOT_NAME  \
    --boot-disk-size=BOOT_DISK_SIZE  \
    --boot-disk-type=BOOT_DISK_TYPE  \
    --boot-disk-device-name=BOOT_DISK_NAME

Remplacez les éléments suivants :

VM_NAME : nom de la nouvelle VM
BOOT_SNAPSHOT_NAME : nom de l'instantané du disque de démarrage que vous souhaitez restaurer sur le disque de démarrage de la nouvelle VM.
BOOT_DISK_SIZE : (facultatif) taille, en Go, du nouveau disque de démarrage

La taille de ces disques doit être au moins égale à la taille des disques sources à partir desquels les instantanés ont été créés.
BOOT_DISK_TYPE : (facultatif) type du disque persistant de démarrage (par exemple, pd-ssd).
BOOT_DISK_NAME : nom du nouveau disque de démarrage pour cette VM

Disque de démarrage sous forme de disque persistant régional

Exécutez la commande gcloud compute instances create en incluant l'option --create-disk avec les propriétés source-snapshot, replica-zones et boot.

gcloud compute instances create VM_NAME \
   --zone=ZONE \
   --create-disk=^:^name=DISK_NAME:source-snapshot=BOOT_SNAPSHOT_NAME:boot=true:replica-zones=ZONE,REMOTE_ZONE

Les caractères ^:^ spécifient qu'un signe deux-points : est utilisé comme séparateur entre chacune des propriétés du disque. Cette valeur est obligatoire pour pouvoir utiliser une virgule , lorsque vous spécifiez les zones pour replica-zones.

Remplacez les éléments suivants :

VM_NAME : nom de la nouvelle VM.
ZONE : zone dans laquelle créer la VM.
DISK_NAME : (facultatif) nom du disque.
BOOT_SNAPSHOT_NAME : nom de l'instantané du disque de démarrage que vous souhaitez restaurer sur le disque de démarrage de la nouvelle VM.
REMOTE_ZONE : la région dans laquelle le disque persistant régional est répliqué. La propriété replica-zones nécessite deux zones séparées par une virgule, et l'une des zones doit être identique à celle de la VM

Go

Afficher sur GitHub Commentaires

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
	"google.golang.org/protobuf/proto"
)

// createInstanceFromSnapshot creates a new VM instance with boot disk created from a snapshot.
func createInstanceFromSnapshot(w io.Writer, projectID, zone, instanceName, snapshotLink string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// snapshotLink := "projects/project_name/global/snapshots/snapshot_name"

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

	req := &computepb.InsertInstanceRequest{
		Project: projectID,
		Zone:    zone,
		InstanceResource: &computepb.Instance{
			Name: proto.String(instanceName),
			Disks: []*computepb.AttachedDisk{
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb:     proto.Int64(11),
						SourceSnapshot: proto.String(snapshotLink),
						DiskType:       proto.String(fmt.Sprintf("zones/%s/diskTypes/pd-standard", zone)),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(true),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
			},
			MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/n1-standard-1", zone)),
			NetworkInterfaces: []*computepb.NetworkInterface{
				{
					Name: proto.String("global/networks/default"),
				},
			},
		},
	}

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

	return nil
}

Java

Afficher sur GitHub Commentaires


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDisk.Type;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.Image;
import com.google.cloud.compute.v1.ImagesClient;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.Vector;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateInstancesAdvanced {

  /**
   * @param diskType the type of disk you want to create. This value uses the following format:
   * "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)". For example:
   * "zones/us-west3-b/diskTypes/pd-ssd"
   * @param diskSizeGb size of the new disk in gigabytes
   * @param boot boolean flag indicating whether this disk should be used as a boot disk of an
   * instance
   * @param diskSnapshot disk snapshot to use when creating this disk. You must have read access to
   * this disk. This value uses the following format:
   * "projects/{project_name}/global/snapshots/{snapshot_name}"
   * @return AttachedDisk object configured to be created using the specified snapshot.
   */
  private static AttachedDisk diskFromSnapshot(String diskType, int diskSizeGb, boolean boot,
      String diskSnapshot) {
    AttachedDisk disk =
        AttachedDisk.newBuilder()
            .setBoot(boot)
            // Remember to set auto_delete to True if you want the disk to be deleted when
            // you delete your VM instance.
            .setAutoDelete(true)
            .setType(Type.PERSISTENT.toString())
            .setInitializeParams(
                AttachedDiskInitializeParams.newBuilder()
                    .setSourceSnapshot(diskSnapshot)
                    .setDiskSizeGb(diskSizeGb)
                    .setDiskType(diskType)
                    .build())
            .build();
    return disk;
  }

  /**
   * Send an instance creation request to the Compute Engine API and wait for it to complete.
   *
   * @param project project ID or project number of the Cloud project you want to use.
   * @param zone name of the zone to create the instance in. For example: "us-west3-b"
   * @param instanceName name of the new virtual machine (VM) instance.
   * @param disks a list of compute_v1.AttachedDisk objects describing the disks you want to attach
   * to your new instance.
   * @param machineType machine type of the VM being created. This value uses the following format:
   * "zones/{zone}/machineTypes/{type_name}".
   * For example: "zones/europe-west3-c/machineTypes/f1-micro"
   * @param network name of the network you want the new instance to use. For example:
   * "global/networks/default" represents the network named "default", which is created
   * automatically for each project.
   * @param subnetwork name of the subnetwork you want the new instance to use. This value uses the
   * following format: "regions/{region}/subnetworks/{subnetwork_name}"
   * @return Instance object.
   */
  private static Instance createWithDisks(String project, String zone, String instanceName,
      Vector<AttachedDisk> disks, String machineType, String network, String subnetwork)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    try (InstancesClient instancesClient = InstancesClient.create()) {
      // Use the network interface provided in the networkName argument.
      NetworkInterface networkInterface;
      if (subnetwork != null) {
        networkInterface = NetworkInterface.newBuilder()
            .setName(network).setSubnetwork(subnetwork)
            .build();
      } else {
        networkInterface = NetworkInterface.newBuilder()
            .setName(network).build();
      }

      machineType = String.format("zones/%s/machineTypes/%s", zone, machineType);

      // Bind `instanceName`, `machineType`, `disk`, and `networkInterface` to an instance.
      Instance instanceResource =
          Instance.newBuilder()
              .setName(instanceName)
              .setMachineType(machineType)
              .addAllDisks(disks)
              .addNetworkInterfaces(networkInterface)
              .build();

      System.out.printf("Creating instance: %s at %s ", instanceName, zone);

      // Insert the instance in the specified project and zone.
      InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstanceResource(instanceResource).build();

      OperationFuture<Operation, Operation> operation = instancesClient.insertAsync(
          insertInstanceRequest);

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

      if (response.hasError()) {
        System.out.println("Instance creation failed ! ! " + response);
        return null;
      }
      System.out.println("Operation Status: " + response.getStatus());

      return instancesClient.get(project, zone, instanceName);
    }
  }

  /**
   * Create a new VM instance with boot disk created from a snapshot.
   *
   * @param project project ID or project number of the Cloud project you want to use.
   * @param zone name of the zone to create the instance in. For example: "us-west3-b"
   * @param instanceName name of the new virtual machine (VM) instance.
   * @param snapshotName link to the snapshot you want to use as the source of your boot disk in the
   * form of: "projects/{project_name}/global/snapshots/{snapshot_name}"
   * @return Instance object.
   */
  public static Instance createFromSnapshot(String project, String zone, String instanceName,
      String snapshotName)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    String diskType = String.format("zones/%s/diskTypes/pd-standard", zone);
    Vector<AttachedDisk> disks = new Vector<>();
    disks.add(diskFromSnapshot(diskType, 11, true, snapshotName));
    return createWithDisks(project, zone, instanceName, disks, "n1-standard-1",
        "global/networks/default", null);
  }

Node.js

Afficher sur GitHub Commentaires

/**
 * 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 snapshotLink = 'projects/YOUR_PROJECT/global/snapshots/YOUR_SNAPSHOT_NAME';

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

// Creates a new VM instance with boot disk created from a snapshot.
async function createInstanceFromSnapshot() {
  const instancesClient = new compute.InstancesClient();

  const [response] = await instancesClient.insert({
    project: projectId,
    zone,
    instanceResource: {
      name: instanceName,
      disks: [
        {
          initializeParams: {
            diskSizeGb: '11',
            sourceSnapshot: snapshotLink,
            diskType: `zones/${zone}/diskTypes/pd-standard`,
          },
          autoDelete: true,
          boot: true,
          type: 'PERSISTENT',
        },
      ],
      machineType: `zones/${zone}/machineTypes/n1-standard-1`,
      networkInterfaces: [
        {
          name: 'global/networks/default',
        },
      ],
    },
  });
  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 created.');
}

createInstanceFromSnapshot();

Python

Afficher sur GitHub Commentaires

from __future__ import annotations

import re
import sys
from typing import Any
import warnings

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

def disk_from_snapshot(
    disk_type: str,
    disk_size_gb: int,
    boot: bool,
    source_snapshot: str,
    auto_delete: bool = True,
) -> compute_v1.AttachedDisk():
    """
    Create an AttachedDisk object to be used in VM instance creation. Uses a disk snapshot as the
    source for the new disk.

    Args:
         disk_type: the type of disk you want to create. This value uses the following format:
            "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "zones/us-west3-b/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        boot: boolean flag indicating whether this disk should be used as a boot disk of an instance
        source_snapshot: disk snapshot to use when creating this disk. You must have read access to this disk.
            This value uses the following format: "projects/{project_name}/global/snapshots/{snapshot_name}"
        auto_delete: boolean flag indicating whether this disk should be deleted with the VM that uses it

    Returns:
        AttachedDisk object configured to be created using the specified snapshot.
    """
    disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.source_snapshot = source_snapshot
    initialize_params.disk_type = disk_type
    initialize_params.disk_size_gb = disk_size_gb
    disk.initialize_params = initialize_params
    # Remember to set auto_delete to True if you want the disk to be deleted when you delete
    # your VM instance.
    disk.auto_delete = auto_delete
    disk.boot = boot
    return disk

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 create_instance(
    project_id: str,
    zone: str,
    instance_name: str,
    disks: list[compute_v1.AttachedDisk],
    machine_type: str = "n1-standard-1",
    network_link: str = "global/networks/default",
    subnetwork_link: str = None,
    internal_ip: str = None,
    external_access: bool = False,
    external_ipv4: str = None,
    accelerators: list[compute_v1.AcceleratorConfig] = None,
    preemptible: bool = False,
    spot: bool = False,
    instance_termination_action: str = "STOP",
    custom_hostname: str = None,
    delete_protection: bool = False,
) -> compute_v1.Instance:
    """
    Send an instance creation request to the Compute Engine API and wait for it to complete.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        disks: a list of compute_v1.AttachedDisk objects describing the disks
            you want to attach to your new instance.
        machine_type: machine type of the VM being created. This value uses the
            following format: "zones/{zone}/machineTypes/{type_name}".
            For example: "zones/europe-west3-c/machineTypes/f1-micro"
        network_link: name of the network you want the new instance to use.
            For example: "global/networks/default" represents the network
            named "default", which is created automatically for each project.
        subnetwork_link: name of the subnetwork you want the new instance to use.
            This value uses the following format:
            "regions/{region}/subnetworks/{subnetwork_name}"
        internal_ip: internal IP address you want to assign to the new instance.
            By default, a free address from the pool of available internal IP addresses of
            used subnet will be used.
        external_access: boolean flag indicating if the instance should have an external IPv4
            address assigned.
        external_ipv4: external IPv4 address to be assigned to this instance. If you specify
            an external IP address, it must live in the same region as the zone of the instance.
            This setting requires `external_access` to be set to True to work.
        accelerators: a list of AcceleratorConfig objects describing the accelerators that will
            be attached to the new instance.
        preemptible: boolean value indicating if the new instance should be preemptible
            or not. Preemptible VMs have been deprecated and you should now use Spot VMs.
        spot: boolean value indicating if the new instance should be a Spot VM or not.
        instance_termination_action: What action should be taken once a Spot VM is terminated.
            Possible values: "STOP", "DELETE"
        custom_hostname: Custom hostname of the new VM instance.
            Custom hostnames must conform to RFC 1035 requirements for valid hostnames.
        delete_protection: boolean value indicating if the new virtual machine should be
            protected against deletion or not.
    Returns:
        Instance object.
    """
    instance_client = compute_v1.InstancesClient()

    # Use the network interface provided in the network_link argument.
    network_interface = compute_v1.NetworkInterface()
    network_interface.network = network_link
    if subnetwork_link:
        network_interface.subnetwork = subnetwork_link

    if internal_ip:
        network_interface.network_i_p = internal_ip

    if external_access:
        access = compute_v1.AccessConfig()
        access.type_ = compute_v1.AccessConfig.Type.ONE_TO_ONE_NAT.name
        access.name = "External NAT"
        access.network_tier = access.NetworkTier.PREMIUM.name
        if external_ipv4:
            access.nat_i_p = external_ipv4
        network_interface.access_configs = [access]

    # Collect information into the Instance object.
    instance = compute_v1.Instance()
    instance.network_interfaces = [network_interface]
    instance.name = instance_name
    instance.disks = disks
    if re.match(r"^zones/[a-z\d\-]+/machineTypes/[a-z\d\-]+$", machine_type):
        instance.machine_type = machine_type
    else:
        instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"

    instance.scheduling = compute_v1.Scheduling()
    if accelerators:
        instance.guest_accelerators = accelerators
        instance.scheduling.on_host_maintenance = (
            compute_v1.Scheduling.OnHostMaintenance.TERMINATE.name
        )

    if preemptible:
        # Set the preemptible setting
        warnings.warn(
            "Preemptible VMs are being replaced by Spot VMs.", DeprecationWarning
        )
        instance.scheduling = compute_v1.Scheduling()
        instance.scheduling.preemptible = True

    if spot:
        # Set the Spot VM setting
        instance.scheduling.provisioning_model = (
            compute_v1.Scheduling.ProvisioningModel.SPOT.name
        )
        instance.scheduling.instance_termination_action = instance_termination_action

    if custom_hostname is not None:
        # Set the custom hostname for the instance
        instance.hostname = custom_hostname

    if delete_protection:
        # Set the delete protection bit
        instance.deletion_protection = True

    # Prepare the request to insert an instance.
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

    # Wait for the create operation to complete.
    print(f"Creating the {instance_name} instance in {zone}...")

    operation = instance_client.insert(request=request)

    wait_for_extended_operation(operation, "instance creation")

    print(f"Instance {instance_name} created.")
    return instance_client.get(project=project_id, zone=zone, instance=instance_name)

def create_from_snapshot(
    project_id: str, zone: str, instance_name: str, snapshot_link: str
):
    """
    Create a new VM instance with boot disk created from a snapshot. The
    new boot disk will have 20 gigabytes.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        snapshot_link: link to the snapshot you want to use as the source of your
            boot disk in the form of: "projects/{project_name}/global/snapshots/{snapshot_name}"

    Returns:
        Instance object.
    """
    disk_type = f"zones/{zone}/diskTypes/pd-standard"
    disks = [disk_from_snapshot(disk_type, 20, True, snapshot_link)]
    instance = create_instance(project_id, zone, instance_name, disks)
    return instance

REST

Lorsque vous utilisez l'API pour créer une VM à partir d'un instantané, les restrictions suivantes s'appliquent :

Un seul disque persistant peut être utilisé comme disque de démarrage.
Vous devez associer le disque de démarrage en tant que premier disque pour cette VM.
Si vous spécifiez la propriété source, vous ne pouvez pas également spécifier la propriété initializeParams. La propriété source indique que le disque persistant de démarrage existe déjà, mais la propriété initializeParams indique que Compute Engine doit créer un disque persistant de démarrage.

Disque de démarrage sous forme de disque persistant

Pour créer une VM à partir d'un instantané de disque de démarrage, utilisez la méthode instances.insert et spécifiez le champ sourceSnapshot sous la propriété disks. Vous pouvez également spécifier les propriétés diskSizeGb et diskType pour le nouveau disque de démarrage.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
  "name": "VM_NAME",
  "machineType": "machineTypes/MACHINE_TYPE"
  "networkInterfaces": [{
    "accessConfigs": [{
      "type": "ONE_TO_ONE_NAT",
      "name": "External NAT"
    }],
    "network": "global/networks/default"
  }],
  "disks": [{
     "boot": true,
     "initializeParams": {
       "sourceSnapshot": "global/snapshots/BOOT_SNAPSHOT_NAME",
       "diskSizeGb": "BOOT_DISK_SIZE",
       "diskType": "BOOT_DISK_TYPE"
      }
   }],
 }

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet.
ZONE : zone dans laquelle vous souhaitez créer la VM
VM_NAME : nom de la VM sur laquelle vous souhaitez restaurer un instantané
MACHINE_TYPE : type de machine de la VM
BOOT_SNAPSHOT_NAME : nom de l'instantané que vous souhaitez utiliser pour créer le disque de démarrage d'une nouvelle VM
BOOT_DISK_SIZE : (facultatif) taille, en Go, du nouveau disque de démarrage

La taille doit être au moins égale à la taille des disques sources à partir desquels les instantanés ont été créés.
BOOT_DISK_TYPE : (facultatif) type du disque de démarrage (par exemple, "pd-ssd").

Disque de démarrage sous forme de disque persistant régional

Pour créer une VM avec un disque de démarrage sous forme de disque persistant régional à partir d'un instantané de disque de démarrage, utilisez la méthode instances.insert et spécifiez les champs sourceSnapshot et replicaZones dans la propriété disks.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
  "name": "VM_NAME",
  "disks": [{
     "boot": true,
     "initializeParams": {
        "sourceSnapshot": "global/snapshots/BOOT_SNAPSHOT_NAME",
        "replicaZones": [
            "projects/PROJECT_ID/zones/ZONE",
            "projects/PROJECT_ID/zones/REMOTE_ZONE"]
   }
  }],
}

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet.
ZONE : nom de la zone dans laquelle vous souhaitez créer la VM.
VM_NAME : nom de la VM.
BOOT_SNAPSHOT_NAME : nom de l'instantané de disque de démarrage.
REMOTE_ZONE : zone distante pour le disque persistant régional.

Créer une VM à partir d'un instantané de disque non amorçable

Si vous avez sauvegardé un disque non amorçable avec un instantané, vous pouvez créer une VM avec un nouveau disque non amorçable basé sur l'instantané.

Console

Lorsque vous restaurez des instantanés de disques non amorçables sur une nouvelle VM à partir de la console, commencez par créer un disque à partir de chaque instantané. Ensuite, associez les nouveaux disques lorsque vous créez la VM.

Restaurez chaque instantané de disque non amorçable sur un nouveau disque.
1. Dans Google Cloud Console, accédez à la page Disques.
  
  Accéder à la page Disques
2. Cliquez sur Créer un disque.
3. Spécifiez le paramètre Nom pour le disque. Pour en savoir plus, consultez Recommandation pour l'attribution de noms aux ressources.
4. Sélectionnez une région et une zone pour ce disque. Le disque et la VM doivent se trouver dans la même zone pour les disques zonaux ou dans la même région pour les disques régionaux.
5. Sélectionnez un Type de disque.
6. Sous Type de source, sélectionnez Instantané.
7. Sous le nouveau champ Instantané source, sélectionnez un instantané de disque non amorçable que vous souhaitez restaurer sur le nouveau disque.
8. Pour créer le disque, cliquez sur Créer.
Répétez ces étapes pour créer un disque à partir de chaque instantané que vous souhaitez restaurer. Lorsque vous créez une VM, vous pouvez ajouter jusqu'à 15 disques non amorçables.
Dans Google Cloud Console, accédez à la page Instances de VM.

Accéder à la page Instances de VM
Sélectionnez le projet et cliquez sur Continuer.
Cliquez sur Create instance (Créer une instance).
1. Spécifiez un nom pour votre VM. Pour en savoir plus, consultez Recommandation pour l'attribution de noms aux ressources.
2. Sélectionnez une région et une zone pour cette VM. Le disque et la VM doivent se trouver dans la même zone pour les disques zonaux ou dans la même région pour les disques régionaux.
3. Sélectionnez un type de machine pour votre VM.
4. Si vous souhaitez autoriser le trafic externe entrant, modifiez les règles de pare-feu pour la VM.
5. Pour associer des disques à la VM, développez la section Options avancées, puis procédez comme suit:
  1. Développez la section Disques.
  2. Cliquez sur Associer un disque existant.
    1. Dans la liste des Disques, sélectionnez un disque à associer à cette VM.
    2. Dans la section Paramètre de rattachement, sélectionnez le mode de rattachement du disque et la règle de suppression du rattachement. Pour en savoir plus sur l'ajout de nouveaux disques, consultez la section Ajouter un disque persistant à votre VM.
  3. Cliquez sur Enregistrer.
  Répétez ces étapes pour chaque disque que vous souhaitez associer à l'instance. Lorsque vous créez une VM, vous pouvez ajouter jusqu'à 15 disques non amorçables.
Pour créer et démarrer la VM, cliquez sur Créer.

gcloud

Créez une VM à l'aide de la commande gcloud compute instances create. Pour chaque instantané de disque non amorçable que vous souhaitez restaurer, incluez l'option --create-disk et spécifiez source-snapshot. Lorsque vous créez une VM, vous pouvez ajouter jusqu'à 15 disques non amorçables.

Par exemple, pour restaurer deux instantanés de disques non amorçables sur une nouvelle VM, exécutez la commande suivante :

gcloud compute instances create VM_NAME \
    --create-disk source-snapshot=SNAPSHOT_1_NAME,name=DISK_1_NAME,size=DISK_1_SIZE,type=DISK_1_TYPE \
    --create-disk source-snapshot=SNAPSHOT_2_NAME,name=DISK_2_NAME,size=DISK_2_SIZE,type=DISK_2_TYPE

Remplacez l'élément suivant :

VM_NAME : nom de la nouvelle VM
SNAPSHOT_1_NAME et SNAPSHOT_2_NAME : noms des instantanés de disques non amorçables que vous souhaitez restaurer
DISK_1_NAME et DISK_2_NAME : noms des nouveaux disques non amorçables pour cette instance
DISK_1_SIZE et DISK_2_SIZE (facultatif) : tailles, en Go, de chaque nouveau disque non amorçable

Ces tailles doivent être au moins égales à celles des disques sources à partir desquels les instantanés ont été créés.
DISK_1_TYPE et DISK_2_TYPE : (facultatif) types des disques persistants

Par exemple, https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/pd-ssd.

REST

Lorsque vous utilisez l'API pour restaurer un instantané de disque non amorçable sur une nouvelle VM, les restrictions suivantes s'appliquent :

Un seul disque persistant peut être le disque persistant de démarrage.
Vous devez associer le disque persistant de démarrage en tant que premier disque pour cette VM.
Si vous spécifiez la propriété source, vous ne pouvez pas également spécifier la propriété initializeParams. La propriété source indique que le disque persistant de démarrage existe déjà, mais la propriété initializeParams indique que Compute Engine doit créer un disque persistant de démarrage.

À l'aide de l'API bêta, spécifiez le champ sourceSnapshot sous la propriété initializeParams. Vous pouvez ajouter jusqu'à 15 disques non amorçables en répétant la propriété initializeParams pour chaque disque non amorçable que vous souhaitez créer. Vous pouvez également spécifier les propriétés diskSizeGb et diskType pour chaque disque que vous créez.

Par exemple, pour restaurer deux instantanés de disques non amorçables sur une nouvelle VM, exécutez la requête suivante :

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
  "name": "VM_NAME",
  "machineType": "machineTypes/MACHINE_TYPE"
  "networkInterfaces": [{
    "accessConfigs": [{
      "type": "ONE_TO_ONE_NAT",
      "name": "External NAT"
    }],
    "network": "global/networks/default"
  }],
  "disks": [{
     "autoDelete": "true",
     "boot": "true",
     "type": "PERSISTENT",
     "diskSizeGb": "DISK_SIZE",
     "diskType": "DISK_TYPE"
   },
   {
     "initializeParams": {
        "sourceSnapshot": "global/snapshots/SNAPSHOT_1_NAME",
        "diskSizeGb": "DISK_SIZE",
        "diskType": "DISK_TYPE"
     }
   },
   {
     "initializeParams": {
        "sourceSnapshot": "global/snapshots/SNAPSHOT_2_NAME",
        "diskSizeGb": "DISK_SIZE",
        "diskType": "DISK_TYPE"
     }
  }]
 }

Remplacez l'élément suivant :

PROJECT_ID : ID de votre projet.
ZONE : zone dans laquelle vous souhaitez créer la VM
VM_NAME : nom de la VM sur laquelle vous souhaitez restaurer un instantané
MACHINE_TYPE : type de machine de la VM
DISK_SIZE : (facultatif) taille, en Go, du disque correspondant

Lorsqu'elle est fournie, cette propriété doit être supérieure ou égale à la taille du disque source à partir duquel l'instantané a été créé.
DISK_TYPE (facultatif) : URL complète ou partielle pour le type du disque persistant correspondant.

Par exemple, https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/pd-ssd.
SNAPSHOT_1_NAME et SNAPSHOT_2_NAME : noms des instantanés de disques non amorçables que vous souhaitez restaurer sur de nouveaux disques non amorçables sur la nouvelle VM