Cette page a été traduite par l'API Cloud Translation.

Gérer des instantanés de disque

Les instantanés de disque standards vous permettent de sauvegarder régulièrement des données de votre Persistent Disk et de votre Google Cloud Hyperdisk.

Vous pouvez afficher, répertorier et supprimer des instantanés de disque. Vous pouvez également partager des instantanés entre plusieurs projets.

Avant de commencer

Si ce n'est pas déjà fait, configurez l'authentification. L'authentification permet de valider votre identité pour accéder aux services et aux API Google Cloud . Pour exécuter du code ou des exemples depuis un environnement de développement local, vous pouvez vous authentifier auprès de Compute Engine en sélectionnant l'une des options suivantes :
Select the tab for how you plan to use the samples on this page:
Console

When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.
gcloud
1. Installez la Google Cloud CLI. Une fois l'installation terminée, initialisez la Google Cloud CLI en exécutant la commande suivante :
  gcloud init
  Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.
  
  Remarque : Si vous avez déjà installé la gcloud CLI, assurez-vous que vous disposez de la dernière version en exécutant gcloud components update.
2. Set a default region and zone.
REST

Pour utiliser les exemples API REST de cette page dans un environnement de développement local, vous devez utiliser les identifiants que vous fournissez à la gcloud CLI.
Pour en savoir plus, consultez la section S'authentifier pour utiliser REST dans la documentation sur l'authentification Google Cloud .

Rôles et autorisations requis

Pour obtenir les autorisations nécessaires pour gérer les instantanés standards, demandez à votre administrateur de vous accorder les rôles IAM suivants sur le projet :

Administrateur d'instances Compute (v1) (roles/compute.instanceAdmin.v1)
Pour vous connecter à une VM pouvant s'exécuter en tant que compte de service : Utilisateur du compte de service (v1) (roles/iam.serviceAccountUser)

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Ces rôles prédéfinis contiennent les autorisations requises pour gérer les instantanés standards. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour gérer les instantanés standards:

Pour répertorier les instantanés : compute.snapshots.list sur le projet
Pour afficher des informations sur un instantané : compute.snapshots.get sur l'instantané
Pour supprimer un instantané : compute.snapshots.delete sur l'instantané
Pour supprimer des instantanés basés sur un filtre :
- compute.snapshots.delete sur l'instantané
- compute.snapshots.list sur le projet
Pour partager des données d'instantané entre projets :
- compute.storageAdmin sur le projet (pour accéder à tous les instantanés standards)
- compute.disks.create sur le projet avec lequel partager
- compute.snapshots.create sur le projet source
- compute.disks.createSnapshot sur le disque source

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

Afficher les instantanés standards dans un projet ou un emplacement

Vous pouvez afficher ou répertorier les instantanés standards dans un projet ou un emplacement à l'aide de la gcloud CLI, de la console Google Cloud ou de REST.

Console

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

Accéder à la page Instantanés
Dans l'onglet Instantanés, vous pouvez afficher les instantanés standards du projet en cours.
Facultatif. Affinez les résultats à l'aide du champ Filtre filter_list. Saisissez un nom ou une valeur de propriété dans le champ Filtre, ou choisissez parmi les propriétés disponibles.

gcloud

Pour afficher la liste de tous les instantanés disponibles pour un projet particulier, utilisez la commande gcloud compute snapshots list.
```
gcloud compute snapshots list --project=PROJECT_ID
```
(Aperçu) Pour afficher la liste des instantanés à portée régionale disponibles pour un projet particulier, utilisez la commande gcloud compute snapshots list et spécifiez la région.
```
gcloud compute snapshots list --region=REGION_NAME
```
Pour afficher la liste des instantanés à portée mondiale disponibles pour un projet particulier, utilisez la commande gcloud compute snapshots list en incluant l'option --global.
```
gcloud compute snapshots list --global
```

Remplacez les éléments suivants :

PROJECT_ID : facultatif. Remplacez par l'ID du projet. Si vous omettez cette option, le projet actuel est utilisé. Vous pouvez définir le projet par défaut pour votre session à l'aide de la commande gcloud CLI gcloud config set project PROJECT_ID.
REGION_NAME : nom de la région pour laquelle vous souhaitez afficher les instantanés.

REST

