Crea e gestisci snapshot di disco

---

Crea snapshot per eseguire periodicamente il backup dei dati da:

• Dischi permanenti a livello di zona.
• Dischi permanenti a livello di area geografica.
• Dischi esterni Hyperdisk.

Puoi creare snapshot dai dischi anche quando sono collegati a istanze in esecuzione. Gli snapshot sono risorse globali, quindi puoi utilizzarli per ripristinare i dati su un nuovo disco o istanza all'interno dello stesso progetto. Puoi anche condividere snapshot tra progetti.

Prima di iniziare

• Se vuoi utilizzare gli esempi a riga di comando in questa guida:
  1. Installa o aggiorna la versione più recente di Google Cloud CLI.
  2. Imposta una regione e una zona predefinite.
• Se vuoi utilizzare gli esempi di API in questa guida, configura l'accesso all'API.

Preparati a creare gli snapshot

Per prepararti alla creazione di snapshot di dischi permanenti o iperdisk, segui questi passaggi:

• Consulta le best practice per gli snapshot del disco di Compute Engine per preparare il tuo disco per lo snapshot.

• Consulta la pagina relativa alla creazione di una pianificazione di snapshot di dischi permanenti per scoprire come creare una pianificazione di snapshot e collegarla ai tuoi dischi. Il backup regolare dei dischi con snapshot pianificati può ridurre il rischio di perdita di dati imprevista.

Importante: se metti in pausa le applicazioni prima di creare uno snapshot, ripristina i carichi di lavoro solo dopo che la risorsa snapshot ha raggiunto lo stato UPLOADING. Per ulteriori informazioni, consulta la tabella in Creazione manuale di snapshot coerenti con l'applicazione.

Crea uno snapshot di un disco permanente

Le istruzioni per la creazione di snapshot di dischi permanenti sono diverse, a seconda che tu stia creando uno snapshot di un disco permanente a livello di zona o di un disco permanente a livello di regione.

Crea uno snapshot di un disco permanente a livello di zona

Autorizzazioni richieste per questa attività

Per eseguire questa attività, devi disporre delle seguenti autorizzazioni:

• compute.snapshots.create nel progetto
• compute.disks.createSnapshot sul disco

Console

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai alle istanze VM
   I passaggi rimanenti verranno visualizzati automaticamente nella console Google Cloud.

2. Seleziona il progetto che contiene le istanze VM.
3. Nella colonna Nome, fai clic sul nome della VM con il disco permanente di cui vuoi eseguire il backup.
4. In Spazio di archiviazione:
   • Per eseguire il backup del disco di avvio, fai clic sul nome del disco di avvio nella sezione Disco di avvio.
   • Per eseguire il backup di un disco permanente collegato, fai clic sul nome del disco permanente collegato in Dischi aggiuntivi.
5. Fai clic su Crea snapshot.
6. In Nome, inserisci un nome univoco per identificare lo scopo dello snapshot, ad esempio:
   • boot-disk-snapshot
   • attached-persistent-disk-snapshot
7. In Tipo, l'impostazione predefinita è uno snapshot normale, ideale per il backup a lungo termine e il ripristino di emergenza.

   Scegli Archiviazione snapshot per una conservazione dei dati più conveniente.

8. In Località, il valore predefinito è Più aree geografiche, che offre una disponibilità più elevata a un costo superiore.

   Scegli gli snapshot regionali per un maggiore controllo sulla località fisica dei dati a un costo inferiore.

9. Per creare uno snapshot manuale, fai clic su Crea.

gcloud

Crea lo snapshot nella località di archiviazione predefinita o in una posizione di archiviazione selezionata. Devi specificare un nome di snapshot. Il nome deve contenere da 1 a 63 caratteri e deve essere conforme alla specifica RFC 1035.

• Per creare uno snapshot di un disco permanente nella località di archiviazione predefinita, utilizza il comando gcloud compute snapshots create.

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

