Duplica un disco con clonaciones

En este documento, se proporciona información sobre cómo funcionan las clonaciones de discos y cómo crear una. El clonado de discos te permite crear copias de discos existentes que se pueden usar de inmediato en la misma ubicación (zona o región). Crea un clon de disco en situaciones en las que quieras una copia de un disco existente que puedas conectar de inmediato a una VM, como las siguientes:

Crear entornos de etapa de pruebas duplicando datos de producción para depurar sin interrumpir la producción
Realizar análisis de software malicioso no disruptivos en un disco sin afectar el rendimiento de una carga de trabajo de producción
Creación de copias para la verificación de copias de seguridad de bases de datos
Cómo mover datos de un disco que no es de arranque a un proyecto nuevo
Duplicar discos mientras escalas horizontalmente tus VMs

Para habilitar la recuperación ante desastres de tus datos, crea una copia de seguridad de tu disco con instantáneas estándar en lugar de usar clones de disco. Para capturar el contenido del disco en intervalos regulares sin crear discos nuevos, usa instantáneas, ya que son más eficientes en cuanto al almacenamiento que las clonaciones. Para obtener más opciones de protección de discos, consulta Opciones de protección de datos.

Antes de comenzar

Si aún no lo hiciste, configura la autenticación. La autenticación verifica tu identidad para acceder a los servicios y las APIs de Google Cloud . Para ejecutar código o muestras desde un entorno de desarrollo local, puedes autenticarte en Compute Engine seleccionando una de las siguientes opciones:
Selecciona la pestaña que corresponda a la forma en que planeas usar las muestras de esta página:
Console

Cuando usas la consola de Google Cloud para acceder a los servicios y las APIs de Google Cloud , no necesitas configurar la autenticación.
gcloud
1. Instala Google Cloud CLI. Después de la instalación, inicializa Google Cloud CLI con el siguiente comando:
  gcloud init
  Si usas un proveedor de identidad externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.
  
  Nota: Si ya instalaste gcloud CLI, asegúrate de tener la versión más reciente. Para esto, ejecuta gcloud components update.
Configura una región y una zona predeterminadas.

Terraform

Para usar las muestras de Terraform de esta página en un entorno de desarrollo local, instala e inicializa la gcloud CLI y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

Instala Google Cloud CLI.
Si usas un proveedor de identidad (IdP) externo, primero debes acceder a gcloud CLI con tu identidad federada.
Si usas un shell local, crea credenciales de autenticación locales para tu cuenta de usuario:
```
gcloud auth application-default login
```
No es necesario que lo hagas si usas Cloud Shell.

Si se devuelve un error de autenticación y usas un proveedor de identidad (IdP) externo, confirma que accediste a la gcloud CLI con tu identidad federada.

Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Go

Para usar las muestras de Go de esta página en un entorno de desarrollo local, instala e inicializa gcloud CLI y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

Instala Google Cloud CLI.
Si usas un proveedor de identidad (IdP) externo, primero debes acceder a gcloud CLI con tu identidad federada.
Si usas un shell local, crea credenciales de autenticación locales para tu cuenta de usuario:
```
gcloud auth application-default login
```
No es necesario que lo hagas si usas Cloud Shell.

Si se devuelve un error de autenticación y usas un proveedor de identidad (IdP) externo, confirma que accediste a la gcloud CLI con tu identidad federada.

Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Java

Para usar las muestras de Java de esta página en un entorno de desarrollo local, instala e inicializa la gcloud CLI y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

Instala Google Cloud CLI.
Si usas un proveedor de identidad (IdP) externo, primero debes acceder a gcloud CLI con tu identidad federada.
Si usas un shell local, crea credenciales de autenticación locales para tu cuenta de usuario:
```
gcloud auth application-default login
```
No es necesario que lo hagas si usas Cloud Shell.

Si se devuelve un error de autenticación y usas un proveedor de identidad (IdP) externo, confirma que accediste a la gcloud CLI con tu identidad federada.

Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

