Sauvegarder vos données à l'aide d'un instantané

Console

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

   Accéder à la page "Instances de VM"
   school Les étapes restantes apparaîtront automatiquement dans la console Google Cloud.

2. Sélectionnez le projet contenant vos instances de VM.
3. Dans la colonne Nom, cliquez sur le nom de la VM contenant le disque persistant à sauvegarder.
4. Dans Stockage :
   • Pour sauvegarder le disque de démarrage, dans la section Disque de démarrage, cliquez sur le Nom du disque de démarrage.
   • Pour sauvegarder un disque persistant associé, dans Disques supplémentaires, cliquez sur le Nom du disque persistant associé.
5. Cliquez sur Créer un instantané.
6. Dans Nom, saisissez un nom unique permettant d'identifier la fonction de l'instantané. Exemple :
   • boot-disk-snapshot
   • attached-persistent-disk-snapshot
7. Dans Type, la valeur par défaut est un instantané standard, ce qui est idéal pour la sauvegarde à long terme et la reprise après sinistre.

   Choisissez Instantané d'archive pour une conservation des données plus économique.

8. Dans la section Emplacement, choisissez l'emplacement de stockage de votre instantané. L'emplacement par défaut prédéfini ou personnalisé configuré dans vos paramètres d'instantanés est automatiquement sélectionné. Vous pouvez éventuellement remplacer les paramètres d'instantanés et stocker vos instantanés dans un emplacement de stockage personnalisé en procédant comme suit :

   1. Choisissez le type d'emplacement de stockage souhaité pour votre instantané.

      • Choisissez Multirégional pour une disponibilité plus élevée à un coût plus élevé.
        
      • Choisissez des instantanés régionaux pour mieux contrôler l'emplacement physique de vos données, à moindre coût.

   2. Dans le champ Sélectionner l'emplacement, sélectionnez la région ou l'emplacement multirégional spécifique que vous souhaitez utiliser. Pour utiliser celui qui est le plus proche de votre disque source, sélectionnez Basé sur l'emplacement du disque source.

9. Pour créer un instantané manuel, cliquez sur Créer.

gcloud

1. Dans la console Google Cloud, activez Cloud Shell.

   Activer Cloud Shell

   En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.

2. Créez votre instantané à l'aide de la stratégie d'emplacement de stockage définie par vos paramètres d'instantanés ou en utilisant un autre emplacement de stockage de votre choix. Pour en savoir plus, consultez la section Choisir l'emplacement de stockage de vos instantanés. Vous devez saisir le nom de l'instantané. Le nom doit comporter entre 1 et 63 caractères, et être conforme à la norme RFC 1035.

   • Pour créer un instantané d'un volume de disque persistant dans l'emplacement par défaut prédéfini ou personnalisé configuré dans vos paramètres d'instantané, utilisez la commande gcloud compute snapshots create.

     gcloud compute snapshots create SNAPSHOT_NAME \
         --source-disk SOURCE_DISK \
         --snapshot-type SNAPSHOT_TYPE \
         --source-disk-zone SOURCE_DISK_ZONE
     

   • Sinon, pour remplacer les paramètres d'instantané et créer un instantané dans un emplacement de stockage personnalisé, incluez l'indicateur --storage-location pour spécifier où stocker l'instantané :

     gcloud compute snapshots create SNAPSHOT_NAME \
       --source-disk SOURCE_DISK \
       --source-disk-zone SOURCE_DISK_ZONE \
       --storage-location STORAGE_LOCATION \
       --snapshot-type SNAPSHOT_TYPE

     Remplacez les éléments suivants :

     • SNAPSHOT_NAME : nom de l'instantané.
     • SOURCE_DISK : nom du volume de disque persistant zonal à partir duquel vous souhaitez créer un instantané.
     • SNAPSHOT_TYPE: type d'instantané, STANDARD ou ARCHIVE. Si aucun type d'instantané n'est spécifié, un instantané STANDARD est créé. Choisissez Instantané d'archive pour une conservation des données plus économique.
     • SOURCE_DISK_ZONE : zone du volume de disque persistant zonal à partir duquel vous souhaitez créer un instantané.
     • STORAGE_LOCATION : pour les emplacements de stockage personnalisés, il s'agit de l'emplacement multirégional Cloud Storage ou de l'emplacement régional Cloud Storage dans lequel vous souhaitez stocker votre instantané. Vous ne pouvez spécifier qu'un seul emplacement de stockage.

     Utilisez l'option --storage-location uniquement lorsque vous souhaitez remplacer l'emplacement de stockage par défaut prédéfini ou personnalisé configuré dans vos paramètres d'instantanés.

   gcloud CLI attend que l'opération renvoie un état READY ou FAILED, ou qu'elle atteigne le délai maximal avant expiration et renvoie les informations les plus récentes de l'instantané.

