Crea snapshot del disco standard e di archiviazione

Crea snapshot standard per eseguire periodicamente il backup dei dati da questi tipi di dischi:

Volumi Persistent Disk a livello di zona
Volumi Persistent Disk a livello di regione
Volumi Google Cloud Hyperdisk

Puoi creare snapshot dai dischi anche quando sono collegati a istanze in esecuzione. Per impostazione predefinita, gli snapshot sono risorse globali, quindi puoi utilizzarli per ripristinare i dati su un nuovo disco o una nuova VM all'interno dello stesso progetto. Per una maggiore protezione dei dati e gestione dei costi, puoi stabilire dove utilizzare gli snapshot per creare nuovi dischi. Per limitare le regioni in cui gli snapshot possono recuperare i dati, puoi creare uno snapshot con ambito a livello di regione e impostare le posizioni di accesso consentite (anteprima). Puoi anche condividere gli snapshot tra i progetti.

Prima di iniziare

(Anteprima) Per creare snapshot con ambito a livello di regione, imposta le posizioni predefinite per la creazione e il ripristino degli snapshot prima di completare i passaggi in questa pagina.
Se non l'hai ancora fatto, configura l'autenticazione. L'autenticazione è il processo mediante il quale la tua identità viene verificata per l'accesso a servizi e API di Google Cloud . Per eseguire codice o esempi da un ambiente di sviluppo locale, puoi autenticarti su Compute Engine selezionando una delle seguenti opzioni:

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

Ruoli e autorizzazioni richiesti

Per ottenere le autorizzazioni necessarie per creare uno snapshot standard, chiedi all'amministratore di concederti i seguenti ruoli IAM per il progetto:

Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1)
Per connetterti a una VM che può essere eseguita come service account: Service Account User (v1) (roles/iam.serviceAccountUser)

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questi ruoli predefiniti contengono le autorizzazioni necessarie per creare uno snapshot standard. Per visualizzare le autorizzazioni obbligatorie corrette, espandi la relativa sezione:

Autorizzazioni obbligatorie

Per creare uno snapshot standard sono necessarie queste autorizzazioni:

Per creare uno snapshot di un disco a livello di zona:
- compute.snapshots.create sul progetto
- compute.disks.createSnapshot sul disco
Per creare uno snapshot di un disco a livello di regione utilizzando i dati presenti sul disco:
- compute.snapshots.create sul progetto
- compute.instances.useReadOnly sulla VM di origine
- compute.disks.createSnapshot sul disco
Per creare uno snapshot di un disco a livello di regione da un checkpoint di recupero delle repliche:
- compute.snapshots.create sul progetto
- compute.disks.createSnapshot sul disco
(Anteprima) Per creare uno snapshot con ambito a livello di regione:
- compute.snapshots.create sul progetto
- compute.regionSnapshots.create sul progetto
- compute.disks.useReadOnly sul disco

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Preparati per la creazione degli snapshot

Per prepararti a creare snapshot dei volumi Persistent Disk o Hyperdisk, segui questi passaggi:

Consulta le best practice per gli snapshot dei dischi Compute Engine per preparare il disco per la procedura di creazione.
Se vuoi personalizzare la località di archiviazione predefinita per tutti i nuovi snapshot con ambito globale, aggiorna le impostazioni degli snapshot per il progetto. Per la località di archiviazioneGoogle Cloud mantiene un valore predefinito finché non aggiorni le impostazioni degli snapshot per la prima volta. La località predefinita è la località multiregionale più vicina al disco di origine.
Per scoprire come creare una pianificazione di snapshot e come collegarla ai dischi, leggi l'articolo Creare pianificazioni per gli snapshot dei dischi. Eseguire regolarmente il backup dei dischi con snapshot pianificati può ridurre il rischio di perdite impreviste dei dati.
Non puoi creare uno snapshot di un volume Hyperdisk in modalità multi-autore. Disattiva la modalità multi-autore per il disco, quindi crea lo snapshot.

Crea uno snapshot di un volume Persistent Disk

Le istruzioni per la creazione di snapshot dei volumi Persistent Disk variano a seconda che tu stia creando uno snapshot di un volume Persistent Disk a livello di zona o di un volume Persistent Disk a livello di regione.

Crea uno snapshot di un volume Persistent Disk a livello di zona