Pour afficher la liste de tous les instantanés disponibles pour un projet particulier, envoyez une requête GET à la méthode snapshots.list et spécifiez "aggregated" (agrégé).
```
GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/aggregated/snapshots
```
(Aperçu) Pour afficher la liste des instantanés à portée régionale disponibles pour un projet particulier, envoyez une requête GET à la méthode snapshots.list et spécifiez la région.
```
GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_NAME/snapshots
```
Pour afficher la liste des instantanés à portée globale disponibles pour un projet particulier, envoyez une requête GET à la méthode snapshots.list et spécifiez "global".
```
GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/snapshots
```

Remplacez les éléments suivants :

PROJECT_ID : ID du projet.
REGION_NAME : nom de la région pour laquelle vous souhaitez afficher les instantanés.

Afficher les instantanés standards d'un disque

Vous pouvez afficher la liste des instantanés standards pour un disque à l'aide de la Google Cloud console, de la gcloud CLI ou de REST.

Console

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

Accéder à la page Instantanés
L'onglet Instantanés affiche la liste de tous les instantanés standards du projet.
Filtrez les résultats par disque source :
1. Saisissez Source disk: dans le champ Filtre filter_list ou cliquez sur le champ Filtre, puis sélectionnez l'option la valeur Source disk dans la liste Propriétés.
2. Sélectionnez le nom du disque dans la liste Valeurs qui s'affiche à côté de Source disk: dans le champ Filtre.
  
  Les instantanés affichés dans la console affichent désormais tous les instantanés standards pour le disque spécifié.
  
  Si vous ne voyez pas le nom d'un disque dans la liste Valeurs, saisissez dans le champ Filtre à côté de Source disk:, saisissez les premières lettres du nom du disque source pour modifier la liste des valeurs qui s'affiche.

gcloud

Répertoriez les instantanés standards d'un disque à l'aide de la commande gcloud compute snapshots list et de l'argument --filter.

Répertoriez les instantanés standards pour un disque zonal :

gcloud compute snapshots list --filter="sourceDisk:projects/PROJECT_ID/zones/SOURCE_ZONE/disks/DISK_NAME

Répertoriez les instantanés standards pour un disque régional :

gcloud compute snapshots list --filter=sourceDisk:projects/PROJECT_ID/regions/SOURCE_REGION/disks/DISK_NAME

Remplacez les éléments suivants :

PROJECT_ID : ID du projet.
SOURCE_ZONE: (disques zonaux uniquement) nom de la zone pour le disque, par exemple, us-west1-a.
SOURCE_REGION: (disques régionaux uniquement) nom de la région pour le disque, par exemple, us-west1.
DISK_NAME : nom du disque, par exemple disk-1.

REST

Répertoriez les instantanés standards pour un disque zonal ou régional en envoyant une requête GET à la méthode snapshots.list.

Utilisez le paramètre de requête filter=sourceDisk pour spécifier le nom du disque.

Répertoriez les instantanés standards pour un disque zonal :

GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/snapshots?filter=sourceDisk:'https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/SOURCE_ZONE/disks/DISK_NAME'

Répertoriez les instantanés standards pour un disque régional :

GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/snapshots?filter=sourceDisk:'https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/SOURCE_REGION/disks/DISK_NAME'

Remplacez les éléments suivants :

PROJECT_ID : ID du projet.
SOURCE_ZONE: (disques zonaux uniquement) nom de la zone pour le disque, par exemple, us-west1-a.
SOURCE_REGION: (disques régionaux uniquement) nom de la région pour le disque, par exemple, us-west1.
DISK_NAME : nom du disque source, par exemple disk-1.

Afficher les informations sur un instantané standard

Récupérez des informations détaillées sur un instantané standard, telles que son heure de création, son disque source et sa taille, à l'aide de la console Google Cloud , de la Google Cloud CLI ou de REST.

Console

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

Accéder à la page Instantanés
Dans l'onglet Instantanés, affichez la liste des instantanés du projet.
Dans la colonne Nom, cliquez sur le nom de l'instantané standard. La page Détails de l'instantané de l'instantané sélectionné s'affiche, indiquant ses propriétés.

gcloud

