Duplica un disco con cloni

Questo documento fornisce informazioni sul funzionamento dei cloni di dischi e su come crearne uno. La clonazione dei dischi consente di creare copie immediatamente utilizzabili dei dischi esistenti nella stessa località (zona o regione). Crea un clone del disco in scenari in cui vuoi una copia di un disco esistente che puoi collegare immediatamente a una VM, ad esempio:

Creazione di ambienti di gestione temporanea mediante la duplicazione dei dati di produzione per eseguire il debug senza disturbare la produzione
Esecuzione di scansioni antimalware non distruttive di un disco senza influire sulle prestazioni di un workload di produzione
Creazione di copie per la verifica del backup del database
Spostamento di dati del disco non di avvio in un nuovo progetto
Duplicazione dei dischi durante lo scale out delle VM

Per attivare ripristino di emergenza per i tuoi dati, esegui il backup del disco con snapshot standard anziché utilizzare cloni del disco. Per acquisire i contenuti dei dischi a intervalli regolari senza creare nuovi dischi, utilizza gli snapshot istantanei, perché sono più efficienti in termini di spazio di archiviazione rispetto ai cloni. Per ulteriori opzioni di protezione dei dischi, consulta Opzioni di protezione dei dati.

Prima di iniziare

Se non l'hai ancora fatto, configura l'autenticazione. L'autenticazione verifica la tua identità per l'accesso ad API e servizi Google Cloud . Per eseguire codice o esempi da un ambiente di sviluppo locale, puoi autenticarti su Compute Engine selezionando una delle seguenti opzioni:
Seleziona la scheda relativa a come intendi utilizzare i campioni in questa pagina:
Console

Quando utilizzi la console Google Cloud per accedere ai servizi Google Cloud e alle API, non devi configurare l'autenticazione.
gcloud
1. Installa Google Cloud CLI. Dopo l'installazione, inizializza Google Cloud CLI eseguendo il comando seguente:
  gcloud init
  Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.
  
  Nota:se hai installato gcloud CLI in precedenza, assicurati di avere l'ultima versione eseguendo gcloud components update.
Imposta una regione e una zona predefinite.

Terraform

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

Installa Google Cloud CLI.
Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.
Se utilizzi una shell locale, crea le credenziali di autenticazione locali per il tuo account utente:
```
gcloud auth application-default login
```
Non è necessario eseguire questa operazione se utilizzi Cloud Shell.

Se viene restituito un errore di autenticazione e utilizzi un provider di identità (IdP) esterno, verifica di aver acceduto a gcloud CLI con la tua identità federata.

Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

Go

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

Installa Google Cloud CLI.
Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.
Se utilizzi una shell locale, crea le credenziali di autenticazione locali per il tuo account utente:
```
gcloud auth application-default login
```
Non è necessario eseguire questa operazione se utilizzi Cloud Shell.

Se viene restituito un errore di autenticazione e utilizzi un provider di identità (IdP) esterno, verifica di aver acceduto a gcloud CLI con la tua identità federata.

Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

Java

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

Installa Google Cloud CLI.
Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.
Se utilizzi una shell locale, crea le credenziali di autenticazione locali per il tuo account utente:
```
gcloud auth application-default login
```
Non è necessario eseguire questa operazione se utilizzi Cloud Shell.

Se viene restituito un errore di autenticazione e utilizzi un provider di identità (IdP) esterno, verifica di aver acceduto a gcloud CLI con la tua identità federata.

Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

Python

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

Installa Google Cloud CLI.
Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.
Se utilizzi una shell locale, crea le credenziali di autenticazione locali per il tuo account utente:
```
gcloud auth application-default login
```
Non è necessario eseguire questa operazione se utilizzi Cloud Shell.

Se viene restituito un errore di autenticazione e utilizzi un provider di identità (IdP) esterno, verifica di aver acceduto a gcloud CLI con la tua identità federata.

Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

REST

Per utilizzare gli esempi di API REST in questa pagina in un ambiente di sviluppo locale, utilizzi le credenziali che fornisci a gcloud CLI.

Installa Google Cloud CLI.

Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.

Per saperne di più, consulta Autenticati per usare REST nella documentazione sull'autenticazione di Google Cloud .

Riepilogo dei casi d'uso

Oltre a duplicare un disco per test e debug rapidi, puoi attivare l'alta affidabilità per un disco a livello di zona creando un clone regionale dal disco a livello di zona. Quando crei un disco regionale da un disco zonale, il disco regionale ha una replica del disco in due zone all'interno della stessa regione. Dopo aver creato il disco a livello di regione, utilizzi il nuovo disco a livello di regione anziché il disco a livello di zona. Nell'improbabile caso di un'interruzione in una zona, puoi comunque accedere ai dati dalla replica nell'altra zona.

Questa tabella riepiloga i diversi tipi di cloni supportati da Compute Engine.

Tipo di clonazione	Quando utilizzarlo	Tipi di dischi supportati
Clone a livello di zona da un disco a livello di zona	Crea una copia identica di un disco nella stessa zona per una delle seguenti attività: Scalabilità orizzontale dei carichi di lavoro duplicando i dischi esistenti per le nuove VM. Ambienti di gestione temporanea, debug o test con dati di produzione. Analisi di un disco in produzione alla ricerca di malware. Spostamento di un disco in un nuovo progetto.	Persistent Disk: Persistent Disk standard, bilanciato e SSD Hyperdisk: tutti i tipi di Hyperdisk, tranne Hyperdisk Balanced High Availability
Clone regionale di un disco a livello di zona	Rendere un workload zonale a disponibilità elevata aggiungendo una replica dei dati in un'altra zona. Analisi di un disco in produzione alla ricerca di malware.	Persistent Disk: Persistent Disk standard, bilanciato e SSD Hyperdisk: Hyperdisk Extreme e Hyperdisk bilanciato
Clone regionale di un disco regionale	Crea una copia identica di un disco a livello di regione nella stessa regione per: Test o scalabilità orizzontale di workload regionali ad alta disponibilità (HA). Mantenere la ridondanza dei dati in due zone durante l'esecuzione di attività amministrative o test. Creazione di copie dei volumi del database HA per la verifica.	Persistent Disk: Persistent Disk bilanciato a livello di regione, SSD e Standard Persistent Disk Hyperdisk: Hyperdisk Balanced High Availability

Come funziona la clonazione di dischi