Terraform

Pour créer un instantané du disque persistant zonal, utilisez la ressource google_compute_snapshot.

resource "google_compute_snapshot" "snapdisk" {
  name        = "snapshot-name"
  source_disk = google_compute_disk.default.name
  zone        = "us-central1-a"
}

Pour savoir comment appliquer ou supprimer une configuration Terraform, consultez la page Commandes Terraform de base.

API

Créez votre instantané dans la stratégie d'emplacement de stockage définie par vos paramètres d'instantanés ou en utilisant un autre emplacement de stockage de votre choix. Pour en savoir plus, consultez la section Choisir l'emplacement de stockage de vos instantanés.

• Pour créer un instantané dans l'emplacement par défaut prédéfini ou personnalisé configuré dans vos paramètres, envoyez une requête POST à la méthode snapshots.insert :

  POST http://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/global/snapshots
  
  {
    "name": SNAPSHOT_NAME
    "sourceDisk": "projects/SOURCE_PROJECT_ID/zones/SOURCE_ZONE/disks/SOURCE_DISK_NAME
    "snapshotType": SNAPSHOT_TYPE
  }
  

  Remplacez les éléments suivants :

  • DESTINATION_PROJECT_ID : ID du projet dans lequel vous souhaitez créer l'instantané.
  • SNAPSHOT_NAME : nom de l'instantané.
  • SOURCE_PROJECT_ID : ID de projet du disque source.
  • SOURCE_ZONE : zone du disque source.
  • SOURCE_DISK_NAME : nom du disque persistant à partir duquel vous souhaitez créer un instantané.
  • SNAPSHOT_TYPE: type d'instantané, STANDARD ou ARCHIVE. Si aucun type d'instantané n'est spécifié, un instantané STANDARD est créé.

• Pour remplacer les paramètres d'instantané et créer un instantané dans un emplacement de stockage personnalisé, vous pouvez également envoyer une requête POST à la méthode snapshots.insert et inclure l'élément Propriété storageLocations dans votre requête :

  POST http://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/global/snapshots
  
  {
    "name": SNAPSHOT_NAME
    "sourceDisk": "projects/SOURCE_PROJECT_ID/zones/SOURCE_ZONE/disks/SOURCE_DISK_NAME
    "snapshotType": SNAPSHOT_TYPE
    "storageLocations": STORAGE_LOCATION
  }
  

  Remplacez les éléments suivants :

  • DESTINATION_PROJECT_ID : ID du projet dans lequel vous souhaitez créer l'instantané.
  • SNAPSHOT_NAME : nom de l'instantané.
  • SOURCE_PROJECT_ID : ID de projet du disque source.
  • SOURCE_ZONE : zone du disque source.
  • SOURCE_DISK_NAME : nom du disque persistant à partir duquel vous souhaitez créer un instantané.
  • SNAPSHOT_TYPE: type d'instantané, STANDARD ou ARCHIVE. Si aucun type d'instantané n'est spécifié, un instantané STANDARD est créé.

  • STORAGE_LOCATION : emplacement multirégional Cloud Storage ou emplacement régional Cloud Storage dans lequel vous souhaitez stocker l'instantané. Vous ne pouvez spécifier qu'un seul emplacement de stockage.

    N'utilisez le paramètre storageLocations que si vous souhaitez ignorer l'emplacement de stockage par défaut prédéfini ou personnalisé configuré dans vos paramètres d'instantanés.

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.go888ogle.com.fqhub.com/go/compute/apiv1"
	computepb "cloud.go888ogle.com.fqhub.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