Python

Para usar las muestras de Python de esta página en un entorno de desarrollo local, instala e inicializa la gcloud CLI y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

Instala Google Cloud CLI.
Si usas un proveedor de identidad (IdP) externo, primero debes acceder a gcloud CLI con tu identidad federada.
Si usas un shell local, crea credenciales de autenticación locales para tu cuenta de usuario:
```
gcloud auth application-default login
```
No es necesario que lo hagas si usas Cloud Shell.

Si se devuelve un error de autenticación y usas un proveedor de identidad (IdP) externo, confirma que accediste a la gcloud CLI con tu identidad federada.

Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

REST

Para usar las muestras de la API de REST incluidas en esta página en un entorno de desarrollo local, debes usar las credenciales que proporciones a la gcloud CLI.

Instala Google Cloud CLI.

Si usas un proveedor de identidad externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.

Para obtener más información, consulta Autentícate para usar REST en la documentación de autenticación de Google Cloud .

Resumen de los casos de uso

Además de duplicar un disco para realizar pruebas y depuraciones rápidas, puedes habilitar la alta disponibilidad para un disco zonal creando un clon regional a partir del disco zonal. Cuando creas un disco regional a partir de un disco zonal, el disco regional tiene una réplica del disco en dos zonas dentro de la misma región. Después de crear el disco regional, usa el disco regional nuevo en lugar del disco zonal. En el caso poco probable de una interrupción en una zona, aún puedes acceder a los datos de la réplica en la otra zona.

En esta tabla, se resumen los diferentes tipos de clonaciones que admite Compute Engine.

Tipo de clonación	Cuándo usar	Tipos de discos compatibles
Clon zonal a partir de un disco zonal	Crea una copia idéntica de un disco en la misma zona para cualquiera de las siguientes tareas: Duplicar discos existentes para VMs nuevas y, así, aumentar la escala de las cargas de trabajo Entornos de etapa de pruebas, depuración o prueba con datos de producción Analizar un disco en producción en busca de software malicioso Se está moviendo un disco a un proyecto nuevo.	Disco persistente: Disco persistente estándar, balanceado y SSD Hyperdisk: Todos los tipos de Hyperdisk, excepto Hyperdisk Balanced High Availability
Clon regional de un disco zonal	Hacer que una carga de trabajo zonal esté altamente disponible agregando una réplica de los datos en otra zona Analizar un disco en producción en busca de software malicioso	Disco persistente: Disco persistente estándar, balanceado y SSD Hyperdisk: Hyperdisk Extreme y Hyperdisk Balanced
Clon regional de un disco regional	Crea una copia idéntica de un disco regional en la misma región para lo siguiente: Probar o escalar horizontalmente cargas de trabajo regionales con alta disponibilidad (HA) Mantener la redundancia de los datos en dos zonas mientras se realizan tareas administrativas o pruebas Crear copias de los volúmenes de la base de datos de HA para la verificación	Persistent Disk: Disco persistente regional equilibrado, SSD y disco persistente estándar Hyperdisk: Alta disponibilidad balanceada de Hyperdisk

Cómo funciona la clonación de discos

Cuando clonas un disco, creas un disco nuevo que contiene todos los datos del disco de origen. Puedes crear un clon de un disco incluso si el disco existente está conectado a una instancia de VM. Después de clonar un disco, puedes borrar el disco de origen sin que haya ningún riesgo de borrar el clon.

De forma predeterminada, los clones de un disco heredan su tamaño, límites de rendimiento, tipo y la zona o región exactas. Puedes cambiar algunas de estas propiedades de la siguiente manera:

Tamaño: Puedes crear un clon que tenga un tamaño mayor que el de su disco de origen, pero no un tamaño menor.
Rendimiento: En el caso de los volúmenes de Hyperdisk, puedes especificar un límite de rendimiento diferente para la clonación. Las clonaciones regionales de volúmenes de Hyperdisk zonales son volúmenes de Hyperdisk Balanced High Availability y pueden tener límites de rendimiento diferentes.
Ubicación: De forma predeterminada, el clon de un disco se crea en la misma zona para los discos zonales y en la misma región para los discos regionales. Sin embargo, para crear un clon regional de un disco zonal, puedes especificar una segunda zona que se encuentre dentro de la misma región del disco zonal. El clon nuevo también se conoce como clon regional y tiene una réplica en la zona del disco de origen y en la segunda zona que especificaste.
Tipo: Los clones regionales de volúmenes zonales de Hyperdisk Balanced o Hyperdisk Extreme son volúmenes de Hyperdisk Balanced High Availability.

Volúmenes de Hyperdisk regionales clonados a partir de volúmenes de Hyperdisk zonales

Una clonación regional de un volumen de Hyperdisk zonal existente siempre es un volumen nuevo de Hyperdisk Balanced High Availability. Esto se debe a que Hyperdisk Balanced High Availability es el único Hyperdisk regional compatible. La forma en que creas un Hyperdisk regional a partir de un Hyperdisk zonal depende de su tipo.

En el caso de los volúmenes zonales de Hyperdisk ML y Hyperdisk Throughput, no puedes crear un disco regional clonando el disco de origen. Debes crear un nuevo volumen de Hyperdisk Balanced High Availability a partir de una instantánea del disco zonal.
En el caso de los volúmenes zonales de Hyperdisk Balanced y Hyperdisk Extreme, puedes crear un nuevo volumen de Hyperdisk Balanced High Availability creando un clon regional de un volumen zonal de Hyperdisk Balanced o Hyperdisk Extreme.

Rendimiento de los volúmenes de Hyperdisk Balanced High Availability clonados a partir de discos zonales

Cuando creas un volumen de Hyperdisk Balanced High Availability nuevo a partir de un volumen de Hyperdisk Balanced o Hyperdisk Extreme, el disco nuevo hereda el tamaño del disco de origen, pero puedes especificar un tamaño diferente.

El rendimiento máximo aprovisionado del disco nuevo podría ser menor que el del disco de origen, ya que Hyperdisk Extreme y Hyperdisk Balanced tienen límites de rendimiento más altos que Hyperdisk Balanced High Availability, como se indica en la siguiente tabla.

Tipo de Hyperdisk	Operaciones de E/S por segundo (IOPS) máximas	Capacidad de procesamiento máxima ( MiB/s)
Alta disponibilidad balanceada de Hyperdisk	100,000	2,400
Hiperdisco balanceado	160,000	2,400
Hiperdisco extremo	350,000	5,000

Puedes especificar límites para el nuevo disco regional, pero estos no pueden exceder los límites de rendimiento máximos que ofrece Hyperdisk Balanced High Availability: 100,000 IOPS y 2,400 MiB/s.

Si no especificas un límite de rendimiento para el disco nuevo, Compute Engine aprovisionará el disco con las IOPS y la capacidad de procesamiento predeterminadas que dependen del tamaño del volumen de Hyperdisk Balanced High Availability. Para conocer los límites predeterminados, consulta Límites predeterminados de tamaño y rendimiento de la alta disponibilidad balanceada de Hyperdisk.

Para alcanzar las 100,000 IOPS, el tamaño de un volumen de Hyperdisk Balanced High Availability debe ser de al menos 200 GiB, por lo que también es posible que debas aumentar el tamaño aprovisionado del clon regional.

Ejemplo

Considera un volumen de Hyperdisk Extreme de 150 GiB, hdx-1, aprovisionado con 180,000 IOPS.

Si creas un clon regional de hdx-1 y no especificas un nuevo límite de tamaño o rendimiento, Compute Engine creará un volumen de Hyperdisk Balanced High Availability de 150 GiB que tendrá el límite predeterminado de IOPS para ese tamaño: 3,900 IOPS.

