Crea snapshot di archivi e dischi standard

Crea snapshot standard di cui eseguire periodicamente il backup da questi tipi di dischi:

Puoi creare snapshot dai dischi anche quando sono collegati a istanze in esecuzione. Gli snapshot sono risorse globali, in modo da poterli utilizzare per ripristinare i dati su un nuovo disco o una nuova VM all'interno dello stesso progetto. Puoi anche condividere istantanee tra progetti.

Prima di iniziare

  • Se non l'hai ancora fatto, configura l'autenticazione. Autenticazione è Il processo di verifica dell'identità per l'accesso ai servizi e alle API di Google Cloud. Per eseguire codice o esempi da un ambiente di sviluppo locale, puoi eseguire l'autenticazione Compute Engine come segue.

    Select the tab for how you plan to use the samples on this page:

    Console

    When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

    gcloud

    1. Install the Google Cloud CLI, then initialize it by running the following command: 

      gcloud init
    2. Set a default region and zone.

      3. Terraform

      Per utilizzare gli esempi di Terraform in questa pagina in un ambiente dell'ambiente di sviluppo, installare e inizializzare gcloud CLI quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

      1. Install the Google Cloud CLI.

      2. To initialize the gcloud CLI, run the following command: 

        gcloud init

      3. If you're using a local shell, then create local authentication credentials for your user account: 

        gcloud auth application-default login

        You don't need to do this if you're using Cloud Shell.

      Per ulteriori informazioni, consulta Set up authentication for a local development environment.

      Vai

      Per utilizzare gli Go esempi in questa pagina in un ambiente di sviluppo locale, installa e inizializza l'interfaccia a riga di comando gcloud, quindi configura le credenziali predefinite dell'applicazione con le tue credenziali utente.

      1. Install the Google Cloud CLI.

      2. To initialize the gcloud CLI, run the following command: 

        gcloud init

      3. If you're using a local shell, then create local authentication credentials for your user account: 

        gcloud auth application-default login

        You don't need to do this if you're using Cloud Shell.

      Per ulteriori informazioni, consulta Set up authentication for a local development environment.

      Java

      Per utilizzare gli Java esempi in questa pagina in un ambiente di sviluppo locale, installa e inizializza l'interfaccia a riga di comando gcloud, quindi configura le credenziali predefinite dell'applicazione con le tue credenziali utente.

      1. Install the Google Cloud CLI.

      2. To initialize the gcloud CLI, run the following command: 

        gcloud init

      3. If you're using a local shell, then create local authentication credentials for your user account: 

        gcloud auth application-default login

        You don't need to do this if you're using Cloud Shell.

      Per ulteriori informazioni, consulta Set up authentication for a local development environment.

      Node.js

      Per utilizzare gli Node.js esempi in questa pagina in una località dell'ambiente di sviluppo, installare e inizializzare gcloud CLI quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

      1. Install the Google Cloud CLI.

      2. To initialize the gcloud CLI, run the following command: 

        gcloud init

      3. If you're using a local shell, then create local authentication credentials for your user account: 

        gcloud auth application-default login

        You don't need to do this if you're using Cloud Shell.

      Per ulteriori informazioni, vedi Set up authentication for a local development environment.

      Python

      Per utilizzare gli Python esempi in questa pagina in un ambiente di sviluppo locale, installa e inizializza l'interfaccia a riga di comando gcloud, quindi configura le credenziali predefinite dell'applicazione con le tue credenziali utente.

      1. Install the Google Cloud CLI.

      2. To initialize the gcloud CLI, run the following command: 

        gcloud init

      3. If you're using a local shell, then create local authentication credentials for your user account: 

        gcloud auth application-default login

        You don't need to do this if you're using Cloud Shell.

      Per ulteriori informazioni, vedi Set up authentication for a local development environment.

      REST

      Per utilizzare gli esempi dell'API REST in questa pagina in un ambiente di sviluppo locale, utilizza le credenziali fornite a gcloud CLI.

        Install the Google Cloud CLI, then initialize it by running the following command: 

        gcloud init

      Per ulteriori informazioni, vedi Esegui l'autenticazione per l'utilizzo di REST nella documentazione sull'autenticazione di Google Cloud.

Ruoli e autorizzazioni richiesti

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

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