// createSnapshot creates a snapshot of a disk.
func createSnapshot(
	w io.Writer,
	projectID, diskName, snapshotName, zone, region, location, diskProjectID string,
) error {
	// projectID := "your_project_id"
	// diskName := "your_disk_name"
	// snapshotName := "your_snapshot_name"
	// zone := "europe-central2-b"
	// region := "eupore-central2"
	// location = "eupore-central2"
	// diskProjectID = "YOUR_DISK_PROJECT_ID"

	ctx := context.Background()

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

	if zone == "" && region == "" {
		return fmt.Errorf("you need to specify `zone` or `region` for this function to work")
	}

	if zone != "" && region != "" {
		return fmt.Errorf("you can't set both `zone` and `region` parameters")
	}

	if diskProjectID == "" {
		diskProjectID = projectID
	}

	disk := &computepb.Disk{}
	locations := []string{}
	if location != "" {
		locations = append(locations, location)
	}

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

		getDiskReq := &computepb.GetDiskRequest{
			Project: projectID,
			Zone:    zone,
			Disk:    diskName,
		}

		disk, err = disksClient.Get(ctx, getDiskReq)
		if err != nil {
			return fmt.Errorf("unable to get disk: %w", err)
		}
	} else {
		regionDisksClient, err := compute.NewRegionDisksRESTClient(ctx)
		if err != nil {
			return fmt.Errorf("NewRegionDisksRESTClient: %w", err)
		}
		defer regionDisksClient.Close()

		getDiskReq := &computepb.GetRegionDiskRequest{
			Project: projectID,
			Region:  region,
			Disk:    diskName,
		}

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

	req := &computepb.InsertSnapshotRequest{
		Project: projectID,
		SnapshotResource: &computepb.Snapshot{
			Name:             proto.String(snapshotName),
			SourceDisk:       proto.String(disk.GetSelfLink()),
			StorageLocations: locations,
		},
	}

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

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

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

	return nil
}

Java

