Esegui il backup dei dati utilizzando uno snapshot

In questa pagina viene illustrato come eseguire il backup dei dati memorizzati sul Istanza di blocchi note gestiti dall'utente di Vertex AI Workbench creando uno snapshot.

I dati sulla tua istanza sono archiviati su un disco permanente a livello di zona. Puoi creare e utilizzare snapshot di questo disco per eseguire il backup dei dati, creare una pianificazione di backup ricorrente e ripristinare i dati in una nuova istanza.

Crea uno snapshot

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

.

Console

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

    Vai a Istanze VM
    I passaggi rimanenti verranno visualizzati automaticamente in la 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 Istantanea archiviazione per creare un backup più conveniente rispetto a quello standard ma con tempi di recupero dei dati più lunghi.

    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. Facoltativamente, puoi eseguire l'override delle impostazioni dello snapshot e archiviare di snapshot in una posizione di archiviazione personalizzata:

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

      • Scegli Più regioni per una maggiore disponibilità a un costo maggiore.
      • Scegli Snapshot regionali per avere un maggiore controllo sulla posizione 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

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Crea il tuo snapshot utilizzando il criterio di località di archiviazione definito dal tuo impostazioni snapshot o l'utilizzo di una posizione di archiviazione alternativa di tua scelta. Per ulteriori informazioni consulta Scegliere la località di archiviazione degli snapshot. Devi specificare un nome snapshot. Il nome deve essere compreso tra 1 e 63 caratteri ed è conforme alla specifica RFC 1035.

    • Per creare uno snapshot di un volume di un Persistent Disk nel località predefinita personalizzata configurata nelle impostazioni dello snapshot, usa il comando gcloud compute snapshots create.

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

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

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

      Sostituisci quanto segue:

      • SNAPSHOT_NAME: un nome per lo snapshot.
      • SOURCE_DISK: il nome del volume del Persistent Disk a livello di zona da cui vuoi per creare uno 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. Scegli Archivia per conservare i dati in modo più conveniente.
      • SOURCE_DISK_ZONE: la zona del volume del Persistent Disk a livello di zona da cui vuoi per creare uno snapshot.

      Usa il flag --storage-location solo quando vuoi eseguire l'override del flag una posizione di archiviazione predefinita o personalizzata configurata nel tuo impostazioni dello snapshot.

    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.

Terraform

Per creare uno snapshot del disco permanente 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.

API

Crea il tuo snapshot nel criterio di località di archiviazione definito dal tuo impostazioni snapshot o l'utilizzo di una posizione di archiviazione alternativa di tua scelta. Per ulteriori informazioni consulta Scegliere la località di archiviazione degli snapshot.

  • Per creare lo 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
}

    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 del progetto del disco di origine.
    • SOURCE_ZONE: la zona del disco di origine.
    • SOURCE_DISK_NAME: il nome del disco permanente da per cui vuoi creare uno 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.

  • In alternativa, per eseguire l'override delle impostazioni dello snapshot e creare uno snapshot in una posizione di archiviazione personalizzata, effettua una richiesta POST 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 inserire per 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 disco permanente da per cui vuoi creare uno 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.

    • STORAGE_LOCATION: l'area multiregionale di Cloud Storage o la regione di Cloud Storage in cui archiviare lo snapshot. Puoi specificare un solo elemento posizione di archiviazione.

      Utilizza il parametro storageLocations solo quando vuoi eseguire l'override la posizione di archiviazione predefinita o personalizzata configurata le impostazioni dello snapshot.

di Gemini Advanced.

Vai

Go

Prima di provare questo esempio, segui le istruzioni di configurazione nel Guida rapida di Compute Engine mediante l'utilizzo delle librerie client.

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 nel Guida rapida di Compute Engine mediante l'utilizzo delle librerie client.

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 nel Guida rapida di Compute Engine mediante l'utilizzo delle librerie client.

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 di configurazione nel Guida rapida di Compute Engine mediante l'utilizzo delle librerie client.

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)