Si no aumentas el tamaño, puedes especificar hasta 75,000 IOPS para la clonación regional.

Volúmenes de Persistent Disk regionales clonados a partir de volúmenes de Persistent Disk zonales

Un volumen de Persistent Disk regional que se clonó a partir de un Persistent Disk zonal tiene el mismo tipo que el clon. Por ejemplo, si clonas un disco persistente estándar zonal, crearás un volumen de disco persistente estándar regional.

Sin embargo, los clones regionales de volúmenes de Persistent Disk pueden tener límites de tamaño y rendimiento diferentes a los del disco de origen zonal, como se indica a continuación.

Límites de rendimiento más bajos: Es posible que los clones regionales de Persistent Disk tengan límites de rendimiento de IOPS y capacidad de procesamiento más bajos que el disco de origen. Esto se debe a que el Persistent Disk zonal ofrece límites de rendimiento máximos más altos para las instancias. Por ejemplo, el disco persistente balanceado zonal tiene un límite máximo de instancias de 80,000 IOPS de escritura, pero el disco persistente balanceado regional tiene un límite de 60,000 IOPS de escritura.

Para conocer los límites de rendimiento detallados, compara los límites de rendimiento de los discos persistentes zonales y los límites de rendimiento de los discos persistentes regionales.
Para el disco persistente estándar regional, un tamaño mínimo de 200 GiB: El disco persistente estándar regional tiene un tamaño mínimo de 200 GiB. Por lo tanto, para crear un clon regional de un volumen de disco persistente estándar zonal de 10 a 199 GiB, debes especificar un tamaño de al menos 200 GiB para el disco regional.

Tipos de discos compatibles

Puedes clonar todos los tipos de Persistent Disk y Hyperdisk si el clon se encuentra en la misma ubicación (zona o región) que el disco de origen.

La clonación de un disco zonal a un disco regional solo se admite para los siguientes tipos de disco:

Google Cloud Hyperdisk:
- Hiperdisco balanceado
- Hiperdisco extremo
Para crear un disco regional a partir de un volumen de Hyperdisk ML o Hyperdisk Throughput, crea una instantánea y, luego, crea un volumen de Hyperdisk Balanced High Availability a partir de la instantánea.
Persistent Disk:
- Disco persistente balanceado
- Disco persistente SSD
- Disco persistente estándar

Restricciones

Las clonaciones de disco tienen las siguientes restricciones:

No puedes crear un volumen de Hyperdisk Balanced High Availability clonando un volumen zonal de Hyperdisk ML o Hyperdisk Throughput. Para crear un volumen de Hyperdisk Balanced High Availability para estos tipos de Hyperdisk, completa los pasos que se indican en Cómo cambiar un disco zonal a un volumen de Hyperdisk Balanced High Availability regional.
No puedes clonar un disco que se encuentre en un grupo de almacenamiento.
No puedes crear un clon de un disco zonal existente en una zona diferente.
El tamaño del clon debe ser al menos el tamaño del disco de origen. Si creas un clon con la consola de Google Cloud , no puedes especificar un tamaño de disco, y el clon se creará con el mismo tamaño que el disco de origen.
Si clonas un volumen de Hyperdisk o Persistent Disk desde la consola de Google Cloud , no puedes especificar el rendimiento aprovisionado para el disco clonado.
Si usas una clave de encriptación proporcionada por el cliente (CSEK) o una clave de encriptación administrada por el cliente (CMEK) para encriptar el disco de origen, debes usar la misma clave para encriptar el clon. Para obtener más información, consulta Crea un clon de un disco de origen encriptado.
No puedes borrar el disco de origen mientras se crea su clon.
La instancia de procesamiento a la que está conectado el disco de origen no podrá encenderse mientras se crea el clon.
Si el disco de origen se marcó para que se borrara junto con la VM a la que está conectado, no podrás borrar la VM mientras se crea el clon.
Puedes crear, como máximo, una clonación de un disco de origen determinado o sus clonaciones cada 30 segundos.
Puedes tener, como máximo, 1,000 clones de disco simultáneos de un disco de origen determinado o sus clonaciones. Si superas este límite, se muestra un internalError. Sin embargo, si creas un clon de un disco y lo borras más tarde, el clon del disco borrado no se incluye en este límite.
Una vez que se clona un disco, las clonaciones posteriores de ese disco o sus clonaciones se cuentan en el límite de 1,000 clonaciones de disco simultáneas para el disco fuente original y se cuentan en el límite de crear como máximo una clonación cada 30 segundos.
Si creas un disco regional clonando un disco zonal, puedes clonar como máximo 1 TiB de capacidad cada 15 minutos, con un límite de solicitudes de aumento de actividad de 257 TiB.
No puedes crear un clon de un disco zonal a partir de un disco regional.
Para crear un clon de un disco regional a partir de un disco zonal de origen, una de las zonas de réplica del clon de disco regional debe coincidir con la zona del disco de origen.
Después de la creación, el clon del disco regional se puede usar en promedio en 3 minutos. Sin embargo, el disco puede tardar decenas de minutos en replicarse por completo y alcanzar un estado en el que el objetivo de punto de recuperación (RPO) se acerque a cero.
Si creaste un disco zonal a partir de una imagen, no puedes usar ese disco zonal para crear un clon de disco regional.