import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.RegionDisksClient;
import com.google.cloud.compute.v1.Snapshot;
import com.google.cloud.compute.v1.SnapshotsClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateSnapshot {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // You need to pass `zone` or `region` parameter relevant to the disk you want to
    // snapshot, but not both. Pass `zone` parameter for zonal disks and `region` for
    // regional disks.

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

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

    // Name of the snapshot that you want to create.
    String snapshotName = "YOUR_SNAPSHOT_NAME";

    // The zone of the source disk from which you create the snapshot (for zonal disks).
    String zone = "europe-central2-b";

    // The region of the source disk from which you create the snapshot (for regional disks).
    String region = "your-disk-region";

    // The Cloud Storage multi-region or the Cloud Storage region where you
    // want to store your snapshot.
    // You can specify only one storage location. Available locations:
    // http://cloud.go888ogle.com.fqhub.com/storage/docs/locations#available-locations
    String location = "europe-central2";

    // Project ID or project number of the Cloud project that
    // hosts the disk you want to snapshot. If not provided, the value will be defaulted
    // to 'projectId' value.
    String diskProjectId = "YOUR_DISK_PROJECT_ID";

    createSnapshot(projectId, diskName, snapshotName, zone, region, location, diskProjectId);
  }

  // Creates a snapshot of a disk.
  public static void createSnapshot(String projectId, String diskName, String snapshotName,
      String zone, String region, String location, String diskProjectId)
      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 `snapshotsClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (SnapshotsClient snapshotsClient = SnapshotsClient.create()) {

      if (zone.isEmpty() && region.isEmpty()) {
        throw new Error("You need to specify 'zone' or 'region' for this function to work");
      }

      if (!zone.isEmpty() && !region.isEmpty()) {
        throw new Error("You can't set both 'zone' and 'region' parameters");
      }

      // If Disk's project id is not specified, then the projectId parameter will be used.
      if (diskProjectId.isEmpty()) {
        diskProjectId = projectId;
      }

      // If zone is not empty, use the DisksClient to create a disk.
      // Else, use the RegionDisksClient.
      Disk disk;
      if (!zone.isEmpty()) {
        DisksClient disksClient = DisksClient.create();
        disk = disksClient.get(projectId, zone, diskName);
      } else {
        RegionDisksClient regionDisksClient = RegionDisksClient.create();
        disk = regionDisksClient.get(diskProjectId, region, diskName);
      }

      // Set the snapshot properties.
      Snapshot snapshotResource;
      if (!location.isEmpty()) {
        snapshotResource = Snapshot.newBuilder()
            .setName(snapshotName)
            .setSourceDisk(disk.getSelfLink())
            .addStorageLocations(location)
            .build();
      } else {
        snapshotResource = Snapshot.newBuilder()
            .setName(snapshotName)
            .setSourceDisk(disk.getSelfLink())
            .build();
      }

      // Wait for the operation to complete.
      Operation operation = snapshotsClient.insertAsync(projectId, snapshotResource)
          .get(3, TimeUnit.MINUTES);

      if (operation.hasError()) {
        System.out.println("Snapshot creation failed!" + operation);
        return;
      }

      // Retrieve the created snapshot.
      Snapshot snapshot = snapshotsClient.get(projectId, snapshotName);
      System.out.printf("Snapshot created: %s", snapshot.getName());

    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const diskName = 'YOUR_DISK_NAME';
// const snapshotName = 'YOUR_SNAPSHOT_NAME';
// const zone = 'europe-central2-b';
// const region = '';
// const location = 'europe-central2';
// let diskProjectId = 'YOUR_DISK_PROJECT_ID';

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

async function createSnapshot() {
  const snapshotsClient = new compute.SnapshotsClient();

  let disk;

  if (!zone && !region) {
    throw new Error(
      'You need to specify `zone` or `region` for this function to work.'
    );
  }

  if (zone && region) {
    throw new Error("You can't set both `zone` and `region` parameters");
  }

  if (!diskProjectId) {
    diskProjectId = projectId;
  }

  if (zone) {
    const disksClient = new compute.DisksClient();
    [disk] = await disksClient.get({
      project: diskProjectId,
      zone,
      disk: diskName,
    });
  } else {
    const regionDisksClient = new compute.RegionDisksClient();
    [disk] = await regionDisksClient.get({
      project: diskProjectId,
      region,
      disk: diskName,
    });
  }

  const snapshotResource = {
    name: snapshotName,
    sourceDisk: disk.selfLink,
  };

  if (location) {
    snapshotResource.storageLocations = [location];
  }

  const [response] = await snapshotsClient.insert({
    project: projectId,
    snapshotResource,
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.GlobalOperationsClient();

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

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

createSnapshot();

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 create_snapshot(
    project_id: str,
    disk_name: str,
    snapshot_name: str,
    *,
    zone: str | None = None,
    region: str | None = None,
    location: str | None = None,
    disk_project_id: str | None = None,
) -> compute_v1.Snapshot:
    """
    Create a snapshot of a disk.

    You need to pass `zone` or `region` parameter relevant to the disk you want to
    snapshot, but not both. Pass `zone` parameter for zonal disks and `region` for
    regional disks.

    Args:
        project_id: project ID or project number of the Cloud project you want
            to use to store the snapshot.
        disk_name: name of the disk you want to snapshot.
        snapshot_name: name of the snapshot to be created.
        zone: name of the zone in which is the disk you want to snapshot (for zonal disks).
        region: name of the region in which is the disk you want to snapshot (for regional disks).
        location: The Cloud Storage multi-region or the Cloud Storage region where you
            want to store your snapshot.
            You can specify only one storage location. Available locations:
            http://cloud.go888ogle.com.fqhub.com/storage/docs/locations#available-locations
        disk_project_id: project ID or project number of the Cloud project that
            hosts the disk you want to snapshot. If not provided, will look for
            the disk in the `project_id` project.

    Returns:
        The new snapshot instance.
    """
    if zone is None and region is None:
        raise RuntimeError(
            "You need to specify `zone` or `region` for this function to work."
        )
    if zone is not None and region is not None:
        raise RuntimeError("You can't set both `zone` and `region` parameters.")

    if disk_project_id is None:
        disk_project_id = project_id

    if zone is not None:
        disk_client = compute_v1.DisksClient()
        disk = disk_client.get(project=disk_project_id, zone=zone, disk=disk_name)
    else:
        regio_disk_client = compute_v1.RegionDisksClient()
        disk = regio_disk_client.get(
            project=disk_project_id, region=region, disk=disk_name
        )

    snapshot = compute_v1.Snapshot()
    snapshot.source_disk = disk.self_link
    snapshot.name = snapshot_name
    if location:
        snapshot.storage_locations = [location]

    snapshot_client = compute_v1.SnapshotsClient()
    operation = snapshot_client.insert(project=project_id, snapshot_resource=snapshot)

    wait_for_extended_operation(operation, "snapshot creation")

    return snapshot_client.get(project=project_id, snapshot=snapshot_name)

Console

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

   Accéder à la page "Instances de VM"
   school Les étapes restantes apparaîtront automatiquement dans la console Google Cloud.

2. Sélectionnez le projet contenant vos instances de VM.
3. Dans la colonne Nom, cliquez sur le nom de la VM sur laquelle figure le disque persistant pour lequel vous souhaitez créer une programmation d'instantanés.
4. Dans Stockage, cliquez sur le nom du disque de démarrage ou du disque supplémentaire pour lequel vous souhaitez créer une programmation d'instantanés.
5. Cliquez sur editModifier. Vous devrez peut-être cliquer sur le menu more_vert Autres actions, puis sur editModifier.
6. Dans Programmation d'instantanés, sélectionnez Créer une programmation.
7. Dans Nom, saisissez l'un des noms suivants pour la programmation d'instantanés :
   • boot-disk-snapshot-schedule
   • attached-persistent-disk-snapshot-schedule

8. Dans la section Emplacement, choisissez l'emplacement de stockage de votre instantané. L'emplacement par défaut prédéfini ou personnalisé défini dans les paramètres de votre instantané est automatiquement sélectionné. Vous pouvez éventuellement remplacer les paramètres d'instantané et stocker vos instantanés dans un emplacement de stockage personnalisé en procédant comme suit :

   1. Choisissez le type d'emplacement de stockage souhaité pour votre instantané.

      • Choisissez Multirégional pour une disponibilité plus élevée à un coût plus élevé.
        
      • Choisissez des instantanés régionaux pour mieux contrôler l'emplacement physique de vos données, à moindre coût.

   2. Dans le champ Sélectionner l'emplacement, sélectionnez la région ou l'emplacement multirégional spécifique que vous souhaitez utiliser. Pour utiliser celui qui est le plus proche de votre disque source, sélectionnez Basé sur l'emplacement du disque source.

9. Pour terminer la création de la programmation d'instantanés, cliquez sur Créer.
10. Pour associer cette programmation d'instantanés au disque persistant, cliquez sur Enregistrer.

gcloud

Pour créer une programmation d'instantanés pour les disques persistants, utilisez la commande gcloud compute resource-policies create snapshot-schedule. Définissez la fréquence de la programmation sur "hourly" (horaire), "daily" (quotidienne) ou "weekly" (hebdomadaire).

  gcloud compute resource-policies create snapshot-schedule [SCHEDULE_NAME] \
      --description "[SCHEDULE_DESCRIPTION]" \
      --max-retention-days [MAX_RETENTION_DAYS] \
      --start-time [START_TIME] \
      --hourly-schedule [SNAPSHOT_INTERVAL] \
      --daily-schedule \
      --weekly-schedule [SNAPSHOT_INTERVAL] \
      --weekly-schedule-from-file [FILE_NAME] \
      --on-source-disk-delete [DELETION_OPTION]

où :

• [SCHEDULE_NAME] est le nom de la nouvelle programmation d'instantanés.
• "[SCHEDULE_DESCRIPTION]" est une description de la programmation d'instantanés. Utilisez des guillemets autour de votre description.
• [MAX_RETENTION_DAYS] est le nombre de jours de conservation de l'instantané. Par exemple, si vous le définissez sur 3, cela signifie que les instantanés sont conservés pendant trois jours avant d'être supprimés. Vous devez définir une règle de conservation d'un jour au minimum.
• [START_TIME] est l'heure de début, en temps UTC. L'heure ne doit pas inclure de minutes. Exemple :
  • 14h PST correspond à 22:00.
  • Si vous définissez une heure de début ayant la valeur 22:13, une erreur sera renvoyée.

• [SNAPSHOT_INTERVAL] définit l'intervalle auquel vous souhaitez que la création d'instantanés ait lieu. Définissez la programmation à fréquence horaire à l'aide d'un entier compris entre 1 et 23. Choisissez un nombre divisible de manière égale par 24. Par exemple, si vous définissez --hourly-schedule sur 12, l'instantané est généré toutes les 12 heures. Pour une programmation à fréquence hebdomadaire, définissez les jours auxquels vous souhaitez que la création d'instantanés ait lieu. Vous devez rédiger en entier les jours de la semaine. Ils ne sont pas sensibles à la casse. Les options de fréquence d'instantanés hourly-schedule, daily-schedule et weekly-schedule s'excluent mutuellement. Vous devez en choisir une seule pour la programmation d'instantanés.

• [FILE_NAME] est le nom du fichier contenant la programmation d'instantanés à fréquence hebdomadaire, si vous choisissez de fournir la programmation dans ce format. Notez que vous pouvez spécifier des programmations à fréquence hebdomadaire à différents jours et à différentes heures à l'aide d'un fichier. Vous ne pouvez pas spécifier plusieurs programmations à fréquence hebdomadaire directement sur la ligne de commande. Par exemple, votre fichier peut spécifier une programmation d'instantanés les lundis et mercredis : [{"day": "MONDAY", "startTime": "04:00"}, {"day": "WEDNESDAY", "startTime": "02:00"}]. Si vous incluez une heure de début dans votre fichier, vous n'avez pas besoin de définir l'option --start-time. La programmation utilise le temps UTC standard.

• [DELETION_OPTION] détermine ce qu'il advient de vos instantanés si le disque source est supprimé. Gardez la valeur par défaut keep-auto-snapshots en ignorant cette option, ou utilisez la valeur apply-retention-policy pour appliquer une règle de conservation.

Voici des exemples supplémentaires pour configurer une programmation d'instantanés. Tous ces exemples incluent les éléments suivants :

• La règle de suppression du disque est incluse, l'option --on-source-disk-delete est définie sur la valeur par défaut keep-auto-snapshots, laquelle permet de conserver indéfiniment tous les instantanés générés automatiquement. L'alternative consiste à définir cette option sur apply-retention-policy pour utiliser votre règle de conservation des instantanés.
• L'emplacement de stockage est défini sur US, afin que tous les instantanés générés soient stockés dans l'emplacement multirégional des États-Unis.
• Les libellés env=dev et media=images sont appliqués à tous les instantanés générés.
• La règle de conservation est définie sur 10 jours.

Programmation à fréquence horaire : dans cet exemple, la programmation d'instantanés commence à 22h UTC et se produit toutes les 4 heures.

  gcloud compute resource-policies create snapshot-schedule SCHEDULE_NAME \
      --description "MY HOURLY SNAPSHOT SCHEDULE" \
      --max-retention-days 10 \
      --start-time 22:00 \
      --hourly-schedule 4 \
      --region us-west1 \
      --on-source-disk-delete keep-auto-snapshots \
      --snapshot-labels env=dev,media=images \
      --storage-location US

Programmation à fréquence quotidienne : dans cet exemple, la programmation d'instantanés commence à 22h UTC et se déroule tous les jours à la même heure. L'option --daily-schedule doit être présente, mais vous ne devez lui définir aucun argument.

gcloud compute resource-policies create snapshot-schedule SCHEDULE_NAME \
    --description "MY DAILY SNAPSHOT SCHEDULE" \
    --max-retention-days 10 \
    --start-time 22:00 \
    --daily-schedule \
    --region us-west1 \
    --on-source-disk-delete keep-auto-snapshots \
    --snapshot-labels env=dev,media=images \
    --storage-location US

Programmation à fréquence hebdomadaire : dans cet exemple, la programmation d'instantanés commence à 22h UTC et a lieu toutes les semaines les mardis et jeudis.

gcloud compute resource-policies create snapshot-schedule SCHEDULE_NAME \
    --description "MY WEEKLY SNAPSHOT SCHEDULE" \
    --max-retention-days 10 \
    --start-time 22:00 \
    --weekly-schedule tuesday,thursday \
    --region us-west1 \
    --on-source-disk-delete keep-auto-snapshots \
    --snapshot-labels env=dev,media=images \
    --storage-location US

API

Dans l'API, envoyez une requête POST à resourcePolicies.insert pour créer une programmation d'instantanés. Au minimum, vous devez inclure le nom de la programmation d'instantanés, l'emplacement régional de stockage des instantanés et la fréquence d'instantanés.

Par défaut, le paramètre onSourceDiskDelete est défini sur keepAutoSnapshots. Cela signifie que si le disque source est supprimé, l'instantané généré automatiquement pour ce disque est conservé indéfiniment. Vous pouvez également définir l'option sur applyRetentionPolicy pour appliquer votre règle de conservation.

L'exemple suivant définit une programmation d'instantanés à fréquence quotidienne qui commence à 12h UTC et se répète chaque jour. L'exemple définit également une règle de conservation de 5 jours. Au bout de ces cinq jours, les instantanés sont automatiquement supprimés.

Vous pouvez également inclure des options d'emplacement des instantanés et des libellés d'instantanés dans votre requête, pour vous assurer que vos instantanés sont stockés à l'emplacement voulu.

POST http://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/regions/[REGION]/resourcePolicies

{
 "name": "[SCHEDULE_NAME]",
 "description": "[SCHEDULE_DESCRIPTION]",
 "snapshotSchedulePolicy": {
   "schedule": {
     "dailySchedule": {
       "startTime": "12:00",
       "daysInCycle": "1"
     }
   },
   "retentionPolicy": {
     "maxRetentionDays": "5"
   },
   "snapshotProperties": {
     "guestFlush": "False",
     "labels": {
       "env": "dev",
       "media": "images"
     },
     "storageLocations": ["US"]
   }
 }
}

où :

• [PROJECT_ID] est le nom du projet.
• [REGION] est l'emplacement de la règle de ressource de la programmation d'instantanés.
• [SCHEDULE_DESCRIPTION] est la description de la programmation d'instantanés.
• [SCHEDULE_NAME] est le nom de la programmation d'instantanés.

De même, vous pouvez créer une programmation à fréquence hebdomadaire ou mensuelle. Consultez la documentation de référence de l'API pour en savoir plus sur la définition d'une programmation hebdomadaire ou mensuelle.

Par exemple, la requête suivante crée une programmation à fréquence hebdomadaire qui s'exécute le mardi et le jeudi, à 9h et à 2h respectivement.

POST http://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/regions/[REGION]/resourcePolicies

{
 "name": "[SCHEDULE_NAME]",
 "description": "[SCHEDULE_DESCRIPTION]",
 "snapshotSchedulePolicy": {
   "schedule": {
     "weeklySchedule": {
       "dayOfWeeks": [
       {
         "day": "Monday",
         "startTime": "9:00"
       },
       {
         "day": "Thursday",
         "startTime": "2:00"
       }
       ]
     }
   },
  "retentionPolicy": {
    "maxRetentionDays": "5"
  },
  "snapshotProperties": {
    "guestFlush": "False",
    "labels": {
      "production": "webserver"
    },
    "storageLocations": ["US"]
  }
 }
}

Console

Pour associer une programmation d'instantanés à un disque existant, procédez comme suit.

1. Dans Google Cloud Console, accédez à la page Disques.

   Accéder à la page Disques

2. Sélectionnez le nom du disque auquel vous souhaitez associer une programmation d'instantanés. La page Gérer le disque s'ouvre.
3. Sur la page Gérer le disque, pointez et cliquez sur le menu more_vertAutres actions et sélectionnez editModifier.
4. Utilisez le menu déroulant Programmation des instantanés pour ajouter la programmation au disque, ou créez une programmation.
5. Si vous avez choisi de créer une programmation, cliquez sur Créer.
6. Cliquez sur Enregistrer pour terminer la tâche.

gcloud

Pour associer une programmation d'instantanés à un disque, utilisez la commande gcloud disks add-resource-policies.

gcloud compute disks add-resource-policies [DISK_NAME] \
    --resource-policies [SCHEDULE_NAME] \
    --zone [ZONE]

où :

• [DISK_NAME] est le nom du disque existant.
• [SCHEDULE_NAME] est le nom de la programmation d'instantanés.
• [ZONE] est l'emplacement de votre disque.

API

Dans l'API, envoyez une requête POST à disks.addResourcePolicies pour associer une programmation d'instantanés à un disque existant.

POST http://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/[ZONE]/disks/[DISK_NAME]/addResourcePolicies

{
  "resourcePolicies": [
    "regions/[REGION]/resourcePolicies/[SCHEDULE_NAME]"
  ]
}

où :

• [PROJECT_ID] est le nom du projet.
• [ZONE] est l'emplacement du disque.
• [REGION] est l'emplacement de la programmation d'instantanés.
• [DISK_NAME] est le nom du disque.
• [SCHEDULE_NAME] est le nom de la programmation d'instantanés dans la région que vous appliquez à ce disque.

Console

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

   Accéder à la section "Instantanés"

2. Recherchez le nom de l'instantané que vous souhaitez restaurer.

3. Accédez à la page Disques.

   Accéder à la page Disques

4. Cliquez sur Créer un disque.

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

6. Sous Type de source, cliquez sur Instantané.

7. Sélectionnez le nom de l'instantané à restaurer.

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

9. Cliquez sur Créer pour créer le disque.

Vous pouvez ensuite associer le nouveau disque à une instance existante.

1. Accédez à la page Instances de VM.

   Accéder à la page Instances de VM

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

gcloud

1. Exécutez la commande gcloud compute snapshots list pour rechercher le nom de l'instantané à restaurer :

   gcloud compute snapshots list
   

2. Exécutez la commande gcloud compute snapshots describe pour connaître la taille de l'instantané à restaurer :

   gcloud compute snapshots describe SNAPSHOT_NAME
   

   Remplacez SNAPSHOT_NAME par le nom de l'instantané à restaurer.

3. 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 : http://www.googleapis.com/compute/v1/projects/PROJECT_ID /zones/ZONE/diskTypes/pd-ssd.

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

API

1. Envoyez une requête GET à snapshots.list pour afficher la liste des instantanés de votre projet.

   GET http://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/snapshots

   en remplaçant PROJECT_ID par l'ID de votre projet :

2. Envoyez une requête POST pour créer un disque zonal à l'aide de la méthode disks.insert. 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.

   POST http://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 l'élément suivant :

   • 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 : http://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ ZONE/diskTypes/pd-ssd
   • SNAPSHOT_NAME est l'instantané source du disque que vous restaurez.

3. Vous pouvez ensuite associer le nouveau disque à une instance existante en envoyant une requête POST à la méthode instances.attachDisk, en incluant l'URL du disque zonal que vous venez de créer à partir de votre instantané.

   POST http://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.

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.go888ogle.com.fqhub.com/go/compute/apiv1"
	computepb "cloud.go888ogle.com.fqhub.com/go/compute/apiv1/computepb"
	"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

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

/**
 * 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

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)