Console

Nella console Google Cloud , vai alla pagina Istanze VM.

Vai a Istanze VM
I passaggi rimanenti verranno visualizzati automaticamente nella console Google Cloud .
Seleziona il progetto che contiene le istanze VM.
Nella colonna Nome, fai clic sul nome della VM con il disco di cui vuoi eseguire il backup.
In Spazio di archiviazione:
- Per eseguire il backup del disco di avvio, fai clic sul nome del disco nella sezione Disco di avvio.
- Per eseguire il backup di un disco dati collegato, fai clic sul nome del disco in Dischi aggiuntivi.
Fai clic su Crea snapshot.
In Nome, inserisci un nome univoco per identificare lo scopo dello snapshot, ad esempio:
- boot-disk-snapshot
- attached-data-disk-snapshot
In Tipo, il valore predefinito è uno snapshot standard. Gli snapshot standard sono ideali per il backup a lungo termine e il disaster recovery.
Scegli Snapshot di archiviazione per creare un backup più conveniente rispetto agli snapshot standard, ma che richiede più tempo per il recupero dei dati.

Per ulteriori informazioni, vedi il confronto tra i tipi di snapshot.
Nella sezione Località, scegli una località per l'archiviazione dello snapshot. La località predefinita o personalizzata indicata nelle impostazioni degli snapshot viene selezionata automaticamente. Se vuoi, puoi ignorare le impostazioni e archiviare gli snapshot in una località di archiviazione personalizzata nel seguente modo:
1. Scegli il tipo di località di archiviazione che preferisci per lo snapshot.
  - Scegli Più regioni per una maggiore affidabilità a un costo superiore.
  - Scegli gli snapshot a livello di regione per un maggiore controllo sulla località fisica dei dati a un costo inferiore.
2. Nel campo Seleziona località, seleziona la regione o la multi-regione che vuoi utilizzare. Per utilizzare la regione o la multi-regione più vicina al disco di origine, scegli una località nella sezione Basata sulla posizione del disco.
Per creare uno snapshot, fai clic su Crea.

gcloud

Puoi creare lo snapshot nella policy della località di archiviazione definita dalle tue impostazioni degli snapshot o utilizzando una località di archiviazione alternativa di tua scelta. Per saperne di più, consulta la sezione sulla scelta della località di archiviazione degli snapshot.

Per creare uno snapshot nella località predefinita o personalizzata configurata nelle impostazioni degli snapshot, utilizza il comando gcloud compute snapshots create.
```
gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-zone=SOURCE_ZONE \
    --source-disk=SOURCE_DISK_NAME \
    --snapshot-type=SNAPSHOT_TYPE
```

In alternativa, per ignorare le impostazioni degli snapshot e crearne uno 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-zone=SOURCE_ZONE \
    --source-disk=SOURCE_DISK_NAME \
    --snapshot-type=SNAPSHOT_TYPE \
    --storage-location=STORAGE_LOCATION

(Anteprima) Per creare uno snapshot con ambito a livello di regione in una regione consentita, includi il flag --region per indicare dove creare lo snapshot.

gcloud beta compute snapshots create SNAPSHOT_NAME \
    --region=SNAPSHOT_SCOPE_REGION
    --source-disk=SOURCE_DISK_NAME \
    --source-disk-zone=SOURCE_ZONE \
    --snapshot-type=SNAPSHOT_TYPE

Sostituisci quanto segue:

SNAPSHOT_NAME: un nome per lo snapshot.
SOURCE_ZONE: la zona del disco di origine.
SOURCE_DISK_NAME: il nome del volume del Persistent Disk da cui vuoi creare uno snapshot.
SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVIO. Se non viene specificato un tipo di snapshot, viene creato uno snapshot STANDARD.
(Facoltativo) STORAGE_LOCATION: per gli snapshot con ambito globale, indica la multi-regione di Cloud Storage o la regione di Cloud Storage in cui vuoi archiviare lo snapshot. Puoi specificare una sola località di archiviazione.