Pianifica un backup ricorrente

Quando crei una pianificazione di snapshot, crei un criterio delle risorse che puoi applicare a uno o più dischi permanenti. Puoi creare uno snapshot programmazioni nei seguenti modi:

Una pianificazione di snapshot include le seguenti proprietà:

  • Nome pianificazione
  • Descrizione pianificazione
  • Frequenza snapshot (ora, giornaliera, settimanale)
  • Ora di inizio snapshot
  • Regione in cui è disponibile la pianificazione di snapshot
  • Criterio di eliminazione del disco di origine per la gestione degli snapshot generati automaticamente se il disco di origine viene eliminato
  • Criterio di conservazione per definire per quanto tempo conservare gli snapshot generati dalla pianificazione di snapshot

Limitazioni

  • Un disco permanente può avere al massimo 10 pianificazioni di snapshot alla volta.
  • Non puoi creare snapshot archivio utilizzando una pianificazione di snapshot.
  • Puoi creare un massimo di 1000 pianificazioni di snapshot in uso per regione.
  • Le pianificazioni degli snapshot si applicano solo al progetto in cui sono state create. Le pianificazioni di snapshot non possono essere utilizzate in altri progetti o organizzazioni.
  • Potrebbe essere necessario richiedere un aumento della quota di risorse tramite la console se hai bisogno di risorse aggiuntive nella tua regione.
  • Non puoi eliminare una pianificazione di snapshot se è collegata a un disco. Devi scollega la programmazione da tutti i dischi, quindi elimina la pianificazione.
  • Puoi aggiornare una pianificazione di snapshot esistente per modificare la descrizione, pianificazione ed etichette. Per aggiornare altri valori per una pianificazione di snapshot, devi eliminare la pianificazione di snapshot e crearne una nuova.
  • Per i dischi permanenti che utilizzano una chiave di crittografia fornita dal cliente (CSEK), non puoi per creare pianificazioni di snapshot.
  • Per i dischi permanenti che utilizzano una chiave di crittografia gestita dal cliente (CMEK), tutti gli snapshot creati con una pianificazione di snapshot vengono criptati automaticamente con la stessa chiave.

Crea una pianificazione

Crea una pianificazione di snapshot per i dischi permanenti utilizzando la console Google Cloud. Google Cloud CLI o l'API Compute Engine. Devi creare lo snapshot pianificazione nella stessa regione in cui si trova il disco permanente. Ad esempio, se il disco permanente si trova nella zona us-west1-a, la pianificazione di snapshot deve Risiedere nella regione us-west1. Per ulteriori informazioni, vedi Scegli una posizione di archiviazione.

Console

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

    Vai a Istanze VM
    I passaggi rimanenti verranno visualizzati automaticamente in la console Google Cloud.

  2. Seleziona il progetto che contiene le istanze VM.
  3. Nella colonna Nome, fai clic sul nome della VM con il disco permanente per cui vuoi creare la pianificazione di snapshot.
  4. In Spazio di archiviazione, fai clic sul nome del disco di avvio o del disco aggiuntivo per cui vuoi creare la pianificazione di snapshot.
  5. Clic Modifica. Potresti dover fai clic sul Menu Altre azioni e poi Modifica.
  6. In Pianificazione di snapshot, scegli Crea una pianificazione.
  7. In Nome, inserisci uno dei seguenti nomi per la pianificazione di snapshot:
    • boot-disk-snapshot-schedule
    • attached-persistent-disk-snapshot-schedule

  8. Nella sezione Posizione, scegli la tua istantanea posizione di archiviazione. La località predefinita o personalizzata definita nelle impostazioni dello snapshot è viene selezionata automaticamente. Facoltativamente, puoi eseguire l'override delle impostazioni dello snapshot e archiviare di snapshot in una posizione di archiviazione personalizzata:

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

      • Scegli Più regioni per una maggiore disponibilità a un costo maggiore.
      • Scegli Snapshot regionali per avere un maggiore controllo sulla posizione 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, seleziona In base alla posizione del disco.

  9. Per completare la creazione della pianificazione di snapshot, fai clic su Crea.
  10. Per collegare questa pianificazione di snapshot al disco permanente, fai clic su Salva.