Mensajes de error

Si excedes los límites de frecuencia de clonación, la solicitud falla con el siguiente mensaje de error:

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 clones de discos

En esta sección, se explica cómo puedes duplicar un disco existente y crear un clon de disco.

Para conocer los pasos detallados, según el tipo de creación de clon de disco, consulta una de las siguientes secciones de este documento:

Para clonar un disco para realizar pruebas, depuraciones o escalamientos rápidos, crea un clon de disco en la misma ubicación que el origen.
Para que un disco zonal tenga alta disponibilidad, crea un clon de un disco regional a partir de un disco zonal.
Crea un clon de un disco de origen encriptado

Permisos necesarios para esta tarea

Para hacer esta tarea, debes tener los siguientes permisos:

compute.disks.create en el proyecto
compute.disks.useReadOnly en el disco de origen
Si el disco de origen es el disco de arranque de una instancia que tiene una cuenta de servicio adjunta: iam.serviceAccounts.actAs en la cuenta de servicio de la instancia

Crea un clon de disco en la misma ubicación que el origen

Puedes crear un clon de un disco zonal o regional existente que se encuentre en la misma zona o región, respectivamente, que el disco de origen con la consola deGoogle Cloud , Google Cloud CLI, REST o las bibliotecas cliente de Cloud.

Consola de Google Cloud

En la consola de Google Cloud , ve a la página Discos.

Ir a Discos
En la lista de discos, navega hasta el disco que deseas clonar.
En la columna Acciones, haz clic en el botón de menú y selecciona Clonar disco.

En el panel Clonar disco que aparece, haz lo siguiente:
1. En el campo Nombre, especifica un nombre para el disco clonado.
2. Opcional: En el caso de los discos zonales, en Ubicación, verifica que esté seleccionada la opción Zona única.
3. En Propiedades, revisa otros detalles del disco nuevo.
4. Para terminar de crear el disco clonado, haz clic en Crear.

Google Cloud CLI

Para clonar un disco de origen zonal y crear un disco zonal nuevo, ejecuta el comando disks create y especifica la marca --source-disk:

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

Reemplaza lo siguiente:

TARGET_DISK_NAME: Es el nombre del disco nuevo.
PROJECT_ID: Es el ID del proyecto en el que deseas clonar el disco.
ZONE: Es la zona del disco de origen y nuevo.
SOURCE_DISK_NAME: el nombre del disco de origen.

Terraform

Para crear una clonación de un disco, usa el recurso 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
}

Si deseas obtener más información para aplicar o quitar una configuración de Terraform, consulta los comandos básicos de Terraform.

