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

Cette page explique comment sauvegarder les données stockées sur votre instance de notebooks gérés par l'utilisateur Vertex AI Workbench en créant un instantané.

Les données de votre instance sont stockées sur un disque persistant zonal. Vous pouvez créer et utiliser des instantanés de ce disque pour sauvegarder vos données, créer une programmation de sauvegarde récurrente et restaurer des données sur une nouvelle instance.

Créer un instantané

Vous pouvez créer des instantanés à partir de disques, même lorsqu'ils sont associés à des instances en cours d'exécution. Les instantanés sont des ressources globales. Vous pouvez donc les utiliser pour restaurer des données sur un nouveau disque ou une nouvelle instance du même projet. Vous pouvez également partager des instantanés entre plusieurs projets.

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes :

compute.snapshots.create sur le projet
compute.disks.createSnapshot sur le disque

Console

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

Accéder à la page "Instances de VM"
Les étapes restantes apparaîtront automatiquement dans la console Google Cloud.
Sélectionnez le projet contenant vos instances de VM.
Dans la colonne Nom, cliquez sur le nom de la VM contenant le disque persistant à sauvegarder.
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 de données associé, dans Disques supplémentaires, cliquez sur le Nom du disque.
Cliquez sur Créer un instantané.
Dans Nom, saisissez un nom unique permettant d'identifier la fonction de l'instantané. Exemple :
- boot-disk-snapshot
- attached-data-disk-snapshot
Dans Type, la valeur par défaut est un instantané standard. Les instantanés standards sont les plus adaptés pour la sauvegarde à long terme et la reprise après sinistre.
Choisissez Instantané d'archive pour créer une sauvegarde plus économique que les instantanés standards, mais avec un temps de récupération des données plus long.

Pour en savoir plus, consultez la section Comparaison des types d'instantanés.
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, choisissez un emplacement dans la section Basé sur l'emplacement du disque source.
Pour créer un instantané, cliquez sur Créer.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
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é.
Remarque : Google recommande d'utiliser la commande gcloud compute snapshots create plutôt que la commande gcloud compute disks snapshot car elle prend en charge un plus grand nombre de fonctionnalités dont la création d'instantanés dans un projet différent du projet de disque source.

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 https://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 https://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

Avant d'essayer cet exemple, suivez les instructions de configuration décrites dans le Guide de démarrage rapide de Compute Engine à l'aide des bibliothèques clientes.

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

import (
	"context"
	"fmt"
	"io"

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

Avant d'essayer cet exemple, suivez les instructions de configuration décrites dans le Guide de démarrage rapide de Compute Engine à l'aide des bibliothèques clientes.


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:
    // https://cloud.google.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

Avant d'essayer cet exemple, suivez les instructions de configuration décrites dans le Guide de démarrage rapide de Compute Engine à l'aide des bibliothèques clientes.

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

Avant d'essayer cet exemple, suivez les instructions de configuration décrites dans le Guide de démarrage rapide de Compute Engine à l'aide des bibliothèques clientes.

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:
            https://cloud.google.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)

Programmer une sauvegarde récurrente

Lors de la création d'une programmation d'instantanés, vous créez une règle de ressource que vous pouvez appliquer à un ou plusieurs disques persistants. Vous pouvez créer des programmations d'instantanés comme suit :

Une programmation d'instantanés inclut les propriétés suivantes :

Nom de la programmation
Description de la programmation
Fréquence des instantanés (horaire, quotidienne, hebdomadaire)
Heure de début des instantanés
Région dans laquelle la programmation d'instantanés est disponible
Règle de suppression du disque source pour gérer les instantanés générés automatiquement si le disque source est supprimé
Règle de conservation permettant de définir la durée de conservation des instantanés générés à partir de la programmation d'instantanés

Restrictions

Un disque persistant peut être associé à un maximum de 10 programmations d'instantanés à la fois.
Vous ne pouvez pas créer d'instantanés d'archive à l'aide d'une programmation d'instantanés.
Les programmations d'instantanés en cours d'utilisation sont limitées à 1 000 par région.
Les programmations d'instantanés ne s'appliquent qu'au projet dans lequel elles ont été créées. Les programmations d'instantanés ne peuvent pas être utilisées dans d'autres projets ou organisations.
Vous devrez peut-être demander une augmentation du quota de ressources via la console si vous avez besoin de ressources supplémentaires dans votre région.
Vous ne pouvez pas supprimer une programmation d'instantanés si celle-ci est associée à un disque. Vous devez dissocier la programmation de tous les disques pour pouvoir ensuite la supprimer.
Vous pouvez mettre à jour une programmation d'instantanés existante pour modifier sa description, sa programmation et ses libellés. Pour mettre à jour d'autres valeurs d'une programmation d'instantanés, vous devez supprimer la programmation d'instantanés et en créer une autre.
Pour les disques persistants qui utilisent une clé de chiffrement fournie par le client (CSEK), vous ne pouvez pas créer de programmations d'instantanés.
Pour les disques persistants qui utilisent une clé de chiffrement gérée par le client (CMEK), tous les instantanés créés avec une programmation d'instantanés sont automatiquement chiffrés avec la même clé.

Créer une programmation

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes :

compute.resourcePolicies.create sur le projet ou l'organisation

Créez une programmation d'instantanés pour vos disques persistants à l'aide de Google Cloud Console, de Google Cloud CLI ou de l'API Compute Engine. Vous devez créer votre programmation d'instantanés dans la région où se trouve votre disque persistant. Par exemple, si votre disque persistant se trouve dans la zone us-west1-a, votre programmation doit se trouver dans la région us-west1. Pour en savoir plus, consultez la section Choisir un emplacement de stockage.

Console

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

Accéder à la page "Instances de VM"
Les étapes restantes apparaîtront automatiquement dans la console Google Cloud.
Sélectionnez le projet contenant vos instances de VM.
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.
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.
Cliquez sur Modifier. Vous devrez peut-être cliquer sur le menu Autres actions, puis sur Modifier.
Dans Programmation d'instantanés, sélectionnez Créer une programmation.
Dans Nom, saisissez l'un des noms suivants pour la programmation d'instantanés :
- boot-disk-snapshot-schedule
- attached-persistent-disk-snapshot-schedule
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é 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 un 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.
Pour terminer la création de la programmation d'instantanés, cliquez sur Créer.
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.
Remarque : Si vous souhaitez spécifier une programmation hebdomadaire avec des jours différents et des heures de début différentes, utilisez plutôt --weekly-schedule-from-file.
[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 https://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 https://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"]
  }
 }
}