Quando cloni un disco, viene creato un nuovo disco contenente tutti i dati del disco di origine. Puoi creare un clone del disco anche se il disco esistente è collegato a un'istanza VM. Dopo aver clonato un disco, puoi eliminare il disco di origine senza il rischio di eliminare il clone.

Per impostazione predefinita, i cloni di un disco ereditano le dimensioni, i limiti di rendimento, il tipo e la zona o la regione esatta. Puoi modificare alcune di queste proprietà nel seguente modo:

Dimensioni: puoi creare un clone di dimensioni maggiori rispetto al disco di origine, ma non di dimensioni inferiori.
Prestazioni: per i volumi Hyperdisk, puoi specificare un limite di prestazioni diverso per il clone. I clone regionali dei volumi Hyperdisk zonali sono volumi Hyperdisk Balanced High Availability e potrebbero avere limiti di prestazioni diversi.
Località: per impostazione predefinita, il clone di un disco viene creato nella stessa zona per i dischi a livello di zona e nella stessa regione per i dischi a livello di regione. Tuttavia, per creare un clone a livello di regione di un disco a livello di zona, puoi specificare una seconda zona che si trova all'interno della stessa regione del disco a livello di zona. Il nuovo clone è anche chiamato clone regionale e ha una replica ciascuno nella zona del disco di origine e nella seconda zona che hai specificato.
Tipo: i clone regionali di volumi Hyperdisk bilanciati o Hyperdisk Extreme a livello di zona sono volumi Hyperdisk Balanced High Availability.

Volumi Hyperdisk regionali clonati da volumi Hyperdisk zonali

Un clone regionale di un volume Hyperdisk a livello di zona esistente è sempre un nuovo volume Hyperdisk Balanced High Availability. Questo perché Hyperdisk Balanced High Availability è l'unico Hyperdisk regionale supportato. Il modo in cui crei un disco Hyperdisk regionale da un disco Hyperdisk a livello di zona dipende dal suo tipo.

Per i volumi Hyperdisk ML e Hyperdisk Throughput a livello di zona, non puoi creare un disco a livello di regione clonando il disco di origine. Devi creare un nuovo volume Hyperdisk Balanced High Availability da uno snapshot del disco a livello di zona.
Per i volumi Hyperdisk bilanciato e Hyperdisk Extreme a livello di zona, crea un nuovo volume Hyperdisk Balanced High Availability creando un clone regionale di un volume Hyperdisk bilanciato o Hyperdisk Extreme a livello di zona.

Prestazioni dei volumi Hyperdisk Balanced High Availability clonati da dischi di zona

Quando crei un nuovo volume Hyperdisk Balanced High Availability da un volume Hyperdisk Balanced o Hyperdisk Extreme, il nuovo disco eredita le dimensioni del disco di origine, ma puoi specificare dimensioni diverse.

Le prestazioni di cui è stato eseguito il provisioning massime del nuovo disco potrebbero essere inferiori a quelle del disco di origine, perché Hyperdisk Extreme e Hyperdisk Balanced hanno limiti di prestazioni superiori rispetto a Hyperdisk Balanced High Availability, come elencato nella tabella seguente.

Tipo di Hyperdisk	Numero massimo di operazioni di I/O al secondo (IOPS)	Throughput massimo ( MiB/s)
Hyperdisk bilanciato con disponibilità elevata	100.000	2400
Hyperdisk bilanciato	160.000	2400
Hyperdisk Extreme	350.000	5000

Puoi specificare i limiti per il nuovo disco regionale, ma non possono superare i limiti di prestazioni massimi offerti da Hyperdisk Balanced High Availability: 100.000 IOPS e 2400 MiB/s.

Se non specifichi un limite di prestazioni per il nuovo disco, Compute Engine esegue il provisioning del disco con IOPS e throughput predefiniti che dipendono dalle dimensioni del volume Hyperdisk Balanced High Availability. Per i limiti predefiniti, consulta Limiti predefiniti di dimensioni e prestazioni di Hyperdisk Balanced High Availability.

Per raggiungere 100.000 IOPS, le dimensioni di un volume Hyperdisk Balanced High Availability devono essere almeno 200 GiB, quindi potrebbe essere necessario aumentare anche le dimensioni sottoposte a provisioning del clone regionale.

Esempio

Considera un volume Hyperdisk Extreme da 150 GiB, hdx-1, di cui è stato eseguito il provisioning con 180.000 IOPS.

Se crei un clone regionale di hdx-1 e non specifichi una nuova dimensione o un nuovo limite di prestazioni, Compute Engine crea un volume Hyperdisk Balanced High Availability di 150 GiB con il limite di IOPS predefinito per quella dimensione: 3900 IOPS.

Se non aumenti le dimensioni, puoi specificare fino a 75.000 IOPS per il clone regionale.

Volumi Persistent Disk a livello di regione clonati da volumi Persistent Disk a livello di zona

Un volume Persistent Disk a livello di regione clonato da un Persistent Disk a livello di zona ha lo stesso tipo del clone. Ad esempio, se cloni un Persistent Disk standard a livello di zona, crei un volume Persistent Disk standard a livello di regione.

Tuttavia, i cloni regionali dei volumi Persistent Disk potrebbero avere limiti di dimensioni e prestazioni diversi rispetto al disco di origine a livello di zona, come segue.

Limiti di prestazioni inferiori: i cloni regionali di Persistent Disk potrebbero avere limiti di prestazioni di IOPS e throughput inferiori rispetto al disco di origine. Questo perché il Persistent Disk zonale offre limiti di prestazioni massimi più elevati per le istanze. Ad esempio, il disco permanente bilanciato a livello di zona ha un limite massimo di 80.000 IOPS di scrittura, mentre il disco permanente bilanciato a livello di regione ha un limite di 60.000 IOPS di scrittura.

Per limiti di prestazioni dettagliati, confronta i limiti di prestazioni per Persistent Disk a livello di zona e i limiti di prestazioni per Persistent Disk a livello di regione.
Per il disco permanente standard a livello di regione, una dimensione minima di 200 GiB: il disco permanente standard a livello di regione ha una dimensione minima di 200 GiB. Pertanto, per creare un clone regionale di un volume Standard Persistent Disk a livello di zona di dimensioni comprese tra 10 e 199 GiB, devi specificare una dimensione di almeno 200 GiB per il disco regionale.

Tipi di dischi supportati

Puoi clonare tutti i tipi di Persistent Disk e Hyperdisk se il clone si trova nella stessa località (zona o regione) del disco di origine.