gcloud

Per creare una pianificazione di snapshot per i dischi permanenti, utilizza compute resource-policies create snapshot-schedule Comando gcloud. Imposta la frequenza di programmazione su base oraria, giornaliera o settimanale.

  gcloud compute resource-policies create snapshot-schedule [SCHEDULE_NAME] \
      --description "[SCHEDULE_DESCRIPTION]" \
      --max-retention-days [MAX_RETENTION_DAYS] \
      --start-time [START_TIME] \
      --hourly-schedule [SNAPSHOT_INTERVAL] \
      --daily-schedule \
      --weekly-schedule [SNAPSHOT_INTERVAL] \
      --weekly-schedule-from-file [FILE_NAME] \
      --on-source-disk-delete [DELETION_OPTION]

dove:

  • [SCHEDULE_NAME] è il nome della nuova pianificazione di snapshot.
  • "[SCHEDULE_DESCRIPTION]" è una descrizione della pianificazione di snapshot. Racchiudi tra virgolette la descrizione.
  • [MAX_RETENTION_DAYS] è il numero di giorni per cui è possibile conservare l'istantanea. Ad esempio, se imposti 3, gli snapshot vengono conservati per tre giorni prima di essere eliminati. Devi impostare un criterio di conservazione pari a almeno 1 giorno.
  • [START_TIME] è l'ora di inizio UTC. L'ora deve iniziare in base all'ora. Ad esempio:
    • 14:00 PST è 22:00.
    • Se imposti un'ora di inizio pari a 22:13, riceverai un errore.

  • [SNAPSHOT_INTERVAL] definisce l'intervallo di tempo desiderato la creazione di snapshot. Impostare la programmazione oraria utilizzando un numero intero tra 1 e 23. Scegli un numero orario diviso equamente in 24. Ad esempio, se imposti --hourly-schedule su 12, significa che lo snapshot viene generato ogni 12 ore. Per una programmazione settimanale, definisci i giorni in cui vuoi che venga eseguita la creazione dello snapshot. Devi precisare il giorni feriali, non sono sensibili alle maiuscole. I flag di frequenza degli snapshot hourly-schedule, daily-schedule e weekly-schedule sono si escludono a vicenda. Devi sceglierne una per la pianificazione di snapshot.

  • [FILE_NAME] è il nome del file che contiene l'istantanea settimanale pianificazione, se scegli di fornire la pianificazione in questo formato. Tieni presente che puoi specificare programmazioni settimanali per giorni diversi del settimana e in orari diversi utilizzando un file (ma non puoi specificare più programmazioni settimanali direttamente dalla riga di comando). Ad esempio: il tuo file potrebbe specificare una pianificazione di snapshot per il lunedì e il mercoledì: [{"day": "MONDAY", "startTime": "04:00"}, {"day": "WEDNESDAY", "startTime": "02:00"}] Se includi un'ora di inizio nel file, non è necessario impostare il valore Flag --start-time. La pianificazione utilizza lo standard orario UTC.

  • [DELETION_OPTION] determina cosa succede agli snapshot se del disco di origine eliminato. Scegli il valore predefinito per keep-auto-snapshots omettendo questo flag oppure usa apply-retention-policy per applicare criterio di conservazione.