Utilizza il parametro --storage-location solo se vuoi sostituire la località di archiviazione personalizzata o predefinita configurata nelle impostazioni degli snapshot.
(Facoltativo) SNAPSHOT_SCOPE_REGION: per gli snapshot con ambito a livello di regione, indica la regione che lo snapshot ha come ambito. Se includi questo parametro, non puoi utilizzare il parametro --storage-location. STORAGE_LOCATION viene impostato automaticamente su SNAPSHOT_SCOPE_REGION.

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 volume del Persistent Disk a livello di zona, utilizza la risorsa google_compute_snapshot.

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.

Vai

Go

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

Per effettuare l'autenticazione in Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

import (
	"context"
	"fmt"
	"io"

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

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

	ctx := context.Background()

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

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

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

	if diskProjectID == "" {
		diskProjectID = projectID
	}

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

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

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

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

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

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

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

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

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

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

	return nil
}

Java

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


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

public class CreateSnapshot {

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

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

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

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

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

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

    // The Cloud Storage multi-region or the Cloud Storage region where you
    // want to store your snapshot.
    // You can specify only one storage location. Available locations:
    // 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

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

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

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

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

  let disk;

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

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

  if (!diskProjectId) {
    diskProjectId = projectId;
  }

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

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

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

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

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

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

createSnapshot();

Python

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

from __future__ import annotations

import sys
from typing import Any

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


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


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

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

    Args:
        project_id: project ID or project number of the Cloud project you want
            to use to store the snapshot.
        disk_name: name of the disk you want to snapshot.
        snapshot_name: name of the snapshot to be created.
        zone: name of the zone in which is the disk you want to snapshot (for zonal disks).
        region: name of the region in which is the disk you want to snapshot (for regional disks).
        location: The Cloud Storage multi-region or the Cloud Storage region where you
            want to store your snapshot.
            You can specify only one storage location. Available locations:
            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)

REST

Per creare uno snapshot nella località predefinita o personalizzata configurata nelle impostazioni degli snapshot, 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"
}

In alternativa, per ignorare le impostazioni degli snapshot e crearne uno in una località di archiviazione personalizzata, invia una richiesta POST al metodo snapshots.insert e 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"
    ],
}

(Anteprima) Per creare uno snapshot con ambito a livello di regione in una regione consentita, invia una richiesta POST al metodo snapshots.insert e definisci la regione di creazione:

POST https://compute.googleapis.com/compute/beta/projects/DESTINATION_PROJECT_ID/regions/SNAPSHOT_SCOPE_REGION/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: un nome per lo 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 volume del Persistent Disk da cui vuoi creare uno snapshot.
SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVIO. Se non viene specificato un tipo di snapshot, viene creato uno snapshot STANDARD.
(Facoltativo) STORAGE_LOCATION: per gli snapshot con ambito globale, indica la multi-regione di Cloud Storage o la regione di Cloud Storage in cui vuoi archiviare lo snapshot. Puoi specificare una sola località di archiviazione.

Utilizza il parametro storageLocations solo se vuoi sostituire la località di archiviazione personalizzata o predefinita configurata nelle impostazioni degli snapshot.
(Facoltativo) SNAPSHOT_SCOPE_REGION: per gli snapshot con ambito a livello di regione, indica la regione che lo snapshot ha come ambito. Se includi questo parametro, non puoi utilizzare il parametro storageLocations. STORAGE_LOCATION viene impostato automaticamente su SNAPSHOT_SCOPE_REGION.

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

Crea uno snapshot di un volume Persistent Disk a livello di regione

Puoi creare snapshot del volume Persistent Disk a livello di regione in uno dei seguenti modi:

Utilizzando i dati presenti sul disco di origine. Per utilizzare questo metodo di creazione degli snapshot, devi disporre di una replica a livello di zona sincronizzata.
Utilizzando il checkpoint di recupero delle repliche di un disco con prestazioni ridotte. Puoi creare snapshot da un checkpoint solo utilizzando Google Cloud CLI o REST.

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

Console

Vai alla pagina Crea uno snapshot nella console Google Cloud .
Vai alla pagina Crea uno snapshot
Inserisci un nome per lo snapshot.
Seleziona un tipo di snapshot. Il valore predefinito è uno snapshot STANDARD, che è l'opzione migliore per il backup a lungo termine e il disaster recovery.

Scegli Snapshot archivio per una conservazione dei dati più economica.
Facoltativo: inserisci una descrizione dello snapshot.
In Disco di origine, seleziona il disco esistente di cui vuoi creare uno snapshot.
Nella sezione Località, scegli una località per l'archiviazione dello snapshot.