La clonazione di un disco a livello di zona in un disco regionale è supportata solo per i seguenti tipi di disco:

Google Cloud Hyperdisk:
- Hyperdisk bilanciato
- Hyperdisk Extreme
Per creare un disco a livello di regione da un volume Hyperdisk ML o Hyperdisk Throughput, crea uno snapshot, quindi crea un volume Hyperdisk Balanced High Availability dallo snapshot.
Persistent Disk:
- Disco permanente bilanciato
- Disco permanente SSD
- Disco permanente standard

Limitazioni

I cloni dei dischi presentano le seguenti limitazioni:

Non puoi creare un volume Hyperdisk Balanced High Availability clonando un volume Hyperdisk ML o Hyperdisk Throughput a livello di zona. Per creare un volume Hyperdisk Balanced High Availability per questi tipi di Hyperdisk, completa i passaggi descritti in Passa da un disco a livello di zona a un volume Hyperdisk Balanced High Availability a livello di regione.
Non puoi clonare un disco che si trova in un pool di archiviazione.
Non puoi creare un clone di un disco a livello di zona esistente in una zona diversa.
Le dimensioni del clone devono essere almeno uguali a quelle del disco di origine. Se crei un clone utilizzando la console Google Cloud , non puoi specificare le dimensioni del disco e il clone avrà le stesse dimensioni del disco di origine.
Se cloni un volume Hyperdisk o Persistent Disk dalla console Google Cloud , non puoi specificare le prestazioni di cui è stato eseguito il provisioning per il disco clonato.
Se utilizzi una chiave di crittografia fornita dal cliente (CSEK) o una chiave di crittografia gestita dal cliente (CMEK) per criptare il disco di origine, devi utilizzare la stessa chiave per criptare il clone. Per saperne di più, consulta Crea un clone di un disco di origine criptato.
Non puoi eliminare il disco di origine durante la creazione del clone.
L'istanza di computing a cui è collegato il disco di origine non potrà essere attivata durante la creazione del clone.
Se il disco di origine è stato contrassegnato per l'eliminazione insieme alla VM a cui è collegato, non puoi eliminare la VM durante la creazione del clone.
Puoi creare al massimo un clone di un determinato disco di origine o dei suoi cloni ogni 30 secondi.
Puoi avere al massimo 1000 cloni simultanei di un determinato disco di origine o dei suoi cloni. Il superamento di questo limite restituisce un errore internalError. Tuttavia, se crei un clone del disco e lo elimini in un secondo momento, il clone del disco eliminato non è incluso in questo limite.
Dopo la clonazione di un disco, eventuali cloni successivi di quel disco o dei suoi cloni vengono conteggiati ai fini del limite di 1000 cloni di dischi simultanei per il disco di origine iniziale e ai fini del limite di creazione di massimo un clone ogni 30 secondi.
Se crei un disco a livello di regione clonando un disco a livello di zona, puoi clonare al massimo 1 TiB di capacità ogni 15 minuti, con un limite di richiesta burst di 257 TiB.
Non puoi creare un clone come disco a livello di zona da un disco a livello di regione.
Per creare un clone come disco a livello di regione da un disco di origine a livello di zona, una delle zone di replica del clone del disco a livello di regione deve corrispondere alla zona del disco di origine.
Dopo la creazione, un clone di disco a livello di regione è utilizzabile in media entro 3 minuti. Tuttavia, potrebbero essere necessarie decine di minuti per la replica completa del disco e per raggiungere uno stato in cui il Recovery Point Objective (RPO) è prossimo allo zero.
Se hai creato un disco a livello di zona da un'immagine, non puoi utilizzarlo per creare un clone del disco a livello di regione.

Messaggi di errore

Se superi i limiti di frequenza della clonazione, la richiesta non va a buon fine e restituisce il seguente errore:

RATE LIMIT: ERROR: (gcloud.compute.disks.create) Could not fetch resource:
 - Operation rate exceeded for resource RESOURCE. Too frequent operations from the source resource.

Crea cloni di dischi

Questa sezione spiega come duplicare un disco esistente e creare un clone del disco.

Per la procedura dettagliata, a seconda del tipo di creazione del clone del disco, consulta una delle seguenti sezioni di questo documento:

Per clonare un disco per test, debug o scalabilità rapida, Crea un clone del disco nella stessa posizione dell'origine
Per rendere un disco a livello di zona ad alta affidabilità, crea un clone di un disco a livello di regione da un disco a livello di zona.
Crea un clone di un disco di origine criptato

Autorizzazioni richieste per questa attività

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

compute.disks.create sul progetto
compute.disks.useReadOnly sul disco di origine
Se il disco di origine è il disco di avvio di un'istanza a cui è collegato un account di servizio: iam.serviceAccounts.actAs sul account di servizio dell'istanza

Crea un clone del disco nella stessa località dell'origine

Puoi creare un clone di un disco esistente a livello di zona o di regione che si trova nella stessa zona o regione, rispettivamente, del disco di origine utilizzando la consoleGoogle Cloud , Google Cloud CLI, REST o le librerie client di Cloud.

Console Google Cloud

Nella console Google Cloud , vai alla pagina Dischi.

Vai a Dischi
Nell'elenco dei dischi, vai al disco che vuoi clonare.
Nella colonna Azioni, fai clic sul pulsante del menu e seleziona Clona disco.

Nel riquadro Clona disco visualizzato, segui questi passaggi:
1. Nel campo Nome, specifica un nome per il disco clonato.
2. (Facoltativo) Per i dischi zonali, in Località, verifica che sia selezionata l'opzione Zona singola.
3. In Proprietà, rivedi altri dettagli del disco clonato.
4. Per completare la creazione del disco clonato, fai clic su Crea.

Google Cloud CLI

Per clonare un disco di origine a livello di zona e creare un nuovo disco a livello di zona, esegui il comando disks create e specifica il flag --source-disk:

gcloud compute disks create TARGET_DISK_NAME \
    --description="cloned disk" \
    --source-disk=projects/PROJECT_ID/zones/ZONE/disks/SOURCE_DISK_NAME

Sostituisci quanto segue:

TARGET_DISK_NAME: il nome del nuovo disco.
PROJECT_ID: l'ID progetto in cui vuoi clonare il disco.
ZONE: la zona del disco di origine e del nuovo disco.
SOURCE_DISK_NAME: il nome del disco di origine.

Terraform

Per creare un clone del disco, utilizza la risorsa google_compute_disk.