Questi ruoli predefiniti contengono le autorizzazioni necessarie per creare uno snapshot standard. Per vedere le autorizzazioni esatte obbligatorie, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per creare uno snapshot standard sono necessarie le seguenti autorizzazioni:

  • Per creare uno snapshot di un disco a livello di zona:
    • compute.snapshots.create del progetto
    • compute.disks.createSnapshot sul disco
  • Per creare uno snapshot di un disco di una regione utilizzando i dati presenti sul disco:
    • compute.snapshots.create del progetto
    • compute.instances.useReadOnly sulla VM di origine
    • compute.disks.createSnapshot sul disco
  • Per creare uno snapshot di un disco di regione da un checkpoint di recupero della replica:
    • compute.snapshots.create del progetto
    • compute.disks.createSnapshot sul disco

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

Preparati per la creazione di snapshot

Per prepararti a creare snapshot di dischi permanenti o Hyperdisk:

di Gemini Advanced.

Crea uno snapshot del volume del Persistent Disk

Le istruzioni per creare snapshot di volumi di Persistent Disk sono diverse, a seconda che tu stia creando uno snapshot di un Persistent Disk a livello di zona Persistent Disk regionale.

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

Console

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

    Vai a 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 di cui eseguire il backup.
  4. In Spazio di archiviazione:
    • Per eseguire il backup del disco di avvio, nella sezione Disco di avvio, fai clic sul Nome del disco di avvio.
    • Per eseguire il backup di un disco dati collegato, fai clic sul Nome in Dischi aggiuntivi del disco.
  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-data-disk-snapshot
  7. In Tipo, il valore predefinito è uno snapshot standard. Gli snapshot standard vengono ideale per backup a lungo termine e ripristino di emergenza.

    Scegli Snapshot archivio per creare un backup più conveniente rispetto agli snapshot standard, ma con un tempo di recupero dei dati più lungo.

    Per ulteriori informazioni, vedi Confronto dei tipi di snapshot.

  8. Nella sezione Posizione, scegli la tua istantanea posizione di archiviazione. La località predefinita o personalizzata definita nelle impostazioni dello snapshot è viene selezionata automaticamente. Se vuoi, puoi ignorare le impostazioni degli snapshot e archiviarli in una posizione di archiviazione personalizzata nel seguente modo:

    1. Scegli il tipo di posizione di archiviazione per lo snapshot.

      • Scegli Più regioni per una maggiore disponibilità a un costo maggiore.
      • Scegli gli snapshot regionali per un maggiore controllo sulla località fisica dei dati a un costo inferiore.

    2. Nel campo Seleziona località, seleziona una o più regioni specifiche che vuoi utilizzare. Per utilizzare la regione o le regioni più vicine al tuo disco di origine, scegli una posizione dalla sezione intitolata In base alla posizione del disco.

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

gcloud

Puoi creare lo snapshot nel criterio di località di archiviazione definita dal tuo impostazioni snapshot oppure utilizzando una posizione di archiviazione alternativa di tua scelta. Per ulteriori informazioni, vedi Scegli la località di archiviazione degli snapshot.

  • Per creare uno snapshot nella posizione predefinita o personalizzata configurato nelle impostazioni dello snapshot, utilizza 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 eseguire l'override delle impostazioni dello snapshot e creare uno snapshot in una posizione di archiviazione personalizzata, includi --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

    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 ARCHIVE. Se non viene specificato un tipo di snapshot, viene creato uno snapshot STANDARD.

    • STORAGE_LOCATION: Facoltativo: il campo Cloud Storage (più regioni) o la regione di Cloud Storage in cui archiviare lo snapshot. Puoi specificare una sola località di archiviazione.

      Utilizza il parametro --storage-location solo quando vuoi eseguire l'override del località di archiviazione predefinita o personalizzata configurata nello snapshot impostazioni.

    di Gemini Advanced.

Terraform

Per creare uno snapshot del volume del Persistent Disk a livello di zona, utilizza 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, consulta Comandi Terraform di base.

Vai

Go

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

Per eseguire l'autenticazione su Compute Engine, configura 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

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di Compute Engine che utilizza le librerie client. Per ulteriori informazioni, consulta API Java Compute Engine documentazione di riferimento.

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


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 nel Guida rapida di Compute Engine con librerie client. Per ulteriori informazioni, consulta API Node.js Compute Engine documentazione di riferimento.

Per autenticarti a Compute Engine, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