• In alternativa, per creare uno snapshot in una località di archiviazione personalizzata, utilizza il flag --storage-location per indicare dove archiviare lo snapshot:

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

  Sostituisci quanto segue:

  • SNAPSHOT_NAME: nome dello snapshot.
  • SOURCE_DISK: il nome del disco permanente da cui vuoi creare uno snapshot.
  • SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVIA. Se non viene specificato un tipo di snapshot, viene creato uno snapshot STANDARD. Scegli Archivia per una conservazione dei dati più conveniente.
  • SOURCE_DISK_ZONE: la zona del disco permanente da cui vuoi creare uno snapshot.
  • STORAGE_LOCATION: per le località di archiviazione personalizzate, è la più aree geografiche Cloud Storage o la regione di Cloud Storage in cui vuoi archiviare lo snapshot. Puoi specificare una sola località di archiviazione.

L'interfaccia a riga di comando gcloud attende che l'operazione restituisca uno stato di READY o FAILED oppure raggiunga il timeout massimo e restituisce gli ultimi dettagli noti dello snapshot.

Nota: Google consiglia di utilizzare il comando gcloud compute snapshots create anziché il comando gcloud compute disks snapshot, perché supporta più funzionalità, ad esempio la creazione di snapshot in un progetto diverso da quello del disco di origine.

Terraform

Per creare uno snapshot del disco permanente a livello di zona, utilizza la risorsa google_compute_snapshot.

compute/disk/main.tf

Visualizza su GitHub Feedback

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

Per scoprire come applicare o rimuovere una configurazione Terraform, vedi Comandi Terraform di base.

API

Crea lo snapshot nella località di archiviazione predefinita o in una posizione di archiviazione selezionata.

• Per creare lo snapshot nella località di archiviazione predefinita, invia una richiesta POST al metodo 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
  }
  

  Sostituisci quanto segue:

  • DESTINATION_PROJECT_ID: l'ID del progetto in cui vuoi creare lo snapshot.
  • SNAPSHOT_NAME: nome dello snapshot.
  • SOURCE_PROJECT_ID: l'ID del progetto del disco di origine.
  • SOURCE_ZONE: la zona del disco di origine.
  • SOURCE_DISK_NAME: il nome del disco permanente da cui vuoi creare uno snapshot.
  • SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVIA. Se non viene specificato un tipo di snapshot, viene creato uno snapshot STANDARD.

• In alternativa, per creare uno snapshot in una località di archiviazione personalizzata, invia una richiesta POST al metodo snapshots.insert e specifica la località di archiviazione:

  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
  }
  

  Sostituisci quanto segue:

  • DESTINATION_PROJECT_ID: l'ID del progetto in cui vuoi creare lo snapshot.
  • SNAPSHOT_NAME: nome dello snapshot.
  • SOURCE_PROJECT_ID: l'ID del progetto del disco di origine.
  • SOURCE_ZONE: la zona del disco di origine.
  • SOURCE_DISK_NAME: il nome del disco permanente da cui vuoi creare uno snapshot.
  • SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVIA. Se non viene specificato un tipo di snapshot, viene creato uno snapshot STANDARD.
  • STORAGE_LOCATION: la regione di Cloud Storage o la regione di Cloud Storage in cui vuoi archiviare lo snapshot. Puoi specificare una sola località di archiviazione.

Nota: Google consiglia di utilizzare il metodo snapshots.insert invece del metodo disks.createSnapshot, perché supporta altre funzionalità, come la creazione di snapshot in un progetto diverso da quello del disco di origine.

Go

Go

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nella guida rapida di Compute Engine mediante librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Go di Compute Engine.

Visualizza su GitHub Feedback

import (
	"context"
	"fmt"
	"io"

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

// 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: %v", 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: %v", 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 create disk: %v", err)
		}
	} else {
		regionDisksClient, err := compute.NewRegionDisksRESTClient(ctx)
		if err != nil {
			return fmt.Errorf("NewRegionDisksRESTClient: %v", 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 create disk: %v", 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: %v", err)
	}

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

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

	return nil
}

Java

Java

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nella guida rapida di Compute Engine mediante librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java di Compute Engine.