resource "google_compute_disk" "default" {
  name  = "disk-name1"
  type  = "pd-ssd"
  zone  = "us-central1-a"
  image = "debian-11-bullseye-v20220719"
  labels = {
    environment = "dev"
  }
  physical_block_size_bytes = 4096
}

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

Go

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

Per effettuare l'autenticazione in Compute Engine, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

import (
	"context"
	"fmt"
	"io"

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

// createDiskFromDisk creates a new disk with the contents of
// an already existitng disk. Type, and size and zone may differ.
func createDiskFromDisk(
	w io.Writer,
	projectID, zone, diskName, diskType, sourceDiskLink 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"
	// sourceDiskLink := "projects/your_project_id/global/disks/disk_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),
			SourceDisk: proto.String(sourceDiskLink),
			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

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

Per effettuare l'autenticazione in Compute Engine, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.


import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DisksClient;
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 CreateFromSource {

  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 project = "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.
    int diskSizeGb = 10;

    // A link to the disk you want to use as a source for the new disk.
    // This value uses the following format:
    // "projects/{project_name}/zones/{zone}/disks/{disk_name}"
    String diskLink = String.format("projects/%s/zones/%s/disks/%s", "PROJECT_NAME", "ZONE",
        "DISK_NAME");

    createDiskFromDisk(project, zone, diskName, diskType, diskSizeGb, diskLink);
  }

  // Creates a disk in a project in a given zone.
  public static void createDiskFromDisk(String project, String zone, String diskName,
      String diskType, int diskSizeGb, String diskLink)
      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()) {

      // Create the disk.
      Disk disk = Disk.newBuilder()
          .setZone(zone)
          .setSizeGb(diskSizeGb)
          .setSourceDisk(diskLink)
          .setType(diskType)
          .setName(diskName)
          .build();

      // Wait for the insert instance operation to complete.
      Operation operation = disksClient.insertAsync(project, zone, disk)
          .get(3, TimeUnit.MINUTES);

      if (operation.hasError()) {
        System.out.println("Disk creation failed!");
        throw new Error(operation.getError().toString());
      }
      System.out.println(
          "Disk created from source. Operation Status: " + operation.getStatus());
    }
  }
}

Python

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

Per effettuare l'autenticazione in Compute Engine, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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_disk(
    project_id: str,
    zone: str,
    disk_name: str,
    disk_type: str,
    disk_size_gb: int,
    disk_link: str,
) -> compute_v1.Disk:
    """
    Creates a disk in a project in a 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
        disk_link: a link to the disk you want to use as a source for the new disk.
            This value uses the following format: "projects/{project_name}/zones/{zone}/disks/{disk_name}"

    Returns:
        An attachable disk.
    """
    disk_client = compute_v1.DisksClient()
    disk = compute_v1.Disk()
    disk.zone = zone
    disk.size_gb = disk_size_gb
    disk.source_disk = disk_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)

REST

Per clonare un disco di origine a livello di zona e creare un nuovo disco a livello di zona, invia una richiesta POST al metodo compute.disks.insert. Nel corpo della richiesta, specifica i parametri name e sourceDisk. Il clone del disco eredita tutte le proprietà omesse dal disco di origine.

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

{
  "name": "TARGET_DISK_NAME"
  "sourceDisk": "projects/PROJECT_ID/zones/ZONE/disks/SOURCE_DISK_NAME"
}

Sostituisci quanto segue:

PROJECT_ID: l'ID progetto in cui vuoi clonare il disco.
ZONE: la zona del disco di origine e del nuovo disco.
TARGET_DISK_NAME: il nome del nuovo disco.
SOURCE_DISK_NAME: il nome del disco di origine.

Crea un clone di un disco a livello di regione da un disco a livello di zona

Puoi creare un nuovo disco a livello di regione clonando un disco a livello di zona esistente di uno dei seguenti tipi:

Hyperdisk bilanciato
Hyperdisk Extreme
Disco permanente standard, bilanciato e SSD

Se il disco di origine è un volume Hyperdisk Balanced o Hyperdisk Extreme, il disco regionale è sempre un volume Hyperdisk Balanced High Availability e non eredita le stesse prestazioni sottoposte a provisioning del disco zonale. Per impostare le prestazioni di provisioning del disco regionale, devi clonare il disco con Google Cloud CLI o REST. Se cloni il disco con la console Google Cloud , non puoi specificare un limite di prestazioni e viene eseguito il provisioning del disco con i limiti predefiniti per le sue dimensioni.

Console

Nella console Google Cloud , vai alla pagina Dischi.

Vai a Dischi
Nell'elenco dei dischi, vai al volume di disco permanente a livello di zona che vuoi clonare.
Nella colonna Azioni, fai clic sul pulsante del menu e seleziona Clona disco.

Nel riquadro Clona disco visualizzato, segui questi passaggi:
1. Nel campo Nome, specifica un nome per il disco clonato.
2. In Località, seleziona A livello di regione, quindi seleziona la zona di replica secondaria per il nuovo disco a livello di regione clonato.
3. In Proprietà, rivedi altri dettagli del disco clonato.
4. Per completare la creazione del disco clonato, fai clic su Crea.

gcloud

Per creare un clone del disco a livello di regione da un disco a livello di zona, esegui il comando gcloud compute disks create e specifica i parametri --region e --replica-zones.

Se il disco a livello di zona è un volume Hyperdisk bilanciato o Hyperdisk Extreme, specifica il flag --disk-type=hyperdisk-balanced-high-availability, poiché il disco a livello di regione deve essere un volume Hyperdisk Balanced High Availability.

Per clonare un volume Persistent Disk, ometti il flag --disk-type.

gcloud compute disks create TARGET_DISK_NAME \
  --description="zonal to regional cloned disk" \
  --region=CLONED_REGION \
  --source-disk=SOURCE_DISK_NAME \
  --source-disk-zone=SOURCE_DISK_ZONE \
  --replica-zones=SOURCE_DISK_ZONE,REPLICA_ZONE_2 \
  --project=PROJECT_ID \
  [ --disk-type=hyperdisk-balanced-high-availability ] \
  [ --provisioned-iops=IOPS_LIMIT ] \
  [ --provisioned-throughput=THROUGHPUT_LIMIT ]

Sostituisci quanto segue:

TARGET_DISK_NAME: il nome del nuovo clone del disco a livello di regione.
CLONED_REGION: la regione del disco di origine e del disco clonato.
SOURCE_DISK_NAME: il nome del disco a livello di zona da clonare.
SOURCE_DISK_ZONE: la zona del disco di origine. Inoltre, sarà la prima zona di replica per la copia del disco a livello di regione.
REPLICA_ZONE_2: la seconda zona di replica per la nuova copia del disco a livello di regione.
PROJECT_ID: l'ID progetto in cui vuoi clonare il disco.
IOPS_LIMIT: (facoltativo) per creare un disco Hyperdisk Balanced High Availability regionale, puoi specificare un numero di IOPS che il disco può gestire, fino a 100.000 IOPS.
THROUGHPUT_LIMIT: (facoltativo) per creare un disco Hyperdisk Balanced High Availability regionale, puoi specificare il throughput massimo in MiB/s che il disco può fornire, fino a 2400 MiB/s.

Terraform

Per creare un clone di un disco a livello di regione da un disco a livello di zona, utilizza la seguente risorsa. Se il disco di origine è un volume Hyperdisk bilanciato o Hyperdisk Extreme, imposta l'argomento type su hyperdisk-balanced-high-availability.

google_compute_region_disk

resource "google_compute_region_disk" "regiondisk" {
  name                      = "region-disk-name"
  snapshot                  = google_compute_snapshot.snapdisk.id
  type                      = "pd-ssd"
  region                    = "us-central1"
  physical_block_size_bytes = 4096
  size                      = 11

  replica_zones = ["us-central1-a", "us-central1-f"]
}

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

Go

Per effettuare l'autenticazione in Compute Engine, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