Questi sono alcuni esempi aggiuntivi per la configurazione di una pianificazione di snapshot. In tutto i seguenti esempi:

  • È inclusa la regola di eliminazione del disco. la bandiera --on-source-disk-delete è impostata sul valore predefinito di keep-auto-snapshots per mantenere tutti di snapshot generati automaticamente. L'alternativa è impostare il flag su apply-retention-policy per utilizzare il criterio di conservazione degli snapshot.
  • La località di archiviazione è impostata su US, quindi tutti gli snapshot generati verranno archiviati in più regioni degli Stati Uniti.
  • Le etichette env=dev e media=images vengono applicate a tutte le etichette generate snapshot.
  • Il criterio di conservazione è impostato su 10 giorni.

Programmazione oraria:in questo esempio, la pianificazione di snapshot inizia alle 22:00. UTC e si verifica ogni 4 ore.

  gcloud compute resource-policies create snapshot-schedule SCHEDULE_NAME \
      --description "MY HOURLY SNAPSHOT SCHEDULE" \
      --max-retention-days 10 \
      --start-time 22:00 \
      --hourly-schedule 4 \
      --region us-west1 \
      --on-source-disk-delete keep-auto-snapshots \
      --snapshot-labels env=dev,media=images \
      --storage-location US

Programmazione giornaliera:in questo esempio, la pianificazione di snapshot inizia alle 22:00. UTC e si verifica ogni giorno alla stessa ora. Il flag --daily-schedule deve essere presente, ma non essere impostato su alcun valore.

gcloud compute resource-policies create snapshot-schedule SCHEDULE_NAME \
    --description "MY DAILY SNAPSHOT SCHEDULE" \
    --max-retention-days 10 \
    --start-time 22:00 \
    --daily-schedule \
    --region us-west1 \
    --on-source-disk-delete keep-auto-snapshots \
    --snapshot-labels env=dev,media=images \
    --storage-location US

Programmazione settimanale:in questo esempio, la pianificazione di snapshot inizia alle 22:00. UTC e si verifica ogni settimana di martedì e giovedì.

gcloud compute resource-policies create snapshot-schedule SCHEDULE_NAME \
    --description "MY WEEKLY SNAPSHOT SCHEDULE" \
    --max-retention-days 10 \
    --start-time 22:00 \
    --weekly-schedule tuesday,thursday \
    --region us-west1 \
    --on-source-disk-delete keep-auto-snapshots \
    --snapshot-labels env=dev,media=images \
    --storage-location US

API

Nell'API, crea una richiesta POST per resourcePolicies.insert per creare una pianificazione di snapshot. Come minimo, devi includere lo snapshot nome pianificazione, località regionale di archiviazione degli snapshot e frequenza degli snapshot.

Per impostazione predefinita, il parametro onSourceDiskDelete è impostato su keepAutoSnapshots. Ciò significa che se il disco di origine viene eliminato, lo snapshot generato automaticamente per quel disco vengono conservati per un periodo indeterminato. In alternativa, puoi impostare il flag a applyRetentionPolicy per applicare il criterio di conservazione.

L'esempio seguente imposta una pianificazione di snapshot giornaliera che inizia alle 12:00 UTC e si ripete ogni giorno. L'esempio imposta anche un criterio di conservazione di 5 giorni; dopo 5 giorni, gli snapshot vengono rimossi automaticamente.

Puoi anche includere opzioni di località istantanee e le etichette di snapshot nella tua richiesta di assicurarti che gli snapshot siano archiviati nella località scelta.

POST https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/regions/[REGION]/resourcePolicies

{
 "name": "[SCHEDULE_NAME]",
 "description": "[SCHEDULE_DESCRIPTION]",
 "snapshotSchedulePolicy": {
   "schedule": {
     "dailySchedule": {
       "startTime": "12:00",
       "daysInCycle": "1"
     }
   },
   "retentionPolicy": {
     "maxRetentionDays": "5"
   },
   "snapshotProperties": {
     "guestFlush": "False",
     "labels": {
       "env": "dev",
       "media": "images"
     },
     "storageLocations": ["US"]
   }
 }
}