Visualizza su GitHub Feedback

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

Node.js

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nella guida rapida di Compute Engine mediante librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Node.js di Compute Engine.

Visualizza su GitHub Feedback

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

Python

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nella guida rapida di Compute Engine mediante librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Python di Compute Engine.

Visualizza su GitHub Feedback

import sys
from typing import Any, Optional

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: Optional[str] = None,
    region: Optional[str] = None,
    location: Optional[str] = None,
    disk_project_id: Optional[str] = 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)

Attenzione: se tenti di creare uno snapshot da un disco permanente a livello di zona e il processo di snapshot non riesce, non potrai eliminare il disco permanente a livello di zona originale finché non avrai rimosso lo snapshot non riuscito. Questa operazione contribuisce a impedire l'eliminazione accidentale dei dati di origine in caso di backup non riuscito.

Crea uno snapshot di un disco permanente a livello di regione

Autorizzazioni richieste per questa attività

Per eseguire questa attività, devi disporre delle seguenti autorizzazioni:

• compute.snapshots.create nel progetto
• compute.instances.useReadOnly sull'istanza di origine
• compute.disks.createSnapshot sul disco

Dopo aver preparato il disco, puoi creare uno snapshot. Quando crei uno snapshot di un disco permanente a livello di regione, devi indicare la regione in cui si trova il disco.

Console

1. Vai alla pagina Crea uno snapshot nella console Google Cloud.
   Vai alla pagina Crea uno snapshot
2. Inserisci un Nome snapshot.

3. Seleziona un tipo di snapshot. L'impostazione predefinita è uno snapshot normale, ideale per il backup a lungo termine e il ripristino di emergenza.

   Scegli Archiviazione snapshot per una conservazione dei dati più conveniente.

4. Se vuoi, inserisci una descrizione dello snapshot.

5. In Disco di origine, seleziona un disco esistente da cui vuoi creare uno snapshot.

6. Facoltativamente, puoi specificare una località dello spazio di archiviazione personalizzato:

   1. In Località, scegli se vuoi archiviare lo snapshot in una località Più aree geografiche o A livello di area geografica.
   2. Seleziona la regione specifica o le regioni che vuoi utilizzare. Per utilizzare l'area geografica o più aree geografiche più vicina al disco di origine, seleziona In base alla posizione del disco.

7. Fai clic su Crea per creare lo snapshot.

gcloud

Crea lo snapshot nella località di archiviazione predefinita o in una posizione di archiviazione selezionata.

• Per creare uno snapshot di un disco permanente a livello di regione nella località di archiviazione predefinita, utilizza il comando gcloud compute snapshots create.

  gcloud compute snapshots create SNAPSHOT_NAME \
      --source-disk SOURCE_DISK \
      --source-disk-region=SOURCE_DISK_REGION
  

  Sostituisci quanto segue:

  • SNAPSHOT_NAME: nome dello snapshot.
  • SOURCE_DISK: il nome del disco permanente da cui vuoi creare uno snapshot.
  • SOURCE_DISK_REGION: la regione del disco permanente a livello di regione da cui vuoi creare uno snapshot.

• Facoltativamente, puoi specificare una posizione di archiviazione personalizzata.

  gcloud compute snapshots create SNAPSHOT_NAME \
      --source-disk SOURCE_DISK \
      --source-disk-region=SOURCE_DISK_REGION
      --storage-location STORAGE_LOCATION \
      --snapshot-type SNAPSHOT_TYPE
  

  Sostituisci quanto segue:

  • SNAPSHOT_NAME: nome dello snapshot.
  • SOURCE_DISK: il nome del disco permanente da cui vuoi creare uno snapshot.
  • SOURCE_DISK_REGION: la regione del disco permanente a livello di regione da cui vuoi creare uno snapshot.
  • STORAGE_LOCATION: la regione di Cloud Storage o la regione di Cloud Storage in cui vuoi archiviare lo snapshot. Puoi specificare una sola località di archiviazione.
  • SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVIA. Se non viene specificato un tipo di snapshot, viene creato uno snapshot STANDARD.

  Google Cloud CLI attende che l'operazione restituisca uno stato di READY, FAILED o raggiunga il timeout massimo e restituisce gli ultimi dettagli noti dello snapshot.