Pour afficher des informations sur un instantané standard à portée globale, utilisez la commande gcloud compute snapshots describe.
```
gcloud compute snapshots describe SNAPSHOT_NAME
```
(Aperçu) Pour afficher des informations sur un instantané standard à portée régionale, utilisez la commande gcloud compute snapshots describe et spécifiez la région.
```
gcloud compute snapshots describe SNAPSHOT_NAME --regions=REGION_NAME
```

Remplacez les éléments suivants :

SNAPSHOT_NAME : nom de l'instantané standard.
REGION_NAME : nom de la région à laquelle votre instantané est associé.

REST

Pour afficher des informations sur un instantané standard à portée globale, envoyez une requête GET à la méthode snapshots.get.
```
GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/snapshots/SNAPSHOT_NAME
```
(Aperçu) Pour afficher des informations sur un instantané standard à portée régionale, envoyez une requête GET à la méthode snapshots.get et spécifiez la région.
```
GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_NAME/snapshots/SNAPSHOT_NAME
```

Remplacez les éléments suivants :

PROJECT_ID : nom du projet contenant l'instantané standard.
SNAPSHOT_NAME : nom de l'instantané standard.
REGION_NAME : nom de la région à laquelle votre instantané est associé.

Supprimer un instantané

Compute Engine utilise des instantanés incrémentiels qui ne contiennent que les données modifiées depuis l'instantané précédent. Les instantanés ultérieurs peuvent nécessiter des informations stockées dans un instantané précédent. Par conséquent, notez que la suppression d'un instantané ne supprime pas nécessairement toutes les données qu'il contient.

Pour en savoir plus sur la suppression des instantanés, consultez la page Suppression d'instantanés.

Console

Accédez à la page Instantanés dans la console Google Cloud .

Accéder à la page Instantanés
Sélectionnez un ou plusieurs instantanés que vous souhaitez supprimer.
En haut de la page Instantanés, cliquez sur Supprimer.

gcloud

Pour supprimer un instantané à portée globale, utilisez la commande gcloud compute snapshots delete.
```
gcloud compute snapshots delete SNAPSHOT_NAME
```
(Aperçu) Pour supprimer un instantané à portée régionale, utilisez la commande gcloud compute snapshots delete et spécifiez le nom de la région.
```
gcloud compute snapshots delete SNAPSHOT_NAME --regions=REGION_NAME
```

Remplacez les éléments suivants :

SNAPSHOT_NAME : nom de l'instantané que vous souhaitez supprimer.
REGION_NAME : région à laquelle l'instantané est associé.

Go