Go

Antes de probar esta muestra, sigue las instrucciones de configuración de Go en la Guía de inicio rápido de Compute Engine: Usa las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Go de Compute Engine.

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Antes de probar esta muestra, sigue las instrucciones de configuración de Java en la Guía de inicio rápido de Compute Engine: Usa las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Java de Compute Engine.

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.


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

Antes de probar esta muestra, sigue las instrucciones de configuración de Python en la Guía de inicio rápido de Compute Engine: Usa las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Python de Compute Engine.

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Para clonar un disco de origen zonal y crear un disco zonal nuevo, realiza una solicitud POST al método compute.disks.insert. En el cuerpo de la solicitud, especifica los parámetros name y sourceDisk. El clon hereda todas las propiedades omitidas del disco de origen.

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

Reemplaza lo siguiente:

PROJECT_ID: Es el ID del proyecto en el que deseas clonar el disco.
ZONE: Es la zona del disco de origen y nuevo.
TARGET_DISK_NAME: Es el nombre del disco nuevo.
SOURCE_DISK_NAME: Es el nombre del disco de origen.

Crea un clon de un disco regional a partir un disco zonal

Puedes crear un disco regional nuevo clonando un disco zonal existente de cualquiera de los siguientes tipos:

Hiperdisco balanceado
Hiperdisco extremo
Discos persistentes estándar, balanceados y SSD

Si el disco de origen es un volumen de Hyperdisk Balanced o Hyperdisk Extreme, el disco regional siempre será un volumen de Hyperdisk Balanced High Availability y no heredará el mismo rendimiento aprovisionado del disco zonal. Para establecer el rendimiento aprovisionado del disco regional, debes clonarlo con Google Cloud CLI o REST. Si clonas el disco con la consola de Google Cloud , no puedes especificar un límite de rendimiento, y el disco se aprovisiona con los límites predeterminados para su tamaño.

Console

En la consola de Google Cloud , ve a la página Discos.

Ir a Discos
En la lista de discos, navega hasta el volumen de Persistent Disk zonal que deseas clonar.
En la columna Acciones, haz clic en el botón de menú y selecciona Clonar disco.

En el panel Clonar disco que aparece, haz lo siguiente:
1. En el campo Nombre, especifica un nombre para el disco clonado.
2. En Ubicación, selecciona Regional y, luego, la zona de réplica secundaria para el disco regional clonado nuevo.
3. En Propiedades, revisa otros detalles del disco nuevo.
4. Para terminar de crear el disco clonado, haz clic en Crear.

gcloud

Para crear un clon de un disco regional a partir de un disco zonal, ejecuta el comando gcloud compute disks create y especifica los parámetros --region y --replica-zones.

Si el disco zonal es un volumen de Hyperdisk Balanced o Hyperdisk Extreme, especifica la marca --disk-type=hyperdisk-balanced-high-availability, ya que el disco regional debe ser un volumen de Hyperdisk Balanced High Availability.

Para clonar un volumen de Persistent Disk, omite la marca --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 ]

Reemplaza lo siguiente:

TARGET_DISK_NAME: Es el nombre del disco regional nuevo.
CLONED_REGION: Es la región de los discos de origen y clonados.
SOURCE_DISK_NAME: Es el nombre del disco zonal que se clonará.
SOURCE_DISK_ZONE: Es la zona del disco de origen. Esta también será la primera zona de réplica para el clon de disco regional.
REPLICA_ZONE_2: Es la segunda zona de réplica para la clonación del disco regional nuevo.
PROJECT_ID: Es el ID del proyecto en el que deseas clonar el disco.
IOPS_LIMIT: Opcional: Para crear un disco Hyperdisk Balanced High Availability regional, puedes especificar una cantidad de IOPS que el disco puede controlar, hasta 100,000 IOPS.
THROUGHPUT_LIMIT: Opcional: Para crear un disco regional de Hyperdisk Balanced High Availability, puedes especificar la capacidad de procesamiento máxima en MiB/s que el disco puede proporcionar, hasta 2,400 MiB/s.