Terraform

Il provider Terraform per Google Cloud non supporta la creazione di uno snapshot di un disco permanente a livello di regione. Per monitorare questo limite, consulta il problema su GitHub.

API

• Per creare uno snapshot nella posizione di archiviazione predefinita, invia una richiesta POST al metodo snapshots.insert:

  POST https://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/global/snapshots
  {
    "name": SNAPSHOT_NAME
    "sourceDisk": "projects/SOURCE_PROJECT_ID/regions/SOURCE_REGION/disks/SOURCE_DISK_NAME
    "snapshotType": SNAPSHOT_TYPE
  }
  

  Sostituisci quanto segue:

  • DESTINATION_PROJECT_ID: l'ID del progetto in cui vuoi creare lo snapshot.
  • SNAPSHOT_NAME: nome dello snapshot.
  • SOURCE_PROJECT_ID: l'ID del progetto del disco di origine.
  • SOURCE_REGION: la regione del disco di origine.
  • SOURCE_DISK_NAME: il nome del disco permanente da cui vuoi creare uno snapshot.
  • SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVIA. Se non viene specificato un tipo di snapshot, viene creato uno snapshot STANDARD.

• In alternativa, per creare uno snapshot in una località di archiviazione personalizzata, invia una richiesta POST al metodo snapshots.insert e specifica la località di archiviazione:

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

  Sostituisci quanto segue:

  • DESTINATION_PROJECT_ID: l'ID del progetto in cui vuoi creare lo snapshot.
  • SNAPSHOT_NAME: nome dello snapshot.
  • SOURCE_PROJECT_ID: l'ID del progetto del disco di origine.
  • SOURCE_REGION: la regione del disco di origine.
  • SOURCE_DISK_NAME: il nome del disco permanente da cui vuoi creare uno snapshot.
  • STORAGE_LOCATION: la regione di Cloud Storage o la regione di Cloud Storage in cui vuoi archiviare lo snapshot. Puoi specificare una sola località di archiviazione.
  • SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVIA. Se non viene specificato un tipo di snapshot, viene creato uno snapshot STANDARD.

Nota: Google consiglia di utilizzare il metodo snapshots.insert invece del metodo disks.createSnapshot, perché supporta altre funzionalità, come la creazione di snapshot in un progetto diverso da quello del disco di origine.

Go

Go

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nella guida rapida di Compute Engine mediante librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Go di Compute Engine.

Visualizza su GitHub Feedback

import (
	"context"
	"fmt"
	"io"

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

// 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: %v", 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: %v", 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 create disk: %v", err)
		}
	} else {
		regionDisksClient, err := compute.NewRegionDisksRESTClient(ctx)
		if err != nil {
			return fmt.Errorf("NewRegionDisksRESTClient: %v", 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 create disk: %v", 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: %v", err)
	}

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

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

	return nil
}

Java

Java

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nella guida rapida di Compute Engine mediante librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java di Compute Engine.

Visualizza su GitHub Feedback

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

Node.js

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nella guida rapida di Compute Engine mediante librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Node.js di Compute Engine.

Visualizza su GitHub Feedback

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

Python

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nella guida rapida di Compute Engine mediante librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Python di Compute Engine.

Visualizza su GitHub Feedback

import sys
from typing import Any, Optional

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: Optional[str] = None,
    region: Optional[str] = None,
    location: Optional[str] = None,
    disk_project_id: Optional[str] = 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)

Attenzione: se tenti di creare uno snapshot da un disco permanente a livello di regione e il processo di snapshot non riesce, non potrai eliminare il disco permanente originale a livello di area geografica finché non acquisisci uno snapshot pulito. Questo failover impedisce l'eliminazione accidentale dei dati di origine in caso di backup non riuscito.