La località predefinita o personalizzata indicata nelle impostazioni degli snapshot viene selezionata automaticamente. Se vuoi, puoi ignorare le impostazioni e archiviare lo snapshot in una località di archiviazione personalizzata nel seguente modo:
1. Scegli il tipo di località di archiviazione che preferisci per lo snapshot.
  - Scegli Più regioni per una maggiore affidabilità a un costo superiore.
  - Scegli gli snapshot a livello di regione per un maggiore controllo sulla posizione fisica dei dati a un costo inferiore.
2. Nel campo Seleziona località, seleziona la regione o la multi-regione specifica che vuoi utilizzare. Per utilizzare la regione o la multi-regione più vicina al tuo disco di origine, seleziona Basata sulla posizione del disco.
Fai clic su Crea per creare lo snapshot.

gcloud

Puoi creare uno snapshot utilizzando i dati del disco di origine o il relativo checkpoint di recupero delle repliche.

Dai dati del disco

Puoi creare uno snapshot dai dati del disco utilizzando la policy della località di archiviazione definita dalle tue impostazioni degli snapshot o utilizzando una località di archiviazione alternativa di tua scelta. Per saperne di più, consulta la sezione sulla scelta della località di archiviazione degli snapshot.

Per creare uno snapshot nella località predefinita o personalizzata configurata nelle impostazioni degli snapshot, utilizza il comando gcloud compute snapshots create.
```
gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-region=SOURCE_REGION \
    --source-disk=SOURCE_DISK_NAME \
    --snapshot-type=SNAPSHOT_TYPE
```

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

(Anteprima) Per creare uno snapshot con ambito a livello di regione in una regione consentita, includi il flag --region per indicare dove creare lo snapshot.

gcloud beta compute snapshots create SNAPSHOT_NAME \
    --region=SNAPSHOT_SCOPE_REGION \
    --source-disk=SOURCE_DISK_NAME \
    --source-disk-region=SOURCE_REGION \
    --snapshot-type=SNAPSHOT_TYPE

Sostituisci quanto segue:

SNAPSHOT_NAME: un nome per lo snapshot.
SOURCE_REGION: la regione del disco di origine.
SOURCE_DISK_NAME: il nome del volume del Persistent Disk regionale o del volume Hyperdisk bilanciato ad alta affidabilità da cui vuoi creare uno snapshot.
SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVIO. Se non viene specificato un tipo di snapshot, viene creato uno snapshot STANDARD.
(Facoltativo) STORAGE_LOCATION: per gli snapshot con ambito globale, indica la multi-regione di Cloud Storage o la regione di Cloud Storage in cui vuoi archiviare lo snapshot. Puoi specificare una sola località di archiviazione.

Utilizza il parametro --storage-location solo se vuoi sostituire la località di archiviazione personalizzata o predefinita configurata nelle impostazioni degli snapshot.
(Facoltativo) SNAPSHOT_SCOPE_REGION: per gli snapshot con ambito a livello di regione, indica la regione che lo snapshot ha come ambito. Se includi questo parametro, non puoi utilizzare il parametro --storage-location. STORAGE_LOCATION viene impostato automaticamente su SNAPSHOT_SCOPE_REGION.

Dal checkpoint

Puoi creare lo snapshot utilizzando il checkpoint di recupero delle repliche (anteprima) di un disco con prestazioni ridotte. Lo snapshot viene creato purché la replica incompleta sia disponibile.

Per creare uno snapshot utilizzando il checkpoint di recupero delle repliche, utilizza il comando gcloud compute snapshots create. Includi il flag --source-disk-for-recovery-checkpoint per specificare che vuoi creare lo snapshot utilizzando un checkpoint di recupero delle repliche. Escludi i parametri --source-disk e --source-disk-region.

gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-for-recovery-checkpoint=SOURCE_DISK \
    --source-disk-for-recovery-checkpoint-region=SOURCE_REGION \
    --storage-location=STORAGE_LOCATION \
    --snapshot-type=SNAPSHOT_TYPE

Sostituisci quanto segue:

DESTINATION_PROJECT_ID: l'ID del progetto in cui vuoi creare lo snapshot.
SNAPSHOT_NAME: un nome per lo snapshot.
SOURCE_PROJECT_ID: l'ID progetto del disco di origine di cui vuoi utilizzare il checkpoint per creare lo snapshot.
SOURCE_REGION: la regione del disco di origine di cui vuoi utilizzare il checkpoint per creare lo snapshot.
SOURCE_DISK_NAME: il nome del disco di origine di cui vuoi utilizzare il checkpoint per creare lo snapshot.
(Facoltativo) STORAGE_LOCATION: la multi-regione di Cloud Storage o la regione di Cloud Storage in cui vuoi archiviare lo snapshot. Puoi specificare una sola località di archiviazione.
Utilizza questa opzione solo se vuoi sostituire la località di archiviazione predefinita o personalizzata configurata nelle impostazioni degli snapshot.
SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVIO. Se non viene specificato un tipo di snapshot, viene creato uno snapshot STANDARD.

Puoi utilizzare il checkpoint di recupero delle repliche per creare uno snapshot solo sui dischi con prestazioni ridotte. Se provi a creare uno snapshot da un checkpoint di recupero delle repliche quando il dispositivo è completamente replicato, viene visualizzato il seguente messaggio di errore:

The device is fully replicated and should not create snapshots out of a recovery checkpoint. Please
create regular snapshots instead.

Google Cloud CLI attende che l'operazione restituisca uno stato READY o 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 volume del Persistent Disk a livello di regione. Per monitorare questa limitazione, vedi le informazioni relative al problema su GitHub.

Vai

Go

import (
	"context"
	"fmt"
	"io"

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

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

	ctx := context.Background()

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

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

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

	if diskProjectID == "" {
		diskProjectID = projectID
	}

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

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

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

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

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

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

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

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

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

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

	return nil
}

Java


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

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

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

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

  let disk;

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

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

  if (!diskProjectId) {
    diskProjectId = projectId;
  }

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

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

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

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

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

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

createSnapshot();

Python

from __future__ import annotations

import sys
from typing import Any

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


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


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

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

    Args:
        project_id: project ID or project number of the Cloud project you want
            to use to store the snapshot.
        disk_name: name of the disk you want to snapshot.
        snapshot_name: name of the snapshot to be created.
        zone: name of the zone in which is the disk you want to snapshot (for zonal disks).
        region: name of the region in which is the disk you want to snapshot (for regional disks).
        location: The Cloud Storage multi-region or the Cloud Storage region where you
            want to store your snapshot.
            You can specify only one storage location. Available locations:
            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)

REST

Puoi creare uno snapshot utilizzando i dati del disco di origine o il relativo checkpoint di recupero delle repliche.

Dai dati del disco

Per creare uno snapshot nella località predefinita o personalizzata configurata nelle impostazioni degli snapshot, 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"
}

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"
  ],
}

(Anteprima) Per creare uno snapshot con ambito a livello di regione in una regione consentita, invia una richiesta POST al metodo snapshots.insert e definisci la regione di creazione:

POST https://compute.googleapis.com/compute/beta/projects/DESTINATION_PROJECT_ID/regions/SNAPSHOT_SCOPE_REGION/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: un nome per lo 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 Persistent Disk regionale o del volume Hyperdisk bilanciato ad alta affidabilità da cui vuoi creare uno snapshot.
SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVIO. Se non viene specificato un tipo di snapshot, viene creato uno snapshot STANDARD.
(Facoltativo) STORAGE_LOCATION: per gli snapshot con ambito globale, indica la multi-regione di Cloud Storage o la regione di Cloud Storage in cui vuoi archiviare lo snapshot. Puoi specificare una sola località di archiviazione.

Utilizza il parametro storageLocations solo se vuoi sostituire la località di archiviazione personalizzata o predefinita configurata nelle impostazioni degli snapshot.
(Facoltativo) SNAPSHOT_SCOPE_REGION: per gli snapshot con ambito a livello di regione, indica la regione che lo snapshot ha come ambito. Se includi questo parametro, non puoi utilizzare il parametro storageLocations. STORAGE_LOCATION viene impostato automaticamente su SNAPSHOT_SCOPE_REGION.

Dal checkpoint