Terraform

Para crear un clon de un disco regional a partir de un disco zonal, usa el siguiente recurso. Si el disco de origen es un volumen de Hyperdisk Balanced o Hyperdisk Extreme, establece el argumento type en 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"]
}

Si deseas obtener más información para aplicar o quitar una configuración de Terraform, consulta los comandos básicos de Terraform.

Go

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.


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

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Para crear un clon de un disco regional a partir de un disco zonal, realiza una solicitud POST al método compute.disks.insert y especifica los parámetros sourceDisk y replicaZone.

Si el disco zonal es un volumen de Hyperdisk Balanced o Hyperdisk Extreme, incluye el campo type para crear un volumen de 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"
}

Reemplaza lo siguiente:

PROJECT_ID: Es el ID del proyecto en el que deseas clonar el disco.
TARGET_DISK_NAME: Es el nombre del disco regional nuevo.
CLONED_REGION: Es la región de los discos de origen y clonados.
SOURCE_DISK_NAME: Es el nombre del disco zonal que se clonará.
SOURCE_DISK_ZONE: Es la zona del disco de origen. Esta también será la primera zona de réplica para el clon de disco regional.
REPLICA_ZONE_2: Es la segunda zona de réplica para la clonación del disco regional nuevo.
IOPS_LIMIT: Opcional: Para crear un disco Hyperdisk Balanced High Availability regional, puedes especificar una cantidad de IOPS que el disco puede controlar, hasta 100,000 IOPS.
THROUGHPUT_LIMIT: Opcional: Para crear un disco regional de Hyperdisk Balanced High Availability, puedes especificar la capacidad de procesamiento máxima en MiB/s que el disco puede proporcionar, hasta 2,400 MiB/s.

Crea una clonación de un disco de origen encriptado con CMEK o CSEK

Para crear una clonación zonal o regional de un disco encriptado con CSEK o CMEK, sigue los procedimientos que se describen en las secciones anteriores. Sin embargo, también debes proporcionar la clave que se usó para encriptar el disco de origen.

Crea clones de discos encriptados con CSEK

Si usas una CSEK para encriptar el disco de origen, también debes usar la misma clave para encriptar el clon.

Console

En la consola de Google Cloud , ve a la página Discos.

Ir a Discos
En la lista de discos persistentes zonales, busca el disco que deseas clonar.
En la columna Acciones, haz clic en el botón de menú y selecciona Clonar disco.

En el panel Clonar disco que aparece, haz lo siguiente:
1. En el campo Nombre, especifica un nombre para el disco clonado.
2. En el campo Desencriptación y encriptación, proporciona la clave de encriptación del disco de origen.
3. En Propiedades, revisa otros detalles del disco nuevo.
4. Para terminar de crear el disco clonado, haz clic en Crear.

gcloud

Para crear una clonación de un disco para un disco de origen encriptado con CSEK, ejecuta el comando gcloud compute disks create y proporciona la clave de encriptación del disco de origen con la marca --csek-key-file. Si usas una clave unida con RSA, usa el gcloud beta compute disks create comando.

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

Reemplaza lo siguiente:

TARGET_DISK_NAME: Es el nombre del disco nuevo.
PROJECT_ID: Es el ID del proyecto en el que deseas clonar el disco.
ZONE: Es la zona del disco de origen y nuevo.
SOURCE_DISK_NAME: Es el nombre del disco de origen.

Go

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.


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

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Si deseas crear un clon de un disco para un disco de origen encriptado con CSEK, realiza una solicitud POST al método compute.disks.insert y proporciona la clave de encriptación del disco de origen con la propiedad diskEncryptionKey. Si usas una clave unida con RSA, usa la versión beta del método.

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

Reemplaza lo siguiente:

PROJECT_ID: Es el ID del proyecto en el que deseas clonar el disco.
ZONE: Es la zona del disco de origen y nuevo.
TARGET_DISK_NAME: Es el nombre del disco nuevo.
SOURCE_DISK_NAME: Es el nombre del disco de origen.

Crea clones de discos encriptados con CMEK

Si usas una CMEK para encriptar el disco de origen, también debes usar la misma clave para encriptar el clon.

Console

Compute Engine encripta de forma automática el clon mediante la clave de encriptación del disco de origen.

gcloud

Para crear una clonación de un disco para un disco de origen encriptado con CMEK, ejecuta el comando gcloud compute disks create y proporciona la clave de encriptación del disco de origen con la marca --kms-key. Si usas una clave unida con RSA, usa el gcloud beta compute disks create comando.

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

Reemplaza lo siguiente:

TARGET_DISK_NAME: Es el nombre del disco nuevo.
PROJECT_ID: Es el ID del proyecto en el que deseas clonar el disco.
ZONE: Es la zona del disco de origen y nuevo.
SOURCE_DISK_NAME: el nombre del disco de origen.
KMS_PROJECT_ID: Es el ID del proyecto de la clave de encriptación.
REGION: Es la región de la clave de encriptación.
KEY_RING: Es el llavero de claves de la clave de encriptación.
KEY: Es el nombre de la clave de encriptación.

Go

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.


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

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Si deseas crear un clon de un disco para un disco de origen encriptado con CMEK, realiza unaPOST solicitud al método compute.disks.insert y proporciona la clave de encriptación del disco de origen mediante la propiedad kmsKeyName. Si usas una clave unida con RSA, usa la versión beta del método.

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

Reemplaza lo siguiente:

PROJECT_ID: Es el ID del proyecto en el que deseas clonar el disco.
ZONE: Es la zona del disco de origen y nuevo.
TARGET_DISK_NAME: Es el nombre del disco nuevo.
SOURCE_DISK_NAME: el nombre del disco de origen.
KMS_PROJECT_ID: Es el ID del proyecto de la clave de encriptación.
REGION: Es la región de la clave de encriptación.
KEY_RING: Es el llavero de claves de la clave de encriptación.
KEY: Es el nombre de la clave de encriptación.

¿Qué sigue?

Obtén información para crear una copia de seguridad de tus discos a través de instantáneas estándar de forma periódica para evitar la pérdida involuntaria de datos.
Obtén más información para crear copias de seguridad de tus discos en el lugar con Instant Snapshots.
Obtén información sobre el uso de discos persistentes regionales para la replicación síncrona entre dos zonas.
Obtén más información sobre la replicación asíncrona.

Duplica un disco con clonaciones Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Antes de comenzar

Console

gcloud

Terraform

Go

Java

Python

REST

Resumen de los casos de uso

Cómo funciona la clonación de discos

Volúmenes de Hyperdisk regionales clonados a partir de volúmenes de Hyperdisk zonales

Rendimiento de los volúmenes de Hyperdisk Balanced High Availability clonados a partir de discos zonales

Ejemplo

Volúmenes de Persistent Disk regionales clonados a partir de volúmenes de Persistent Disk zonales

Tipos de discos compatibles

Restricciones

Mensajes de error

Crea clones de discos

Permisos necesarios para esta tarea

Crea un clon de disco en la misma ubicación que el origen

Consola de Google Cloud

Google Cloud CLI

Terraform

Go

Go

Java

Java

Python

Python

REST

Crea un clon de un disco regional a partir un disco zonal

Console

gcloud

Terraform

Go

Go

Java

Java

Python

Python

REST

Crea una clonación de un disco de origen encriptado con CMEK o CSEK

Crea clones de discos encriptados con CSEK

Console

gcloud

Go

Go

Java

Java

Python

Python

REST

Crea clones de discos encriptados con CMEK

Console

gcloud

Go

Go

Java

Java

Python

Python

REST

¿Qué sigue?

Duplica un disco con clonaciones