Creazione di uno snapshot di un Hyperdisk

Autorizzazioni richieste per questa attività

Per eseguire questa attività, devi disporre delle seguenti autorizzazioni:

• compute.snapshots.create nel progetto
• compute.disks.createSnapshot sul disco

Puoi creare lo snapshot nella località di archiviazione predefinita o in una posizione di archiviazione selezionata. Devi specificare un nome di snapshot. Il nome deve contenere da 1 a 63 caratteri e deve essere conforme alla specifica RFC 1035.

Console

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai a Istanze VM

2. Seleziona il progetto che contiene le istanze VM.

3. Nella colonna Nome, fai clic sul nome della VM di cui vuoi eseguire il backup dell'Hyperdisk.

4. In Archiviazione, in Dischi aggiuntivi, fai clic su Nome dell'Hyperdisk collegato.

5. Fai clic su Crea snapshot.

6. In Nome, inserisci un nome univoco per identificare lo scopo dell'istantanea, ad esempio hyperdisk-data-snapshot.

7. In Tipo, l'impostazione predefinita è uno snapshot normale, ideale per il backup a lungo termine e il ripristino di emergenza.

1. In Località, il valore predefinito è Più aree geografiche, che offre maggiore disponibilità a un costo superiore. Scegli gli snapshot regionali per maggiore controllo sulla località fisica dei dati a un costo inferiore.

2. Fai clic su Crea.

gcloud

• Per creare uno snapshot di un Hyperdisk nella posizione di archiviazione predefinita, utilizza il comando gcloud compute snapshots create.

• Per creare uno snapshot in una località di archiviazione personalizzata, includi il flag --storage-location per indicare dove archiviare lo snapshot:

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

  Sostituisci quanto segue:

  • SNAPSHOT_NAME: nome dello snapshot.
  • SOURCE_DISK: il nome dell'Hyperdisk da cui vuoi creare lo snapshot.
  • SOURCE_DISK_ZONE: la zona dell'Hyperdisk da cui vuoi creare uno snapshot.
  • STORAGE_LOCATION: facoltativo. La regione di Cloud Storage o la regione di Cloud Storage in cui vuoi archiviare lo snapshot. Puoi specificare una sola località di archiviazione.
  • SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVIA. Se non viene specificato un tipo di snapshot, viene creato uno snapshot STANDARD. Scegli gli snapshot archivio per una conservazione dei dati più conveniente.

L'interfaccia a riga di comando gcloud attende che l'operazione restituisca uno stato di READY o FAILED oppure raggiunga il timeout massimo e restituisce gli ultimi dettagli noti dello snapshot.

Nota: Google consiglia di utilizzare il comando gcloud compute snapshots create anziché il comando gcloud compute disks snapshot, perché supporta più funzionalità, ad esempio la creazione di snapshot in un progetto diverso da quello del disco di origine.

API

• Per creare lo snapshot nella località di archiviazione predefinita, invia una richiesta POST al metodo snapshots.insert.

• Per creare uno snapshot in una località di archiviazione personalizzata, includi la proprietà storageLocations nella richiesta.

  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
  }
  

  Sostituisci quanto segue:

  • DESTINATION_PROJECT_ID: l'ID del progetto in cui vuoi creare lo snapshot.
  • SNAPSHOT_NAME: nome dello snapshot.
  • SOURCE_PROJECT_ID: l'ID del progetto del disco di origine.
  • SOURCE_ZONE: la zona del disco di origine.
  • SOURCE_DISK_NAME: il nome dell'Hyperdisk da cui vuoi creare uno snapshot.
  • SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVIA. Se non viene specificato un tipo di snapshot, viene creato uno snapshot STANDARD. Scegli gli snapshot archivio per una conservazione dei dati più conveniente.
  • STORAGE_LOCATION: facoltativo. La regione di Cloud Storage o la regione di Cloud Storage in cui vuoi archiviare lo snapshot. Puoi specificare una sola località di archiviazione.