dove:

  • [PROJECT_ID] è il nome del progetto.
  • [REGION] è la località del criterio delle risorse di pianificazione degli snapshot.
  • [SCHEDULE_DESCRIPTION] è la descrizione della pianificazione di snapshot.
  • [SCHEDULE_NAME] è il nome della pianificazione di snapshot.

Analogamente, puoi creare una pianificazione settimanale o mensile. Esamina il Riferimento API per informazioni dettagliate sull'impostazione di una programmazione settimanale o mensile.

Ad esempio, la seguente richiesta crea una pianificazione settimanale che viene eseguita il martedì e il giovedì, rispettivamente alle 9:00 e alle 2:00.

POST https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/regions/[REGION]/resourcePolicies

{
 "name": "[SCHEDULE_NAME]",
 "description": "[SCHEDULE_DESCRIPTION]",
 "snapshotSchedulePolicy": {
   "schedule": {
     "weeklySchedule": {
       "dayOfWeeks": [
       {
         "day": "Monday",
         "startTime": "9:00"
       },
       {
         "day": "Thursday",
         "startTime": "2:00"
       }
       ]
     }
   },
  "retentionPolicy": {
    "maxRetentionDays": "5"
  },
  "snapshotProperties": {
    "guestFlush": "False",
    "labels": {
      "production": "webserver"
    },
    "storageLocations": ["US"]
  }
 }
}

Collega una pianificazione di snapshot a un disco

Quando hai una pianificazione, collegala a un disco esistente. Usa la console gcloud o il metodo dell'API Compute Engine.

Console

Collega una pianificazione di snapshot a un disco esistente.

  1. Nella console Google Cloud, vai alla pagina Dischi.

    Vai alla pagina Dischi

  2. Seleziona il nome del disco a cui vuoi collegare uno snapshot programmazione. Viene visualizzata la pagina Gestisci disco.
  3. Nella pagina Gestisci disco, passa il mouse e fai clic sul pulsante Altre azioni e seleziona Modifica.
  4. Per aggiungere la pianificazione, utilizza il menu a discesa Pianificazione snapshot. al disco. In alternativa, crea una nuova pianificazione.
  5. Se hai creato una nuova pianificazione, fai clic su Crea.
  6. Fai clic su Salva per completare l'attività.

gcloud

Per collegare una pianificazione di snapshot a un disco, utilizza disks add-resource-policies Comando gcloud.

gcloud compute disks add-resource-policies [DISK_NAME] \
    --resource-policies [SCHEDULE_NAME] \
    --zone [ZONE]

dove:

  • [DISK_NAME] è il nome del disco esistente.
  • [SCHEDULE_NAME] è il nome della pianificazione di snapshot.
  • [ZONE] è la posizione del tuo disco.

API

Nell'API, crea una richiesta POST per disks.addResourcePolicies per collegare una pianificazione di snapshot a un disco esistente.

POST https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/[ZONE]/disks/[DISK_NAME]/addResourcePolicies

{
  "resourcePolicies": [
    "regions/[REGION]/resourcePolicies/[SCHEDULE_NAME]"
  ]
}

dove:

  • [PROJECT_ID] è il nome del progetto.
  • [ZONE] è la posizione del disco.
  • [REGION] è la località della pianificazione di snapshot.
  • [DISK_NAME] è il nome del disco.
  • [SCHEDULE_NAME] è il nome della pianificazione di snapshot in quel che applichi al disco.

Ripristina i dati da uno snapshot

Se hai eseguito il backup di un disco di avvio o non di avvio con uno snapshot, puoi creare un nuovo il disco basato sullo snapshot.

Limitazioni

  • Il nuovo disco deve avere almeno le stesse dimensioni dell'origine originale per lo snapshot. Se crei un disco più grande rispetto al disco di origine originale per lo snapshot, devi ridimensionare il file su quel disco permanente per includere lo spazio aggiuntivo su disco. A seconda del sistema operativo e tipo di file system, potrebbe essere necessario utilizzare uno strumento di ridimensionamento diverso del file system. Per ulteriori informazioni, consulta la documentazione del tuo sistema operativo.