import (
	"context"
	"fmt"
	"io"

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

// deleteSnapshot deletes a snapshot of a disk.
func deleteSnapshot(w io.Writer, projectID, snapshotName string) error {
	// projectID := "your_project_id"
	// snapshotName := "your_snapshot_name"

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

	req := &computepb.DeleteSnapshotRequest{
		Project:  projectID,
		Snapshot: snapshotName,
	}

	op, err := snapshotsClient.Delete(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to delete 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 deleted\n")

	return nil
}

Java


import com.google.cloud.compute.v1.Operation;
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 DeleteSnapshot {

  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 snapshot to be deleted.
    String snapshotName = "YOUR_SNAPSHOT_NAME";

    deleteSnapshot(projectId, snapshotName);
  }

  // Delete a snapshot of a disk.
  public static void deleteSnapshot(String projectId, String snapshotName)
      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()) {

      Operation operation = snapshotsClient.deleteAsync(projectId, snapshotName)
          .get(3, TimeUnit.MINUTES);

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

      System.out.println("Snapshot deleted!");
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const snapshotName = 'YOUR_SNAPSHOT_NAME';

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

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

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

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

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

deleteSnapshot();

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 delete_snapshot(project_id: str, snapshot_name: str) -> None:
    """
    Delete a snapshot of a disk.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        snapshot_name: name of the snapshot to delete.
    """

    snapshot_client = compute_v1.SnapshotsClient()
    operation = snapshot_client.delete(project=project_id, snapshot=snapshot_name)

    wait_for_extended_operation(operation, "snapshot deletion")

REST

Pour supprimer un instantané à portée globale, envoyez une requête DELETE à la méthode snapshots.delete.
```
DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/snapshots/SNAPSHOT_NAME
```
(Aperçu) Pour supprimer un instantané à portée régionale, envoyez une requête DELETE à la méthode snapshots.delete et spécifiez la région.
```
DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_NAME/snapshots/SNAPSHOT_NAME
```

Remplacez les éléments suivants :

PROJECT_ID : le nom de votre projet
SNAPSHOT_NAME : nom de l'instantané à supprimer.
REGION_NAME : région à laquelle l'instantané est associé.

Supprimer plusieurs instantanés en fonction d'un filtre

Compute Engine utilise des instantanés incrémentiels qui ne contiennent que les données modifiées depuis l'instantané précédent. Étant donné que les instantanés suivants peuvent nécessiter des informations stockées dans un instantané précédent, la suppression d'un instantané ne supprime pas nécessairement toutes les données qu'il contient.

Pour en savoir plus sur la suppression des instantanés, consultez la page Suppression d'instantanés.

Vous pouvez supprimer un certain nombre d'instantanés en fonction d'un filtre donné. Pour en savoir plus sur l'utilisation des filtres avec gcloud CLI, consultez la page Filtres de sujets de gcloud CLI.

Pour supprimer les instantanés, utilisez une combinaison de la commande gcloud compute snapshots list avec un filtre donné, et de la commande gcloud compute snapshots delete avec xargs.

  gcloud compute snapshots list --filter="EXPRESSION" --uri |
  xargs gcloud compute snapshots delete

Remplacez EXPRESSION par un filtre de sujet gcloud CLI.

Par exemple, --filter="creationTimestamp<'2023-12-31'" supprime tous les instantanés créés avant le 31 décembre 2023.

Partager des données d'instantané entre des projets appartenant à la même organisation

Vous pouvez utiliser cette procédure pour déplacer des données d'un disque d'un projet vers un disque d'un autre projet au sein de la même organisation.

gcloud

Créez un instantané standard dans le projet de destination en utilisant la commande gcloud compute snapshots create. Par exemple, pour créer un instantané d'un disque Persistent Disk ou Hyperdisk zonal, exécutez la commande suivante:
```
gcloud compute snapshots create SNAPSHOT_NAME \
 --source-disk https://www.googleapis.com/compute/v1/projects/SOURCE_PROJECT_ID/zones/ZONE/disks/SOURCE_DISK_NAME \
 --project DESTINATION_PROJECT_ID
```
Remplacez les éléments suivants :
- SNAPSHOT_NAME: nom du nouvel instantané.
- SOURCE_PROJECT_ID: ID du projet pour le disque source.
- ZONE : zone du disque source.
- SOURCE_DISK_NAME : nom du disque source.
- DESTINATION_PROJECT_ID : ID du projet de destination pour le nouvel instantané.
Dans le projet de destination, créez un disque zonal ou régional basé sur l'instantané en utilisant la commande gcloud compute disks create :
```
gcloud compute disks create DISK_NAME \
 --source-snapshot SNAPSHOT_NAME \
 --project DESTINATION_PROJECT_ID
```
Remplacez les éléments suivants :
- DISK_NAME : nom du nouveau disque.
- SNAPSHOT_NAME : nom de l'instantané.
- DESTINATION_PROJECT_ID : ID du projet de destination pour le nouveau disque.

REST

Créez un instantané standard dans le projet de destination en appelant la méthode snapshots.insert. Par exemple, pour prendre un instantané d'un disque Persistent Disk ou Hyperdisk zonal, exécutez la requête suivante:
```
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
}
```
Remplacez les éléments suivants :
- DESTINATION_PROJECT_ID : ID du projet de destination pour le nouvel 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 source.
Dans le projet de destination, créez un disque zonal ou régional basé sur l'instantané en utilisant la méthode zonale disks.insert ou la méthode régionale regionDisks.insert.

Par exemple, pour créer un disque zonal, envoyez la requête suivante :
```
POST https://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/zones/DESTINATION_ZONE/disks
{
 "name": DISK_NAME
 "sourceSnapshot": SNAPSHOT_NAME
}
```
Remplacez les éléments suivants :
- DESTINATION_PROJECT_ID : ID du projet de destination pour le nouveau disque.
- DESTINATION_ZONE: zone du projet de destination pour le nouveau disque.
- DISK_NAME : nom du nouveau disque.
- SNAPSHOT_NAME : nom de l'instantané.

Pour obtenir la liste des instantanés disponibles, consultez la section Afficher les instantanés standards dans un projet ou un emplacement.

Partager un instantané entre des projets de différentes organisations

Vous pouvez utiliser cette procédure pour partager un instantané standard dans un projet d'une organisation avec un autre projet dans une autre organisation.

gcloud

Dans le projet source, créez un disque basé sur l'instantané à l'aide de la commande gcloud compute disks create.
```
gcloud compute disks create DISK_NAME \
 --source-snapshot SNAPSHOT_NAME \
 --project SOURCE_PROJECT_ID \
 --zone ZONE
```
Remplacez les éléments suivants :
- DISK_NAME : nom du nouveau disque.
- SNAPSHOT_NAME : nom de l'instantané.
- SOURCE_PROJECT_ID: ID du projet source.
- ZONE : zone dans laquelle créer le disque.
Ce disque est un disque temporaire qui n'est créé que pour copier l'instantané sur plusieurs organisations.
Dans le projet de destination, créez un instantané à l'aide de la commande gcloud compute snapshots create.

Par exemple, pour créer un instantané à l'aide du disque zonal créé à la première étape, exécutez la commande suivante:
```
gcloud compute snapshots create SNAPSHOT_NAME \
 --source-disk https://www.googleapis.com/compute/v1/projects/SOURCE_PROJECT_ID/zones/ZONE/disks/DISK_NAME \
 --project DESTINATION_PROJECT_ID
```
Remplacez les éléments suivants :
- SNAPSHOT_NAME : nom de l'instantané.
- SOURCE_PROJECT_ID: ID du projet contenant le disque source.
- ZONE : zone du disque source.
- DISK_NAME: nom du disque créé à l'étape 1.
- DESTINATION_PROJECT_ID : ID du projet de destination pour le nouvel instantané.
Pour obtenir la liste des instantanés disponibles, consultez la section Afficher les instantanés standards dans un projet ou un emplacement.
Supprimez le disque temporaire créé à la première étape à l'aide de la commande gcloud compute disks delete.
```
gcloud compute disks delete DISK_NAME \
 --project SOURCE_PROJECT_ID --zone ZONE
```
Remplacez les éléments suivants :
- DISK_NAME: nom du disque créé à l'étape 1.
- SOURCE_PROJECT_ID: ID du projet contenant le disque source.
- ZONE : zone du disque.

REST

Dans le projet source, créez un disque zonal ou régional basé sur l'instantané à l'aide de la méthode disks.insert zonal.

Par exemple, pour créer un disque zonal, envoyez la requête suivante :
```
POST https://compute.googleapis.com/compute/v1/projects/SOURCE_PROJECT_ID/zones/SOURCE_ZONE/disks
{
 "name": DISK_NAME
 "sourceSnapshot": SNAPSHOT_NAME
}
```
Remplacez les éléments suivants :
- SOURCE_PROJECT_ID : ID du projet source pour le nouveau disque.
- SOURCE_ZONE: zone du nouveau disque.
- DISK_NAME : nom du nouveau disque.
- SNAPSHOT_NAME : nom de l'instantané.
Ce disque est un disque temporaire qui n'est créé que pour copier l'instantané sur plusieurs organisations.
Créez un instantané dans le projet de destination en appelant la méthode snapshots.insert.

Par exemple, pour créer un instantané à l'aide du disque zonal créé à la première étape, exécutez la commande suivante:
```
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/DISK_NAME
}
```
Remplacez les éléments suivants :
- DESTINATION_PROJECT_ID : ID du projet de destination pour le nouvel instantané.
- SNAPSHOT_NAME : nom de l'instantané.
- SOURCE_PROJECT_ID: ID du projet contenant le disque source.
- SOURCE_ZONE : zone du disque source.
- DISK_NAME : nom du disque source.
Supprimez le disque temporaire créé à la première étape à l'aide de la méthode disks.delete.
```
DELETE https://compute.googleapis.com/compute/v1/projects/SOURCE_PROJECT_ID/zones/SOURCE_ZONE/disks/DISK_NAME
```
Remplacez les éléments suivants :
- SOURCE_PROJECT_ID: ID du projet contenant le disque temporaire.
- SOURCE_ZONE : zone du disque.
- DISK_NAME: nom du disque temporaire créé à l'étape 1.

Étapes suivantes

Découvrez comment créer des instantanés programmés pour des disques.
Apprenez à créer une image disque à partir de votre instantané.