Nota: Google consiglia di utilizzare il metodo snapshots.insert invece del metodo disks.createSnapshot, perché supporta più funzionalità, ad esempio la creazione di snapshot in un progetto diverso da quello del disco di origine.

Attenzione: se tenti di creare uno snapshot da un Hyperdisk e il processo di creazione dello snapshot non riesce, non potrai eliminare l'Hyperdisk originale finché non avrai rimosso lo snapshot non riuscito. Questa operazione contribuisce a impedire l'eliminazione accidentale dei dati di origine in caso di backup non riuscito.

Elimina uno snapshot

Compute Engine utilizza snapshot differenziali in modo che ogni snapshot contenga solo i dati che sono stati modificati rispetto allo snapshot precedente. Poiché gli snapshot successivi potrebbero richiedere informazioni archiviate in uno snapshot precedente, tieni presente che l'eliminazione di uno snapshot non comporta l'eliminazione di tutti i dati contenuti nello snapshot. Per scoprire di più sull'eliminazione degli snapshot, consulta la sezione Eliminazione di snapshot.

Autorizzazioni richieste per questa attività

Per eseguire questa attività, devi disporre delle seguenti autorizzazioni:

• compute.snapshots.delete sullo snapshot

Per eliminare uno snapshot:

Console

1. Vai alla pagina Snapshots nella console Google Cloud.

   Vai alla pagina Snapshot

2. Seleziona uno o più snapshot da eliminare.
3. Nella parte superiore della pagina Snapshot, fai clic su Elimina.

gcloud

Per eliminare uno snapshot, utilizza il comando gcloud compute snapshots delete:

gcloud compute snapshots delete SNAPSHOT_NAME

dove SNAPSHOT_NAME è il nome dello snapshot che viene eliminato.

API

Esegui una richiesta DELETE al metodo compute.snapshots.delete per eliminare gli snapshot.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/snapshots/SNAPSHOT_NAME

dove:

• PROJECT_ID è il nome del tuo progetto.
• SNAPSHOT_NAME è il nome dello snapshot da eliminare.

Go

compute/snapshots/delete_snapshot.go

Visualizza su GitHub Feedback

import (
	"context"
	"fmt"
	"io"

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

// 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: %v", 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: %v", err)
	}

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

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

	return nil
}

Java

compute/cloud-client/src/main/java/compute/disks/DeleteSnapshot.java

Visualizza su GitHub Feedback

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

compute/snapshots/deleteSnapshot.js

Visualizza su GitHub Feedback

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

compute/client_library/snippets/snapshots/delete.py

Visualizza su GitHub Feedback

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")

Eliminare più snapshot in base a un filtro

Compute Engine utilizza snapshot differenziali in modo che ogni snapshot contenga solo i dati che sono stati modificati rispetto allo snapshot precedente. Poiché gli snapshot successivi potrebbero richiedere informazioni archiviate in uno snapshot precedente, l'eliminazione di uno snapshot non comporta necessariamente l'eliminazione di tutti i dati contenuti nello snapshot. Per scoprire di più sull'eliminazione degli snapshot, consulta la sezione Eliminazione di snapshot.

Le seguenti sezioni descrivono come eliminare un certo numero di snapshot in base a un determinato filtro. Per maggiori informazioni sui filtri dell'interfaccia a riga di comando gcloud, consulta Filtri dell'argomento dell'interfaccia a riga di comando gcloud.

Autorizzazioni richieste per questa attività

Per eseguire questa attività, devi disporre delle seguenti autorizzazioni:

• compute.snapshots.delete sullo snapshot

Per eliminare gli snapshot, utilizza una combinazione del comando gcloud compute snapshots list con un determinato filtro e del comando gcloud compute snapshots delete con xargs:

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

Sostituisci EXPRESSION con un filtro argomento gcloud.

Ad esempio, --filter="creationTimestamp>'2021-01-01'" elimina tutti gli snapshot creati dopo il giorno 1/01/2021.

Elenco snapshot

Autorizzazioni richieste per questa attività

Per eseguire questa attività, devi disporre delle seguenti autorizzazioni:

• compute.snapshots.list nel progetto

gcloud

Per visualizzare un elenco degli snapshot disponibili in un determinato progetto, utilizza il comando gcloud compute snapshots list.

gcloud compute snapshots list --project PROJECT_ID

dove PROJECT_ID è l'ID del progetto.

API

Per visualizzare un elenco di snapshot disponibili in un determinato progetto, effettua una richiesta GET al metodo snapshots.list:

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

dove PROJECT_ID è l'ID del progetto.

Visualizza le informazioni su uno snapshot

Per elencare le informazioni relative a uno snapshot specifico, ad esempio ora di creazione, dimensioni e disco di origine, utilizza il comando gcloud compute snapshots describe:

gcloud compute snapshots describe SNAPSHOT_NAME

dove SNAPSHOT_NAME è il nome dello snapshot.

Condividere dati snapshot tra progetti nella stessa organizzazione

Autorizzazioni richieste per questa attività

Per eseguire questa attività, devi disporre delle seguenti autorizzazioni:

• compute.storageAdmin nel progetto se hai bisogno di accedere a tutti gli snapshot nel progetto
• compute.snapshots.create nel progetto di destinazione
• compute.disks.createSnapshot sul disco di origine

Per spostare i dati da un disco in un progetto a un disco in un progetto diverso all'interno della stessa organizzazione:

gcloud

1. Crea uno snapshot del disco nel progetto di destinazione utilizzando il comando gcloud compute snapshots create. Ad esempio, per creare uno snapshot di un disco permanente a livello di zona, utilizza il comando seguente:

   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
   

   Sostituisci quanto segue:

   • SNAPSHOT_NAME: nome dello snapshot.
   • SOURCE_PROJECT_ID: l'ID del progetto del disco di origine.
   • ZONE: la zona del disco di origine.
   • SOURCE_DISK_NAME: il nome del disco di origine.
   • DESTINATION_PROJECT_ID: l'ID del progetto di destinazione per il nuovo snapshot.

2. Nel progetto di destinazione, crea un disco permanente a livello di zona o di regione oppure un Hyperdisk basato sullo snapshot utilizzando il comando gcloud compute disks create:

   gcloud compute disks create DISK_NAME \
       --source-snapshot SNAPSHOT_NAME \
       --project DESTINATION_PROJECT_ID
   

   Sostituisci quanto segue:

   • DISK_NAME: un nome per il nuovo disco.
   • SNAPSHOT_NAME: il nome dello snapshot.
   • DESTINATION_PROJECT_ID: l'ID del progetto di destinazione per il nuovo disco.

API

1. Crea uno snapshot del disco nel progetto di destinazione chiamando il metodo snapshots.insert. Ad esempio, per acquisire uno snapshot di un disco permanente a livello di zona, effettua la seguente richiesta:

   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
   }
   

   Sostituisci quanto segue:

   • DESTINATION_PROJECT_ID: l'ID del progetto di destinazione per il nuovo snapshot.
   • SNAPSHOT_NAME: nome dello snapshot.
   • SOURCE_PROJECT_ID: l'ID del progetto del disco di origine.
   • SOURCE_ZONE: la zona del disco di origine.
   • SOURCE_DISK_NAME: il nome del disco di origine.

2. Nel progetto di destinazione, crea un disco permanente a livello di zona o di regione oppure un Hyperdisk basato sullo snapshot utilizzando il metodo disks.insert di zona o il metodo regionDisks.insert a livello di regione. Ad esempio, per creare un disco di zona, effettua la seguente richiesta:

   POST https://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/zones/DESTINATION_ZONE/disks
   {
     "name": DISK_NAME
     "sourceSnapshot": SNAPSHOT_NAME
   }
   

   Sostituisci quanto segue:

   • DESTINATION_PROJECT_ID: l'ID del progetto di destinazione per il nuovo disco.
   • DISK_NAME: un nome per il nuovo disco.
   • SNAPSHOT_NAME: il nome dello snapshot.