Crea un disco da uno snapshot e collegalo a una VM

Console

  1. Nella console Google Cloud, vai alla pagina Snapshot.

    Vai a Snapshot

  2. Trova il nome dello snapshot da ripristinare.

  3. Vai alla pagina Dischi.

    Vai alla pagina Dischi

  4. Fai clic su Crea nuovo disco.

  5. Specifica i seguenti parametri di configurazione:

    • Un nome per il disco.
    • Un tipo per il disco.
    • Facoltativamente, puoi eseguire l'override della selezione predefinita per la regione e la zona. Puoi selezionare qualsiasi regione e zona, indipendentemente dallo spazio di archiviazione località dello snapshot di origine.

  6. In Tipo di origine, fai clic su Istantanea.

  7. Seleziona il nome dello snapshot da ripristinare.

  8. Seleziona le dimensioni del nuovo disco, in gigabyte. Questo numero deve essere uguale rispetto al disco di origine originale per lo snapshot.

  9. Fai clic su Crea per creare il disco.

Potrai quindi collegare il nuovo disco a un'istanza esistente.

  1. Vai alla pagina Istanze VM.

    Vai alla pagina Istanze VM

  2. Fai clic sul nome dell'istanza in cui vuoi ripristinare il disco non di avvio.
  3. Nella parte superiore della pagina dei dettagli dell'istanza, fai clic su Modifica.
  4. In Dischi aggiuntivi, fai clic su Collega disco esistente.
  5. Seleziona il nome del nuovo disco creato dallo snapshot.
  6. Fai clic su Fine per collegare il disco.
  7. In fondo alla pagina dei dettagli dell'istanza, fai clic su Salva per applicare le modifiche apportate all'istanza.

gcloud

  1. Utilizza la Comando gcloud compute snapshots list per trovare il nome dello snapshot che vuoi ripristinare:

    gcloud compute snapshots list

  2. Usa il comando gcloud compute snapshots describe per trovare le dimensioni dello snapshot che vuoi ripristinare:

    gcloud compute snapshots describe SNAPSHOT_NAME

    Sostituisci SNAPSHOT_NAME con il nome dello snapshot ripristinato.

  3. Utilizza la Comando gcloud compute disks create per creare un nuovo comando regionale disco a livello di zona dal tuo senza dover creare uno snapshot. Se hai bisogno di un disco permanente SSD per una velocità effettiva aggiuntiva o IOPS, includi il flag --type e specifica pd-ssd.

    gcloud compute disks create DISK_NAME \
    --size=DISK_SIZE \
    --source-snapshot=SNAPSHOT_NAME \
    --type=DISK_TYPE

    Sostituisci quanto segue:

    • DISK_NAME: il nome del nuovo disco.
    • DISK_SIZE: le dimensioni del nuovo disco, in gigabyte. Questo numero deve essere uguale o superiore a quello del disco di origine originale per lo snapshot.
    • SNAPSHOT_NAME: il nome dello snapshot da ripristinare.
    • DISK_TYPE: URL completo o parziale per il tipo del disco. Ad esempio: https://www.googleapis.com/compute/v1/projects/PROJECT_ID /zones/ZONE/diskTypes/pd-ssd.

  4. Collega il nuovo disco a un'istanza esistente utilizzando gcloud compute instances attach-disk comando:

    gcloud compute instances attach-disk INSTANCE_NAME \
    --disk DISK_NAME

    Sostituisci quanto segue:

    • INSTANCE_NAME è il nome dell'istanza.
    • DISK_NAME è il nome del disco creato dallo snapshot.

API

  1. Crea una richiesta GET per snapshots.list per visualizzare l'elenco degli snapshot del progetto.

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

    Sostituisci PROJECT_ID con l'ID progetto.

  2. Crea una richiesta POST per creare un disco a livello di zona utilizzando il disks.insert . Includi name, sizeGb e type proprietà. Per ripristinare un disco utilizzando uno snapshot, devi includere la proprietà sourceSnapshot.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/disks