In alternativa, puoi creare lo snapshot utilizzando il checkpoint di recupero delle repliche di un disco con prestazioni ridotte. Lo snapshot viene creato purché la replica incompleta sia disponibile.

Per creare uno snapshot utilizzando il checkpoint di recupero delle repliche, invia una richiesta POST al metodo snapshots.insert. Escludi il parametro sourceDisk e includi il parametro sourceDiskForRecoveryCheckpoint per specificare che vuoi creare lo snapshot utilizzando il checkpoint.

POST https://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/global/snapshots

{
  "name": "SNAPSHOT_NAME",
  "sourceDiskForRecoveryCheckpoint": "projects/SOURCE_PROJECT_ID/regions/SOURCE_REGION/disks/SOURCE_DISK_NAME",
  "storageLocations": "STORAGE_LOCATION",
  "snapshotType": "SNAPSHOT_TYPE"
}

Sostituisci quanto segue:

DESTINATION_PROJECT_ID: l'ID del progetto in cui vuoi creare lo snapshot.
SNAPSHOT_NAME: un nome per lo snapshot.
SOURCE_PROJECT_ID: l'ID progetto del disco di origine di cui vuoi utilizzare il checkpoint per creare lo snapshot.
SOURCE_REGION: la regione del disco di origine di cui vuoi utilizzare il checkpoint per creare lo snapshot.
SOURCE_DISK_NAME: il nome del disco di origine di cui vuoi utilizzare il checkpoint per creare lo snapshot.
(Facoltativo) STORAGE_LOCATION: la multi-regione di Cloud Storage o la regione di Cloud Storage in cui vuoi archiviare lo snapshot. Puoi specificare una sola località di archiviazione.
Utilizza il parametro storageLocations solo se vuoi sostituire la località di archiviazione predefinita o personalizzata configurata nelle impostazioni degli snapshot.
SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVIO. Se non viene specificato un tipo di snapshot, viene creato uno snapshot STANDARD.

The device is fully replicated and should not create snapshots out of a recovery checkpoint. Please
create regular snapshots instead.

Crea uno snapshot di un Hyperdisk

Console

Nella console Google Cloud , vai alla pagina Istanze VM.

Vai a Istanze VM
Seleziona il progetto che contiene le istanze VM.
Nella colonna Nome, fai clic sul nome della VM con il disco Hyperdisk di cui vuoi eseguire il backup.
In Archiviazione, fai clic su Dischi aggiuntivi e poi sul nome del disco Hyperdisk collegato.
Fai clic su Crea snapshot.
In Nome, inserisci un nome univoco per identificare lo scopo dello snapshot, ad esempio hyperdisk-data-snapshot.
In Tipo, il valore predefinito è uno snapshot standard, ideale per il backup a lungo termine e il disaster recovery.
Nella sezione Località, scegli la località di archiviazione degli snapshot.

La località predefinita o personalizzata indicata nelle impostazioni degli snapshot viene selezionata automaticamente. Se vuoi, puoi ignorare le impostazioni e archiviare gli snapshot in una località di archiviazione personalizzata nel seguente modo:
1. Scegli il tipo di località di archiviazione che preferisci per lo snapshot.
  - Scegli Più regioni per una maggiore affidabilità a un costo superiore.
  - Scegli gli snapshot a livello di regione per un maggiore controllo sulla posizione fisica dei dati a un costo inferiore.
2. Nel campo Seleziona località, seleziona la regione specifica o più regioni che vuoi utilizzare. Per utilizzare la regione o più regioni più vicine al tuo disco di origine, seleziona Basata sulla posizione del disco.
Fai clic su Crea.

gcloud

Devi specificare un nome per lo snapshot. Il nome deve avere una lunghezza compresa tra 1 e 63 caratteri e deve essere conforme allo standard RFC 1035.

Per creare uno snapshot nella località predefinita o personalizzata configurata nelle impostazioni degli snapshot, utilizza il comando gcloud compute snapshots create.
```
gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-zone=SOURCE_ZONE \
    --source-disk=SOURCE_DISK_NAME \
    --snapshot-type=SNAPSHOT_TYPE
```

gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-zone=SOURCE_ZONE \
    --source-disk=SOURCE_DISK_NAME \
    --snapshot-type=SNAPSHOT_TYPE \
    --storage-location=STORAGE_LOCATION