Per visualizzare un elenco degli snapshot disponibili, consulta la sezione Istantanea elenco.

Condividere uno snapshot tra progetti in organizzazioni diverse

Autorizzazioni richieste per questa attività

Per eseguire questa attività, devi disporre delle seguenti autorizzazioni:

• compute.storageAdmin nel progetto se hai bisogno di accedere a tutti gli snapshot nel progetto
• compute.snapshots.create nel progetto di destinazione
• compute.disks.createSnapshot sul disco di origine

Per condividere uno snapshot da un progetto in un'organizzazione a un altro progetto in un'altra organizzazione, utilizza la seguente procedura:

gcloud

1. Nel progetto di origine, crea un disco basato sullo snapshot utilizzando il comando gcloud compute disks create:

    gcloud compute disks create DISK_NAME \
       --source-snapshot SNAPSHOT_NAME \
       --project SOURCE_PROJECT_ID \ --zone ZONE
   

   Sostituisci quanto segue:

   • DISK_NAME: un nome per il nuovo disco.
   • SNAPSHOT_NAME: il nome dello snapshot.
   • SOURCE_PROJECT_ID: l'ID del progetto di origine.
   • ZONE: zona in cui verrà creato il nuovo disco.

   Questo disco è un disco temporaneo creato solo per copiare lo snapshot tra le organizzazioni. Puoi eliminare questo disco al termine della copia dello snapshot.

2. Nel progetto di destinazione, crea uno snapshot utilizzando il comando gcloud compute snapshots create. Ad esempio, per creare uno snapshot utilizzando il disco di zona creato nel passaggio 1, utilizza il comando seguente:

   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
   

   Sostituisci quanto segue:

   • SNAPSHOT_NAME: nome dello snapshot.
   • SOURCE_PROJECT_ID: l'ID del progetto che contiene il disco di origine.
   • ZONE: la zona del disco di origine.
   • SOURCE_DISK_NAME: il nome del disco creato nel passaggio 1.
   • DESTINATION_PROJECT_ID: l'ID del progetto di destinazione per il nuovo snapshot.

   Per visualizzare un elenco degli snapshot disponibili, consulta la sezione Istantanea elenco.

3. Elimina il disco temporaneo creato nel passaggio 1 utilizzando il comando gcloud compute disks delete.

API

1. Nel progetto di origine, crea un disco a livello di zona o di regione in base allo snapshot utilizzando il metodo disks.insert di zona. Ad esempio, per creare un disco di zona, effettua la seguente richiesta:

   POST https://compute.googleapis.com/compute/v1/projects/SOURCE_PROJECT_ID/zones/ZONE/disks
   {
     "name": DISK_NAME
     "sourceSnapshot": SNAPSHOT_NAME
   }
   

   Sostituisci quanto segue:

   • SOURCE_PROJECT_ID: l'ID del progetto di origine per il nuovo disco.
   • ZONE: zona per il nuovo disco.
   • DISK_NAME: un nome per il nuovo disco.
   • SNAPSHOT_NAME: il nome dello snapshot.

   Questo disco è un disco temporaneo creato solo per copiare lo snapshot tra le organizzazioni.

2. Crea uno snapshot nel progetto di destinazione chiamando il metodo snapshots.insert. Ad esempio, per acquisire uno snapshot di un disco permanente a livello di zona, effettua la seguente richiesta:

   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
   }
   

   Sostituisci quanto segue:

   • DESTINATION_PROJECT_ID: l'ID del progetto di destinazione per il nuovo snapshot.
   • SNAPSHOT_NAME: nome dello snapshot.
   • SOURCE_PROJECT_ID: l'ID del progetto che contiene il disco di origine.
   • SOURCE_ZONE: la zona del disco di origine.
   • SOURCE_DISK_NAME: il nome del disco di origine.

3. Elimina il disco temporaneo creato nel passaggio 1 utilizzando il metodo disks.delete.

Passaggi successivi

• Scopri come creare una pianificazione di snapshot per i dischi permanenti.
• Scopri come creare un'immagine disco dal tuo snapshot.