{
 "name": "DISK_NAME",
 "sizeGb": "DISK_SIZE",
 "type": "zones/ZONE/diskTypes/DISK_TYPE"
 "sourceSnapshot": "SNAPSHOT_NAME"
}

    Sostituisci quanto segue:

    • PROJECT_ID: il tuo ID progetto.
    • ZONE la zona in cui l'istanza e il nuovo in cui si trovano.
    • DISK_NAME: il nome del nuovo disco.
    • DISK_SIZE: le dimensioni del nuovo disco, in gigabyte. Questo numero deve essere uguale o superiore a quello del disco di origine originale per lo snapshot.
    • DISK_TYPE: URL completo o parziale per il tipo del disco. Ad esempio https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ ZONE/diskTypes/pd-ssd.
    • SNAPSHOT_NAME: lo snapshot di origine per il disco che stai ripristinando.

  3. Puoi quindi collegare il nuovo disco a un'istanza esistente creando una richiesta POST al instances.attachDisk , e includere l'URL al disco di zona appena creato dalla tua senza dover creare uno snapshot.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/attachDisk

{
 "source": "/compute/v1/projects/PROJECT_ID/zones/ZONE/disks/DISK_NAME"
}

    Sostituisci quanto segue:

    • PROJECT_ID è l'ID progetto.
    • ZONE è la zona in cui si trovano l'istanza e il nuovo disco.
    • INSTANCE_NAME è il nome dell'istanza in cui stai aggiungendo un nuovo disco.
    • DISK_NAME è il nome del nuovo disco.

Vai

Go

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

Per eseguire l'autenticazione su Vertex AI, 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"
)

// createDiskFromSnapshot creates a new disk in a project in given zone.
func createDiskFromSnapshot(
	w io.Writer,
	projectID, zone, diskName, diskType, snapshotLink string,
	diskSizeGb int64,
) error {
	// projectID := "your_project_id"
	// zone := "us-west3-b" // should match diskType below
	// diskName := "your_disk_name"
	// diskType := "zones/us-west3-b/diskTypes/pd-ssd"
	// snapshotLink := "projects/your_project_id/global/snapshots/snapshot_name"
	// diskSizeGb := 120

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

	req := &computepb.InsertDiskRequest{
		Project: projectID,
		Zone:    zone,
		DiskResource: &computepb.Disk{
			Name:           proto.String(diskName),
			Zone:           proto.String(zone),
			Type:           proto.String(diskType),
			SourceSnapshot: proto.String(snapshotLink),
			SizeGb:         proto.Int64(diskSizeGb),
		},
	}

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

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

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

	return nil
}

Java

Java

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