/**
 * 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 nel Guida rapida di Compute Engine con librerie client. Per ulteriori informazioni, consulta API Python Compute Engine documentazione di riferimento.

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

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 lo snapshot nel criterio di località di archiviazione definita dal tuo impostazioni snapshot oppure utilizzando una posizione di archiviazione alternativa di tua scelta. Per ulteriori informazioni, vedi Scegli la località di archiviazione degli snapshot.

  • Per creare uno snapshot nella posizione predefinita o personalizzata configurata nelle impostazioni dello 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 dello snapshot e crearne uno in una posizione 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"
    ],
}

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 ARCHIVE. Se non viene specificato un tipo di snapshot, viene creato uno snapshot STANDARD.

  • STORAGE_LOCATION: Facoltativo: il campo Cloud Storage (più regioni) o la regione di Cloud Storage in cui archiviare lo snapshot. Puoi specificare una sola località di archiviazione.

    Utilizza il parametro storageLocations solo quando vuoi eseguire l'override del località di archiviazione predefinita o personalizzata configurata nello snapshot impostazioni.

di Gemini Advanced.

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

Puoi creare snapshot del volume del Persistent Disk a livello di regione in una delle nei seguenti modi:

  • Utilizzando i dati sul disco di origine. Per utilizzare questo metodo di creazione dello snapshot, devi disporre di una replica sincronizzata a livello di zona.
  • Utilizzando il checkpoint di recupero della replica di un disco danneggiato. Puoi creare snapshot da un checkpoint solo utilizzando Google Cloud CLI o REST.
di Gemini Advanced.

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

Console

  1. Vai alla pagina Crea uno snapshot nella console Google Cloud.

    Vai alla pagina Crea un'istantanea
  2. Inserisci un Nome snapshot.

  3. Seleziona un tipo di snapshot. Il valore predefinito è uno snapshot STANDARD, che è l'opzione migliore per il backup a lungo termine e il ripristino di emergenza.

    Scegli Istantanea archiviazione per conservare i dati in modo più conveniente.

  4. (Facoltativo) Inserisci una descrizione dello snapshot.
  5. In Disco di origine, seleziona il disco esistente di cui vuoi creare uno snapshot.

  6. Nella sezione Posizione, scegli la tua istantanea posizione di archiviazione.

    La località predefinita o personalizzata definita nello snapshot viene selezionata automaticamente. Facoltativamente, puoi eseguire l'override le impostazioni degli snapshot e archiviarli in una posizione di archiviazione personalizzata nel seguente modo:

    1. Scegli il tipo di posizione di archiviazione per lo snapshot.

    2. Nel campo Seleziona località, seleziona la regione specifica oppure dall'area multiregionale che vuoi utilizzare. Per utilizzare una o più regioni più vicino al disco di origine, seleziona In base alla posizione del disco.
  7. Fai clic su Crea per creare lo snapshot.

gcloud

Puoi creare uno snapshot utilizzando i dati del disco di origine o i relativi il checkpoint di ripristino della replica.

Dai dati del disco

Puoi creare uno snapshot dai dati del tuo disco utilizzando il criterio di località di archiviazione definita dal tuo impostazioni snapshot oppure utilizzando una posizione di archiviazione alternativa di tua scelta. Per ulteriori informazioni, vedi Scegli la località di archiviazione degli snapshot.

  • Per creare uno snapshot nella posizione predefinita o personalizzata configurato nelle impostazioni dello snapshot, utilizza 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

  • In alternativa, per eseguire l'override delle impostazioni dello snapshot e creare uno snapshot in una posizione di archiviazione personalizzata, includi --storage-location per indicare dove archiviare lo snapshot.

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

    Sostituisci quanto segue:

    • SNAPSHOT_NAME: un nome per lo snapshot.
    • SOURCE_REGION: la regione del disco di origine.
    • SOURCE_DISK_NAME: il nome dell'evento Volume a disponibilità elevata Hyperdisk Bilanciata o Disco permanente regionale da cui creare senza dover creare uno snapshot.
    • SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVE. Se il tipo di snapshot non è specificato, viene creato uno snapshot STANDARD.

    • STORAGE_LOCATION: Facoltativo: il campo Cloud Storage (più regioni) o la regione di Cloud Storage in cui archiviare lo snapshot. Puoi specificare una sola località di archiviazione.

      Utilizza il parametro --storage-location solo quando vuoi eseguire l'override del località di archiviazione predefinita o personalizzata configurata nello snapshot impostazioni.

    di Gemini Advanced.

Dal checkpoint

Puoi creare lo snapshot utilizzando il controllo punto di ripristino della replica (Anteprima) di un disco in stato degradato. Lo snapshot viene creato se la replica incompleta è disponibile.

Per creare uno snapshot mediante il checkpoint di recupero della replica, utilizza Comando gcloud compute snapshots create . Includi il flag --source-disk-for-recovery-checkpoint per specifica che vuoi creare lo snapshot utilizzando un ripristino della replica punto di controllo. Escludi --source-disk e Parametri --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 inserire per creare lo snapshot.
  • SNAPSHOT_NAME: un nome per lo snapshot.
  • SOURCE_PROJECT_ID: l'ID progetto del disco di origine la cui che vuoi usare per creare lo snapshot.
  • SOURCE_REGION: la regione del disco di origine la cui che vuoi usare per creare lo snapshot.
  • SOURCE_DISK_NAME: il nome del disco di origine la cui che vuoi usare per creare lo snapshot.
  • STORAGE_LOCATION: facoltativo: L'area multiregionale di Cloud Storage o Cloud Storageregion in cui archiviare lo snapshot. Puoi specificare una sola località di archiviazione.
    Utilizza la solo se si desidera eseguire l'override dello spazio di archiviazione predefinito o personalizzato località configurata nelle impostazioni dello snapshot.
  • SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVIO. Se il tipo di snapshot non è specificato, viene restituito un valore STANDARD viene creato uno snapshot.

Puoi utilizzare il checkpoint di recupero della replica per creare uno snapshot solo sui dischi degradati. Se provi a creare uno snapshot da un ripristino della replica 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 lo stato READY, FAILED o raggiunge il timeout massimo e restituisce l'ultimo dettagli noti dello snapshot.

Terraform

Il provider Terraform per Google Cloud non supporta la creazione di un di un volume di Persistent Disk a livello di regione. Per tenere traccia di questa limitazione, consulta la su GitHub.

Vai

Go

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di Compute Engine con librerie client. Per ulteriori informazioni, consulta API Go Compute Engine documentazione di riferimento.

Per eseguire l'autenticazione su Compute Engine, configura 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

Java

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

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


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 di configurazione di Node.js nella guida rapida di Compute Engine che utilizza le librerie client. Per ulteriori informazioni, consulta API Node.js Compute Engine documentazione di riferimento.

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

/**
 * 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 nel Guida rapida di Compute Engine con librerie client. Per ulteriori informazioni, consulta API Python Compute Engine documentazione di riferimento.

Per autenticarti a Compute Engine, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

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 i relativi il checkpoint di ripristino della replica.

Dai dati del disco

Puoi creare uno snapshot dai dati del tuo disco utilizzando il criterio di località di archiviazione definita dal tuo impostazioni snapshot oppure utilizzando una posizione di archiviazione alternativa di tua scelta. Per ulteriori informazioni, vedi Scegli la località di archiviazione degli snapshot.

  • Per creare uno snapshot nella posizione predefinita o personalizzata configurato nelle impostazioni dello snapshot, effettua una richiesta POST 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"
}

  • In alternativa, per eseguire l'override delle impostazioni dello snapshot e creare uno snapshot in una posizione di archiviazione personalizzata, effettua una richiesta POST snapshots.insert e includi la proprietà storageLocations nella tua richiesta:

    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: 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 disco permanente regionale o del volume Hyperdisk bilanciato con disponibilità elevata da cui vuoi creare uno snapshot.
  • SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVE. Se il tipo di snapshot non è specificato, viene creato uno snapshot STANDARD.

  • STORAGE_LOCATION: Facoltativo: il campo Cloud Storage (più regioni) o la regione di Cloud Storage in cui archiviare lo snapshot. Puoi specificare una sola località di archiviazione.

    Utilizza il parametro storageLocations solo quando vuoi eseguire l'override del località di archiviazione predefinita o personalizzata configurata nello snapshot impostazioni.

di Gemini Advanced.

Dal checkpoint

In alternativa, puoi creare lo snapshot utilizzando checkpoint di recupero della replica di un disco con prestazioni ridotte. Lo snapshot viene creato finché è disponibile una replica incompleta.

Per creare uno snapshot utilizzando il checkpoint di recupero della replica, invia una richiesta POST al metodo snapshots.insert. Escludi il parametro sourceDisk e includi invece il 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 inserire per creare lo snapshot.
  • SNAPSHOT_NAME: un nome per lo snapshot.
  • SOURCE_PROJECT_ID: l'ID progetto del disco di origine la cui che vuoi usare per creare lo snapshot.
  • SOURCE_REGION: la regione del disco di origine la cui che vuoi usare per creare lo snapshot.
  • SOURCE_DISK_NAME: il nome del disco di origine la cui che vuoi usare per creare lo snapshot.
  • STORAGE_LOCATION: facoltativo: L'area multiregionale di Cloud Storage o Cloud Storageregion in cui archiviare lo snapshot. Puoi specificare una sola località di archiviazione.
    Utilizza la Parametro storageLocations solo se si desidera eseguire l'override dello spazio di archiviazione predefinito o personalizzato località configurata nelle impostazioni dello snapshot.
  • SNAPSHOT_TYPE: il tipo di snapshot, STANDARD o ARCHIVIO. Se il tipo di snapshot non è specificato, viene restituito un valore STANDARD viene creato uno snapshot.

Puoi utilizzare il checkpoint di recupero della replica per creare uno snapshot solo sui dischi degradati. Se provi a creare uno snapshot da un ripristino della replica 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.

Crea uno snapshot di un Hyperdisk

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 con l'hyperdisk di cui vuoi eseguire il backup.

  4. In Archiviazione, in Dischi aggiuntivi, fai clic sul Nome del un Hyperdisk collegato.

  5. Fai clic su Crea snapshot.

  6. In Nome, inserisci un nome univoco che consenta di identificare lo scopo dell' uno snapshot, ad esempio hyperdisk-data-snapshot.

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

  8. Nella sezione Località, scegli la posizione di archiviazione degli snapshot.

    La località predefinita o personalizzata definita nello snapshot viene selezionata automaticamente. Se vuoi, puoi ignorare le impostazioni degli snapshot e archiviarli in una posizione di archiviazione personalizzata svolgendo i seguenti passaggi:

    1. Scegli il tipo di posizione di archiviazione per lo snapshot.

      • Scegli Più regioni per una maggiore disponibilità a un costo maggiore.
      • Scegli gli snapshot regionali per un maggiore controllo sulla località fisica dei dati a un costo inferiore.

    2. Nel campo Seleziona località, seleziona la regione specifica oppure dall'area multiregionale che vuoi utilizzare. Per utilizzare una o più regioni più vicino al disco di origine, seleziona In base alla posizione del disco.

  9. Fai clic su Crea.

gcloud

Puoi creare lo snapshot nel criterio della località di archiviazione definito dalle tue impostazioni di snapshot o utilizzando una località di archiviazione alternativa a tua scelta. Per ulteriori informazioni, vedi Scegli la località di archiviazione degli snapshot.

Devi specificare un nome snapshot. Il nome deve contenere da 1 a 63 caratteri e rispettare RFC 1035.

  • Per creare uno snapshot nella posizione predefinita o personalizzata configurato nelle impostazioni dello snapshot, utilizza 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 eseguire l'override delle impostazioni dello snapshot e creare uno snapshot in una posizione di archiviazione personalizzata, includi --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

    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 ARCHIVE. Se il tipo di snapshot non è specificato, viene creato uno snapshot STANDARD.

    • STORAGE_LOCATION: Facoltativo: il campo Cloud Storage (più regioni) o la regione di Cloud Storage in cui archiviare lo snapshot. Puoi specificare una sola località di archiviazione.

      Utilizza il parametro --storage-location solo quando vuoi eseguire l'override del località di archiviazione predefinita o personalizzata configurata nello snapshot impostazioni.

    gcloud CLI attende che l'operazione restituisca lo stato READY o FAILED oppure raggiunge il timeout massimo e restituisce l'ultimo dettagli noti dello snapshot.

REST

Puoi creare lo snapshot nel criterio di località di archiviazione definita dal tuo impostazioni snapshot oppure utilizzando una posizione di archiviazione alternativa di tua scelta. Per ulteriori informazioni, vedi Scegli la località di archiviazione degli snapshot.

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

  • Per creare uno snapshot nella posizione predefinita o personalizzata configurato nelle impostazioni dello snapshot, effettua una richiesta POST 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 eseguire l'override delle impostazioni dello snapshot e creare uno snapshot in una posizione di archiviazione personalizzata, effettua una richiesta POST snapshots.insert e includi la proprietà storageLocations nella tua 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: 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 ARCHIVE. Se il tipo di snapshot non è specificato, viene creato uno snapshot STANDARD.

  • STORAGE_LOCATION: Facoltativo: il campo Cloud Storage (più regioni) o la regione di Cloud Storage in cui archiviare lo snapshot. Puoi specificare una sola località di archiviazione.

    Utilizza il parametro storageLocations solo quando vuoi eseguire l'override del località di archiviazione predefinita o personalizzata configurata nello snapshot impostazioni.

di Gemini Advanced.

Passaggi successivi