(Anteprima) Per creare uno snapshot con ambito a livello di regione in una regione consentita, includi il flag --region per indicare dove creare lo snapshot.

gcloud beta compute snapshots create SNAPSHOT_NAME \
    --region=SNAPSHOT_SCOPE_REGION
    --source-disk=SOURCE_DISK_NAME \
    --source-disk-zone=SOURCE_ZONE \
    --snapshot-type=SNAPSHOT_TYPE

Sostituisci quanto segue:

SNAPSHOT_NAME: un nome per lo snapshot.
SOURCE_ZONE: la zona del disco di origine.
SOURCE_DISK_NAME: il nome del volume Hyperdisk da cui vuoi creare uno snapshot.
SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVIO. Se non viene specificato un tipo di snapshot, viene creato uno snapshot STANDARD.
(Facoltativo) STORAGE_LOCATION: per gli snapshot con ambito globale, indica la multi-regione di Cloud Storage o la regione di Cloud Storage in cui vuoi archiviare lo snapshot. Puoi specificare una sola località di archiviazione.

Utilizza il parametro --storage-location solo se vuoi sostituire la località di archiviazione personalizzata o predefinita configurata nelle impostazioni degli snapshot.
(Facoltativo) SNAPSHOT_SCOPE_REGION: per gli snapshot con ambito a livello di regione, indica la regione che lo snapshot ha come ambito. Se includi questo parametro, non puoi utilizzare il parametro --storage-location. STORAGE_LOCATION viene impostato automaticamente su SNAPSHOT_SCOPE_REGION.

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

REST

Devi specificare un nome per lo snapshot. Il nome deve avere una lunghezza compresa tra 1 e 63 caratteri e deve essere conforme allo standard RFC 1035.

Per creare uno snapshot nella località predefinita o personalizzata configurata nelle impostazioni degli snapshot, 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"
}

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"
    ],
}

(Anteprima) Per creare uno snapshot con ambito a livello di regione in una regione consentita, invia una richiesta POST al metodo snapshots.insert e definisci la regione di creazione:

POST https://compute.googleapis.com/compute/beta/projects/DESTINATION_PROJECT_ID/regions/SNAPSHOT_SCOPE_REGION/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: un nome per lo 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 volume Hyperdisk da cui vuoi creare uno snapshot.
SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVIO. Se non viene specificato un tipo di snapshot, viene creato uno snapshot STANDARD.
(Facoltativo) STORAGE_LOCATION: per gli snapshot con ambito globale, indica la multi-regione di Cloud Storage o la regione di Cloud Storage in cui vuoi archiviare lo snapshot. Puoi specificare una sola località di archiviazione.

Utilizza il parametro storageLocations solo se vuoi sostituire la località di archiviazione personalizzata o predefinita configurata nelle impostazioni degli snapshot.
(Facoltativo) SNAPSHOT_SCOPE_REGION: per gli snapshot con ambito a livello di regione, indica la regione che lo snapshot ha come ambito. Se includi questo parametro, non puoi utilizzare il parametro storageLocations. STORAGE_LOCATION viene impostato automaticamente su SNAPSHOT_SCOPE_REGION.

Passaggi successivi

Scopri come creare snapshot pianificati per i dischi.
Scopri come visualizzare, eliminare e condividere gli snapshot dei dischi.
Scopri come creare un'immagine disco dallo snapshot.

Crea snapshot del disco standard e di archiviazione Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Prima di iniziare

Console

gcloud

Terraform

Vai

Java

Node.js

Python

REST

Ruoli e autorizzazioni richiesti

Autorizzazioni obbligatorie

Preparati per la creazione degli snapshot

Crea uno snapshot di un volume Persistent Disk

Crea uno snapshot di un volume Persistent Disk a livello di zona

Console

gcloud

Terraform

Vai

Go

Java

Java

Node.js

Node.js

Python

Python

REST

Crea uno snapshot di un volume Persistent Disk a livello di regione

Console

gcloud

Dai dati del disco

Dal checkpoint

Terraform

Vai

Go

Java

Java

Node.js

Node.js

Python

Python

REST

Dai dati del disco

Dal checkpoint

Crea uno snapshot di un Hyperdisk

Console

gcloud

REST

Passaggi successivi

Crea snapshot del disco standard e di archiviazione