Per eseguire l'autenticazione su Vertex AI, 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.InsertDiskRequest;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateDiskFromSnapshot {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.

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

    // Name of the zone in which you want to create the disk.
    String zone = "europe-central2-b";

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

    // The type of disk you want to create. This value uses the following format:
    // "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
    // For example: "zones/us-west3-b/diskTypes/pd-ssd"
    String diskType = String.format("zones/%s/diskTypes/pd-ssd", zone);

    // Size of the new disk in gigabytes.
    long diskSizeGb = 10;

    // The full path and name of the snapshot that you want to use as the source for the new disk.
    // This value uses the following format:
    // "projects/{projectName}/global/snapshots/{snapshotName}"
    String snapshotLink = String.format("projects/%s/global/snapshots/%s", projectId,
        "SNAPSHOT_NAME");

    createDiskFromSnapshot(projectId, zone, diskName, diskType, diskSizeGb, snapshotLink);
  }

  // Creates a new disk in a project in given zone, using a snapshot.
  public static void createDiskFromSnapshot(String projectId, String zone, String diskName,
      String diskType, long diskSizeGb, String snapshotLink)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `disksClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (DisksClient disksClient = DisksClient.create()) {

      // Set the disk properties and the source snapshot.
      Disk disk = Disk.newBuilder()
          .setName(diskName)
          .setZone(zone)
          .setSizeGb(diskSizeGb)
          .setType(diskType)
          .setSourceSnapshot(snapshotLink)
          .build();

      // Create the insert disk request.
      InsertDiskRequest insertDiskRequest = InsertDiskRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setDiskResource(disk)
          .build();

      // Wait for the create disk operation to complete.
      Operation response = disksClient.insertAsync(insertDiskRequest)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Disk creation failed!" + response);
        return;
      }
      System.out.println("Disk created. Operation Status: " + response.getStatus());
    }
  }
}

Node.js

Node.js

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida di Vertex AI con librerie client. Per ulteriori informazioni, consulta API Node.js Vertex AI documentazione di riferimento.

Per eseguire l'autenticazione su Vertex AI, 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 zone = 'europe-central2-b';
// const diskName = 'YOUR_DISK_NAME';
// const diskType = 'zones/us-west3-b/diskTypes/pd-ssd';
// const diskSizeGb = 10;
// const snapshotLink = 'projects/project_name/global/snapshots/snapshot_name';

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

async function createDiskFromSnapshot() {
  const disksClient = new compute.DisksClient();

  const [response] = await disksClient.insert({
    project: projectId,
    zone,
    diskResource: {
      sizeGb: diskSizeGb,
      name: diskName,
      zone,
      type: diskType,
      sourceSnapshot: snapshotLink,
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

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

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

createDiskFromSnapshot();

Python

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, vedi Installare l'SDK Vertex AI per Python. Per ulteriori informazioni, consulta documentazione di riferimento dell'API Python. 

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


def create_disk_from_snapshot(
    project_id: str,
    zone: str,
    disk_name: str,
    disk_type: str,
    disk_size_gb: int,
    snapshot_link: str,
) -> compute_v1.Disk:
    """
    Creates a new disk in a project in given zone.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone in which you want to create the disk.
        disk_name: name of the disk you want to create.
        disk_type: the type of disk you want to create. This value uses the following format:
            "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "zones/us-west3-b/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        snapshot_link: a link to the snapshot you want to use as a source for the new disk.
            This value uses the following format: "projects/{project_name}/global/snapshots/{snapshot_name}"

    Returns:
        An unattached Disk instance.
    """
    disk_client = compute_v1.DisksClient()
    disk = compute_v1.Disk()
    disk.zone = zone
    disk.size_gb = disk_size_gb
    disk.source_snapshot = snapshot_link
    disk.type_ = disk_type
    disk.name = disk_name
    operation = disk_client.insert(project=project_id, zone=zone, disk_resource=disk)

    wait_for_extended_operation(operation, "disk creation")

    return disk_client.get(project=project_id, zone=zone, disk=disk_name)

Monta il disco

  1. Nel terminale, usa il comando lsblk per elencare i dischi collegato all'istanza e trova il disco che vuoi montare.

    $ sudo lsblk

NAME   MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda      8:0    0   10G  0 disk
└─sda1   8:1    0   10G  0 part /
sdb      8:16   0  250G  0 disk

    In questo esempio, sdb è il nome del nuovo campo disco.

  2. Utilizza lo strumento di montaggio per montare il disco nell'istanza e abilitare l'opzione discard:

    $ sudo mount -o discard,defaults /dev/DEVICE_NAME /home/jupyter

    Sostituisci quanto segue:

    • DEVICE_NAME: il nome del dispositivo del disco su .

  3. Configura le autorizzazioni di lettura e scrittura sul disco. Per questo esempio, concedi l'accesso in scrittura al disco a tutti gli utenti.

    $ sudo chmod a+w /home/jupyter

Passaggi successivi