import (
	"context"
	"fmt"
	"io"

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

// createRegionalDiskFromDisk creates a new regional disk with the contents of
// an already existitng zonal disk. Disk type and size may differ.
func createRegionalDiskFromDisk(
	w io.Writer,
	projectID, region string, replicaZones []string,
	diskName, diskType, sourceDiskLink string,
	diskSizeGb int64,
) error {
	// projectID := "your_project_id"
	// region := "us-west3" // should match diskType below
	// diskName := "your_disk_name"
	// diskType := "regions/us-west3/diskTypes/pd-ssd"
	// sourceDiskLink := "projects/your_project_id/global/disks/disk_name"
	// diskSizeGb := 120

	// Exactly two replica zones must be specified
	replicaZoneURLs := []string{
		fmt.Sprintf("projects/%s/zones/%s", projectID, replicaZones[0]),
		fmt.Sprintf("projects/%s/zones/%s", projectID, replicaZones[1]),
	}

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

	req := &computepb.InsertRegionDiskRequest{
		Project: projectID,
		Region:  region,
		DiskResource: &computepb.Disk{
			Name:         proto.String(diskName),
			Region:       proto.String(region),
			Type:         proto.String(diskType),
			SourceDisk:   proto.String(sourceDiskLink),
			SizeGb:       proto.Int64(diskSizeGb),
			ReplicaZones: replicaZoneURLs,
		},
	}

	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

Per effettuare l'autenticazione in Compute Engine, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.


import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.RegionDisksClient;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class RegionalCreateFromSource {

  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 project = "YOUR_PROJECT_ID";

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

    // An iterable collection of zone names in which you want to keep
    // the new disks' replicas. One of the replica zones of the clone must match
    // the zone of the source disk.
    List<String> replicaZones = new ArrayList<>();

    // 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_NAME");

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

    // A link to the disk you want to use as a source for the new disk.
    // This value uses the following format:
    // "projects/{project_name}/zones/{zone}/disks/{disk_name}"
    String diskLink = String.format("projects/%s/zones/%s/disks/%s", "PROJECT_NAME", "ZONE",
        "DISK_NAME");

    // 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}"
    String snapshotLink = String.format("projects/%s/global/snapshots/%s", "PROJECT_NAME",
        "SNAPSHOT_NAME");

    createRegionalDisk(project, region, replicaZones, diskName, diskType, diskSizeGb,
        Optional.ofNullable(diskLink), Optional.ofNullable(snapshotLink));
  }

  // Creates a regional disk from an existing zonal disk in a given project.
  public static void createRegionalDisk(
      String project, String region, List<String> replicaZones, String diskName, String diskType,
      int diskSizeGb, Optional<String> diskLink, Optional<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 `regionDisksClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (RegionDisksClient regionDisksClient = RegionDisksClient.create()) {

      Disk.Builder diskBuilder = Disk.newBuilder()
          .addAllReplicaZones(replicaZones)
          .setName(diskName)
          .setType(diskType)
          .setSizeGb(diskSizeGb)
          .setRegion(region);

      // Set source disk if diskLink is not empty.
      diskLink.ifPresent(diskBuilder::setSourceDisk);

      // Set source snapshot if the snapshot link is not empty.
      snapshotLink.ifPresent(diskBuilder::setSourceSnapshot);

      // Wait for the operation to complete.
      Operation operation = regionDisksClient.insertAsync(project, region, diskBuilder.build())
          .get(3, TimeUnit.MINUTES);

      if (operation.hasError()) {
        System.out.println("Disk creation failed!");
        throw new Error(operation.getError().toString());
      }
      System.out.println(
          "Regional disk created. Operation Status: " + operation.getStatus());
    }
  }
}

Python

Per effettuare l'autenticazione in Compute Engine, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

from __future__ import annotations

from collections.abc import Iterable
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_regional_disk(
    project_id: str,
    region: str,
    replica_zones: Iterable[str],
    disk_name: str,
    disk_type: str,
    disk_size_gb: int,
    disk_link: str | None = None,
    snapshot_link: str | None = None,
) -> compute_v1.Disk:
    """
    Creates a regional disk from an existing zonal disk in a given project.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region in which you want to create the disk.
        replica_zones: an iterable collection of zone names in which you want to keep
            the new disks' replicas. One of the replica zones of the clone must match
            the zone of the source 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:
            "regions/{region}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "regions/us-west3/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        disk_link: a link to the disk you want to use as a source for the new disk.
            This value uses the following format: "projects/{project_name}/zones/{zone}/disks/{disk_name}"
        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 attachable regional disk.
    """
    disk_client = compute_v1.RegionDisksClient()
    disk = compute_v1.Disk()
    disk.replica_zones = replica_zones
    disk.size_gb = disk_size_gb
    if disk_link:
        disk.source_disk = disk_link
    if snapshot_link:
        disk.source_snapshot = snapshot_link
    disk.type_ = disk_type
    disk.region = region
    disk.name = disk_name
    operation = disk_client.insert(
        project=project_id, region=region, disk_resource=disk
    )

    wait_for_extended_operation(operation, "disk creation")

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

REST

Per creare un clone del disco a livello di regione da un disco a livello di zona, invia una richiesta POST al metodo compute.disks.insert e specifica i parametri sourceDisk e replicaZone.

Se il disco a livello di zona è un volume Hyperdisk Balanced o Hyperdisk Extreme, includi il campo type per creare un volume Hyperdisk Balanced High Availability.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/CLONED_REGION/disks

{
  "name": "TARGET_DISK_NAME",
  "sourceDisk": "projects/PROJECT_ID/zones/SOURCE_DISK_ZONE/disks/SOURCE_DISK_NAME",
  "replicaZone": "SOURCE_DISK_ZONE,REPLICA_ZONE_2",
  "type": "projects/PROJECT_ID/regions/CLONED_REGION/diskTypes/hyperdisk-balanced-high-availability",
  "provisionedIops": "IOPS_LIMIT",
  "provisionedThroughput": "THROUGHPUT_LIMIT"
}

Sostituisci quanto segue:

PROJECT_ID: l'ID progetto in cui vuoi clonare il disco.
TARGET_DISK_NAME: il nome del nuovo clone del disco a livello di regione.
CLONED_REGION: la regione del disco di origine e del disco clonato.
SOURCE_DISK_NAME: il nome del disco a livello di zona da clonare.
SOURCE_DISK_ZONE: la zona del disco di origine. Inoltre, sarà la prima zona di replica per la copia del disco a livello di regione.
REPLICA_ZONE_2: la seconda zona di replica per la nuova copia del disco a livello di regione.
IOPS_LIMIT: (facoltativo) per creare un disco Hyperdisk Balanced High Availability regionale, puoi specificare un numero di IOPS che il disco può gestire, fino a 100.000 IOPS.
THROUGHPUT_LIMIT: (facoltativo) per creare un disco Hyperdisk Balanced High Availability regionale, puoi specificare il throughput massimo in MiB/s che il disco può fornire, fino a 2400 MiB/s.

Crea un clone di un disco di origine criptato con CMEK o CSEK

Per creare un clone a livello di zona o di regione di un disco criptato con CSEK o CMEK, segui le procedure descritte nelle sezioni precedenti. Tuttavia, devi fornire anche la chiave utilizzata per criptare il disco di origine.

Crea cloni di dischi criptati con CSEK

Se utilizzi una CSEK per criptare il disco di origine, devi utilizzare la stessa chiave anche per criptare il clone.

Console

Nella console Google Cloud , vai alla pagina Dischi.

Vai a Dischi
Nell'elenco dei dischi permanenti a livello di zona, trova il disco che vuoi clonare.
Nella colonna Azioni, fai clic sul pulsante del menu e seleziona Clona disco.

Nel riquadro Clona disco visualizzato, segui questi passaggi:
1. Nel campo Nome, specifica un nome per il disco clonato.
2. Nel campo Decrittografia e crittografia, fornisci la chiave di crittografia del disco di origine.
3. In Proprietà, rivedi altri dettagli del disco clonato.
4. Per completare la creazione del disco clonato, fai clic su Crea.

gcloud

Per creare un clone di un disco di origine criptato con CSEK, esegui il comando gcloud compute disks create e fornisci la chiave di crittografia del disco di origine utilizzando il flag --csek-key-file. Se utilizzi una chiave con wrapping RSA, utilizza il comando gcloud beta compute disks create.

gcloud compute disks create TARGET_DISK_NAME \
  --description="cloned disk" \
  --source-disk=projects/PROJECT_ID/zones/ZONE/disks/SOURCE_DISK_NAME \
  --csek-key-file example-key-file.json

Sostituisci quanto segue:

TARGET_DISK_NAME: il nome del nuovo disco.
PROJECT_ID: l'ID progetto in cui vuoi clonare il disco.
ZONE: la zona del disco di origine e del nuovo disco.
SOURCE_DISK_NAME: il nome del disco di origine.

Go

Per effettuare l'autenticazione in Compute Engine, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

import (
	"context"
	"fmt"
	"io"

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

// Creates a zonal non-boot persistent disk in a project with the copy of data from an existing disk.
// The encryption key must be the same for the source disk and the new disk.
// The disk type and size may differ.
func createDiskFromCustomerEncryptedDisk(
	w io.Writer,
	projectID, zone, diskName, diskType string,
	diskSizeGb int64,
	diskLink, encryptionKey string,
) error {
	// projectID := "your_project_id"
	// zone := "us-west3-b" // should match diskType below
	// diskName := "your_disk_name"
	// diskType := "zones/us-west3/diskTypes/pd-ssd"
	// diskSizeGb := 120
	// diskLink := "projects/your_project_id/global/disks/disk_name"
	// encryptionKey := "SGVsbG8gZnJvbSBHb29nbGUgQ2xvdWQgUGxhdGZvcm0=" // in base64

	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),
			SizeGb:     proto.Int64(diskSizeGb),
			SourceDisk: proto.String(diskLink),
			DiskEncryptionKey: &computepb.CustomerEncryptionKey{
				RawKey: &encryptionKey,
			},
		},
	}

	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

Per effettuare l'autenticazione in Compute Engine, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.


import com.google.cloud.compute.v1.CustomerEncryptionKey;
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 com.google.protobuf.ByteString;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CloneEncryptedDisk {

  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 project = "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.
    int diskSizeGb = 10;

    // A link to the disk you want to use as a source for the new disk.
    // This value uses the following format:
    // "projects/{project_name}/zones/{zone}/disks/{disk_name}"
    String diskLink = String.format("projects/%s/zones/%s/disks/%s", "PROJECT_NAME", "ZONE",
        "DISK_NAME");

    // Customer-supplied encryption key used for encrypting data in the source disk.
    // The data will be encrypted with the same key in the new disk.
    byte[] encryptionKey = null;

    createDiskFromCustomerEncryptedKey(project, zone, diskName, diskType, diskSizeGb, diskLink,
        encryptionKey);
  }

  // Creates a zonal non-boot persistent disk in a project with the copy of data
  // from an existing disk.
  // The encryption key must be the same for the source disk and the new disk.
  public static void createDiskFromCustomerEncryptedKey(String project, String zone,
      String diskName, String diskType, int diskSizeGb, String diskLink, byte[] encryptionKey)
      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()) {

      // Create a disk and set the encryption key.
      Disk disk = Disk.newBuilder()
          .setZone(zone)
          .setName(diskName)
          .setType(diskType)
          .setSizeGb(diskSizeGb)
          .setSourceDisk(diskLink)
          .setDiskEncryptionKey(CustomerEncryptionKey
              .newBuilder()
              .setRawKeyBytes(ByteString.copyFrom(encryptionKey))
              .build())
          .build();

      // Wait for the insert disk operation to complete.
      Operation operation = disksClient.insertAsync(
          InsertDiskRequest.newBuilder()
              .setProject(project)
              .setZone(zone)
              .setDiskResource(disk)
              .build()).get(3, TimeUnit.MINUTES);

      if (operation.hasError()) {
        System.out.println("Disk creation failed!");
        throw new Error(operation.getError().toString());
      }
      System.out.println(
          "Disk cloned with customer encryption key. Operation Status: " + operation.getStatus());
    }
  }
}

Python

Per effettuare l'autenticazione in Compute Engine, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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_customer_encrypted_disk(
    project_id: str,
    zone: str,
    disk_name: str,
    disk_type: str,
    disk_size_gb: int,
    disk_link: str,
    encryption_key: bytes,
) -> compute_v1.Disk:
    """
    Creates a zonal non-boot persistent disk in a project with the copy of data from an existing disk.

    The encryption key must be the same for the source disk and the new disk.

    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
        disk_link: a link to the disk you want to use as a source for the new disk.
            This value uses the following format: "projects/{project_name}/zones/{zone}/disks/{disk_name}"
        encryption_key: customer-supplied encryption key used for encrypting
            data in the source disk. The data will be encrypted with the same key
            in the new disk.

    Returns:
        An attachable copy of an existing disk.
    """
    disk_client = compute_v1.DisksClient()
    disk = compute_v1.Disk()
    disk.zone = zone
    disk.size_gb = disk_size_gb
    disk.source_disk = disk_link
    disk.type_ = disk_type
    disk.name = disk_name
    disk.disk_encryption_key = compute_v1.CustomerEncryptionKey()
    disk.disk_encryption_key.raw_key = encryption_key
    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)

REST

Per creare un clone di un disco di origine criptato con CSEK, invia una richiesta POST al metodo compute.disks.insert e fornisci la chiave di crittografia del disco di origine utilizzando la proprietà diskEncryptionKey. Se utilizzi una chiave con wrapping RSA, utilizza la versione beta del metodo.

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

{
  "name": "TARGET_DISK_NAME"
  "sourceDisk": "projects/PROJECT_ID/zones/ZONE/disks/SOURCE_DISK_NAME"
  "diskEncryptionKey": {
    "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  },
}

Sostituisci quanto segue:

PROJECT_ID: l'ID progetto in cui vuoi clonare il disco.
ZONE: la zona del disco di origine e del nuovo disco.
TARGET_DISK_NAME: il nome del nuovo disco.
SOURCE_DISK_NAME: il nome del disco di origine.

Crea cloni di dischi criptati con CMEK

Se utilizzi una CMEK per criptare il disco di origine, devi utilizzare la stessa chiave anche per criptare il clone.

Console

Compute Engine cripta automaticamente il clone utilizzando la chiave di crittografia del disco di origine.

gcloud

Per creare un clone di un disco di origine criptato con CMEK, esegui il comando gcloud compute disks create e fornisci la chiave di crittografia del disco di origine utilizzando il flag --kms-key. Se utilizzi una chiave con wrapping RSA, utilizza il comando gcloud beta compute disks create.

gcloud compute disks create TARGET_DISK_NAME \
  --description="cloned disk" \
  --source-disk=projects/PROJECT_ID/zones/ZONE/disks/SOURCE_DISK_NAME \
  --kms-key projects/KMS_PROJECT_ID/locations/REGION/keyRings/KEY_RING/cryptoKeys/KEY

Sostituisci quanto segue:

TARGET_DISK_NAME: il nome del nuovo disco.
PROJECT_ID: l'ID progetto in cui vuoi clonare il disco.
ZONE: la zona del disco di origine e del nuovo disco.
SOURCE_DISK_NAME: il nome del disco di origine.
KMS_PROJECT_ID: l'ID progetto per la chiave di crittografia.
REGION: la regione della chiave di crittografia.
KEY_RING: le chiavi automatizzate della chiave di crittografia.
KEY: il nome della chiave di crittografia.

Go

Per effettuare l'autenticazione in Compute Engine, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

import (
	"context"
	"fmt"
	"io"

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

// Creates a zonal non-boot persistent disk in a project with the copy of data from an existing disk.
// The encryption key must be the same for the source disk and the new disk.
// The disk type and size may differ.
func createDiskFromKmsEncryptedDisk(
	w io.Writer,
	projectID, zone, diskName, diskType string,
	diskSizeGb int64,
	diskLink, kmsKeyLink string,
) error {
	// projectID := "your_project_id"
	// zone := "us-west3-b" // should match diskType below
	// diskName := "your_disk_name"
	// diskType := "zones/us-west3/diskTypes/pd-ssd"
	// diskSizeGb := 120
	// diskLink := "projects/your_project_id/global/disks/disk_name"
	// kmsKeyLink := "projects/your_kms_project_id/locations/us-central1/keyRings/your_key_ring/cryptoKeys/your_key"

	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),
			SizeGb:     proto.Int64(diskSizeGb),
			SourceDisk: proto.String(diskLink),
			DiskEncryptionKey: &computepb.CustomerEncryptionKey{
				KmsKeyName: &kmsKeyLink,
			},
		},
	}

	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

Per effettuare l'autenticazione in Compute Engine, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.


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

  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 project = "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.
    int diskSizeGb = 10;

    // A link to the disk you want to use as a source for the new disk.
    // This value uses the following format:
    // "projects/{project_name}/zones/{zone}/disks/{disk_name}"
    String diskLink = String.format("projects/%s/zones/%s/disks/%s", "PROJECT_NAME", "ZONE",
        "DISK_NAME");

    // URL of the key from KMS. The key might be from another project, as
    // long as you have access to it. The data will be encrypted with the same key
    // in the new disk. This value uses following format:
    // "projects/{kms_project_id}/locations/{region}/keyRings/{key_ring}/cryptoKeys/{key}"
    String kmsKeyName = "kms-key-name";

    createDiskFromKmsEncryptedDisk(project, zone, diskName, diskType, diskSizeGb, diskLink,
        kmsKeyName);
  }

  // Creates a zonal non-boot disk in a project with the copy of data from an existing disk.
  // The encryption key must be the same for the source disk and the new disk.
  public static void createDiskFromKmsEncryptedDisk(String project, String zone, String diskName,
      String diskType, int diskSizeGb, String diskLink, String kmsKeyName)
      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()) {

      // Create a disk and set the KMS encryption key name.
      Disk disk = Disk.newBuilder()
          .setZone(zone)
          .setName(diskName)
          .setType(diskType)
          .setSizeGb(diskSizeGb)
          .setSourceDisk(diskLink)
          .setDiskEncryptionKey(CustomerEncryptionKey.newBuilder()
              .setKmsKeyName(kmsKeyName)
              .build())
          .build();

      // Wait for the insert disk operation to complete.
      Operation operation = disksClient.insertAsync(
          InsertDiskRequest.newBuilder()
              .setProject(project)
              .setZone(zone)
              .setDiskResource(disk)
              .build()).get(3, TimeUnit.MINUTES);

      if (operation.hasError()) {
        System.out.println("Disk creation failed!");
        throw new Error(operation.getError().toString());
      }
      System.out.println(
          "Disk cloned with KMS encryption key. Operation Status: " + operation.getStatus());
    }
  }
}

Python

Per effettuare l'autenticazione in Compute Engine, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

from __future__ import annotations

import sys
from typing import Any

from google.api_core.exceptions import BadRequest
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_kms_encrypted_disk(
    project_id: str,
    zone: str,
    disk_name: str,
    disk_type: str,
    disk_size_gb: int,
    disk_link: str,
    kms_key_name: str,
) -> compute_v1.Disk:
    """
    Creates a zonal non-boot disk in a project with the copy of data from an existing disk.

    The encryption key must be the same for the source disk and the new disk.

    To run this method, the service-<project_id>@compute-system.iam.gserviceaccount.com
    service account needs to have the cloudkms.cryptoKeyEncrypterDecrypter role,
    as described in documentation:
    https://cloud.google.com/compute/docs/disks/customer-managed-encryption#before_you_begin

    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
        disk_link: a link to the disk you want to use as a source for the new disk.
            This value uses the following format: "projects/{project_name}/zones/{zone}/disks/{disk_name}"
        kms_key_name: URL of the key from KMS. The key might be from another project, as
            long as you have access to it. The data will be encrypted with the same key
            in the new disk. This value uses following format:
            "projects/{kms_project_id}/locations/{region}/keyRings/{key_ring}/cryptoKeys/{key}"

    Returns:
        An attachable copy of an existing disk.
    """
    disk_client = compute_v1.DisksClient()
    disk = compute_v1.Disk()
    disk.zone = zone
    disk.size_gb = disk_size_gb
    disk.source_disk = disk_link
    disk.type_ = disk_type
    disk.name = disk_name
    disk.disk_encryption_key = compute_v1.CustomerEncryptionKey()
    disk.disk_encryption_key.kms_key_name = kms_key_name
    try:
        operation = disk_client.insert(
            project=project_id, zone=zone, disk_resource=disk
        )
    except BadRequest as err:
        if "Permission 'cloudkms.cryptoKeyVersions.useToEncrypt' denied" in err.message:
            print(
                f"Please provide the cloudkms.cryptoKeyEncrypterDecrypter role to"
                f"service-{project_id}@compute-system.iam.gserviceaccount.com"
            )
        raise err

    wait_for_extended_operation(operation, "disk creation")

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

REST

Per creare un clone di un disco di origine criptato con CMEK, invia una richiesta POST al metodo compute.disks.insert e fornisci la chiave di crittografia del disco di origine utilizzando la proprietà kmsKeyName. Se utilizzi una chiave con wrapping RSA, utilizza la versione beta del metodo.

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

{
  "name": "TARGET_DISK_NAME"
  "sourceDisk": "projects/PROJECT_ID/zones/ZONE/disks/SOURCE_DISK_NAME"
  "diskEncryptionKey": {
    "kmsKeyName": "projects/KMS_PROJECT_ID/locations/REGION/keyRings/KEY_RING/cryptoKeys/KEY"
  },
}

Sostituisci quanto segue:

PROJECT_ID: l'ID progetto in cui vuoi clonare il disco.
ZONE: la zona del disco di origine e del nuovo disco.
TARGET_DISK_NAME: il nome del nuovo disco.
SOURCE_DISK_NAME: il nome del disco di origine.
KMS_PROJECT_ID: l'ID progetto per la chiave di crittografia.
REGION: la regione della chiave di crittografia.
KEY_RING: le chiavi automatizzate della chiave di crittografia.
KEY: il nome della chiave di crittografia.

Passaggi successivi

Scopri come eseguire regolarmente il backup dei dischi utilizzando gli snapshot standard per evitare perdite di dati indesiderate.
Scopri come eseguire il backup dei dischi in loco utilizzando gli snapshot istantanei.
Scopri come utilizzare i dischi permanenti a livello di regione per la replica sincrona tra due zone.
Scopri di più sulla replica asincrona.

Duplica un disco con cloni Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Prima di iniziare

Console

gcloud

Terraform

Go

Java

Python

REST

Riepilogo dei casi d'uso

Come funziona la clonazione di dischi

Volumi Hyperdisk regionali clonati da volumi Hyperdisk zonali

Prestazioni dei volumi Hyperdisk Balanced High Availability clonati da dischi di zona

Esempio

Volumi Persistent Disk a livello di regione clonati da volumi Persistent Disk a livello di zona

Tipi di dischi supportati

Limitazioni

Messaggi di errore

Crea cloni di dischi

Autorizzazioni richieste per questa attività

Crea un clone del disco nella stessa località dell'origine

Console Google Cloud

Google Cloud CLI

Terraform

Go

Go

Java

Java

Python

Python

REST

Crea un clone di un disco a livello di regione da un disco a livello di zona

Console

gcloud

Terraform

Go

Go

Java

Java

Python

Python

REST

Crea un clone di un disco di origine criptato con CMEK o CSEK

Crea cloni di dischi criptati con CSEK

Console

gcloud

Go

Go

Java

Java

Python

Python

REST

Crea cloni di dischi criptati con CMEK

Console

gcloud

Go

Go

Java

Java

Python

Python

REST

Passaggi successivi

Duplica un disco con cloni