Associer une programmation d'instantanés à un disque

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes :

compute.disks.addResourcePolicies sur le disque
compute.resourcePolicies.use sur la règle de ressources à utiliser

Une fois que vous avez créé une programmation, associez-la à un disque existant. Utilisez la console, la commande gcloud ou la méthode API Compute Engine.

Console

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

Dans Google Cloud Console, accédez à la page Disques.
Accéder à la page Disques
Sélectionnez le nom du disque auquel vous souhaitez associer une programmation d'instantanés. La page Gérer le disque s'ouvre.
Sur la page Gérer le disque, pointez et cliquez sur le menu Autres actions et sélectionnez Modifier.
Utilisez le menu déroulant Programmation des instantanés pour ajouter la programmation au disque, ou créez une programmation.
Si vous avez choisi de créer une programmation, cliquez sur Créer.
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 https://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.

Restaurer des données à partir d'un instantané

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.

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

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes :

compute.disks.create sur le projet pour créer un disque
compute.instances.attachDisk sur l'instance de VM
l'autorisation compute.disks.use sur le disque à associer

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 ensuite 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 rechercher le nom de l'instantané à restaurer :
```
gcloud compute snapshots list
```
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.
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.
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

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

en remplaçant PROJECT_ID par l'ID de votre projet :
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 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 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 : 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 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 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.

Go

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

Pour vous authentifier auprès de Vertex AI, 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.

import (
	"context"
	"fmt"
	"io"

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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI 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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI 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

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API 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)

Installer le disque

Dans le terminal, exécutez la commande lsblk pour répertorier les disques associés à votre instance, puis recherchez le disque que vous souhaitez installer.
```
$ sudo lsblk

NAME   MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda      8:0    0   10G  0 disk
└─sda1   8:1    0   10G  0 part /
sdb      8:16   0  250G  0 disk
```
Dans cet exemple, sdb correspond au nom de l'appareil pour le nouveau disque persistant vide.
Utilisez l'outil mount pour installer le disque sur l'instance et activez l'option discard :
```
$ sudo mount -o discard,defaults /dev/DEVICE_NAME /home/jupyter
```
Remplacez les éléments suivants :
- DEVICE_NAME : nom du disque à installer.
Configurez les autorisations de lecture et d'écriture sur l'appareil. Dans l'exemple ci-dessous, nous allons accorder à tous les utilisateurs un accès en écriture au disque :
```
$ sudo chmod a+w /home/jupyter
```

Étapes suivantes

Découvrez comment enregistrer un notebook sur GitHub.
Apprenez-en plus sur la création d'instantanés.
Apprenez-en plus sur la programmation d'instantanés.