Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Duplica un disco con clonaciones

La clonación de discos te permite crear una copia de un disco existente que se puede usar de inmediato en la misma ubicación (zona o región) que el disco de origen. Crea un clon de disco en situaciones en las que desees una copia de un disco existente que puedas conectar rápidamente a una instancia, como en los siguientes casos:

Crear entornos de etapa de pruebas duplicando los 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
Duplica discos mientras escalas horizontalmente tus VMs

En este documento, se proporciona información sobre cómo funcionan las clonaciones de discos y cómo crear una.

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 a intervalos regulares sin crear discos nuevos, usa instantáneas inmediatas, ya que son más eficientes en términos de almacenamiento que las clonaciones. Para conocer otras 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 según cómo 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 instalarla, inicializa Google Cloud CLI ejecutando 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 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 externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.
Si usas una 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 muestra 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 externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.
Si usas una 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 muestra 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 externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.
Si usas una 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 muestra un error de autenticación y usas un proveedor de identidad externo (IdP), confirma que accediste a 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 externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.
Si usas una 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 muestra 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, debes usarlo en lugar del disco zonal. En el caso poco probable de que se produzca 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 clones que admite Compute Engine.

Tipo de clonación	Cuándo usar	Tipos de discos compatibles
Clonación 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: Escalar horizontalmente las cargas de trabajo duplicando los discos existentes para las VMs nuevas Entornos de etapa de pruebas, depuración o prueba con datos de producción Analizar un disco que está en producción en busca de software malicioso Mover un disco a un proyecto nuevo	Persistent Disk: Disco persistente estándar, balanceado y SSD Google Cloud Hyperdisk: Todos los tipos de Hyperdisk, excepto Hyperdisk Balanced High Availability
Clonación 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 que está en producción en busca de software malicioso Crea un disco de arranque regional a partir de un disco de arranque zonal.	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 datos en dos zonas mientras se realizan tareas administrativas o pruebas Crear copias de volúmenes de bases de datos de HA para la verificación	Persistent Disk: Disco persistente regional balanceado, SSD y disco persistente estándar Hyperdisk: Hyperdisk Balanced High Availability

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 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 exacta. Puedes cambiar algunas de estas propiedades de la siguiente manera:

Tamaño: Puedes crear un clon que tenga un tamaño mayor que el disco de origen, pero no uno más pequeño.
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 los 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, se crea un clon de un disco 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: Las clonaciones regionales de volúmenes zonales de Hyperdisk Balanced o Hyperdisk Extreme son volúmenes de Hyperdisk Balanced High Availability.

Latencia de clonación para discos de datos

Por lo general, Compute Engine clona discos de datos a escala de desarrollador (no de arranque) de hasta 32 GiB en menos de diez segundos. En el caso de los discos de datos a escala empresarial, con una prueba comparativa de 1 TiB, las clonaciones suelen completarse en menos de un minuto.

Los discos clonados no requieren un precalentamiento, se pueden conectar a instancias y alcanzan el máximo rendimiento inmediatamente después de la creación, lo que elimina las demoras en la inicialización y acelera significativamente los flujos de trabajo a gran escala, como el análisis de seguridad y la configuración de entornos de pruebas.

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.

Puedes crear un disco regional clonando el disco de origen si este es un volumen de Hyperdisk Balanced o Hyperdisk Extreme.
No puedes crear un disco regional clonando el disco de origen si este es un volumen de Hyperdisk ML o Hyperdisk Throughput. Debes crear un volumen nuevo de Hyperdisk Balanced High Availability a partir de una instantánea del disco zonal.

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 aprovisionado máximo 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	Cantidad máxima de operaciones de E/S por segundo (IOPS)	Capacidad de procesamiento máxima ( MiB/s)
Hyperdisk Balanced High Availability	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 la alta disponibilidad balanceada de Hyperdisk: 100,000 IOPS y 2,400 MiB/s.

Si no especificas un límite de rendimiento para el disco nuevo, Compute Engine aprovisiona 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 Hyperdisk Balanced High Availability.

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 es posible que también debas aumentar el tamaño aprovisionado de la clonación regional.

Ejemplo

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

Si creas una clonación regional de hdx-1 y no especificas un tamaño o límite de rendimiento nuevos, el nuevo disco regional será un volumen de Hyperdisk Balanced High Availability de 150 GiB que tendrá el límite de IOPS predeterminado para ese tamaño: 3,900 IOPS.

Las IOPS máximas que puedes especificar para un volumen de Hyperdisk Balanced High Availability de 150 GiB son 75,000 IOPS, según las fórmulas descritas en Límites de IOPS configurables para volúmenes de Hyperdisk Balanced High Availability.

Por lo tanto, si no aumentas el tamaño del disco regional nuevo, puedes especificar hasta 75,000 IOPS para el disco regional nuevo.

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, las clonaciones regionales de los 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: Las clonaciones regionales de Persistent Disk pueden tener un límite de rendimiento de IOPS y capacidad de procesamiento más bajo 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 una clonación regional de un volumen de disco persistente estándar zonal de 10 GiB 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:

Hyperdisk:
- Hiperdisco balanceado
- Hyperdisk Extreme Para crear un disco regional a partir de un volumen de Hyperdisk ML o Hyperdisk Throughput, sigue los pasos que se indican en Cambia un disco zonal a un volumen de Hyperdisk Balanced High Availability.
Persistent Disk:
- Disco persistente balanceado
- Disco persistente SSD
- Disco persistente estándar
Los volúmenes de Persistent Disk extremo son solo zonales y no admiten discos regionales.

Restricciones

Se aplican las siguientes restricciones y limitaciones a las clonaciones de discos.

Limitaciones generales

Las siguientes limitaciones se aplican a todas las operaciones de clonación de discos.

No puedes clonar un disco que se encuentre en un grupo de Hyperdisk.
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 tendrá el mismo tamaño que el disco de origen.
No puedes crear un clon de un disco zonal existente en una zona diferente.
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 borrarse junto con la instancia a la que está conectado, no podrás borrar la instancia mientras se crea el clon.
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) (obsoleta) 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 crear un disco zonal clonando 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 del 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 tres 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.
Crear un disco regional a partir de un disco de arranque zonal que se creó a partir de una imagen es más lento que clonar discos de datos zonales o discos de arranque zonales creados a partir de instantáneas. La duración del proceso es comparable a la de tomar una instantánea del disco de origen y, luego, crear un disco regional a partir de esa instantánea.
En el caso de los discos zonales que se crearon a partir de una imagen o clonando un disco que se creó a partir de una imagen, la creación de un clon regional de ese disco puede tardar más si creas instantáneas estándar de otros discos al mismo tiempo.
No puedes crear un disco regional clonando el disco fuente si este es un volumen de Hyperdisk ML o Hyperdisk Throughput. Debes crear un nuevo volumen de alta disponibilidad balanceada de Hyperdisk a partir de una instantánea del disco zonal.

Límites de frecuencia para clonar discos

Los siguientes límites se aplican a la frecuencia con la que puedes clonar discos.

En el caso de las clonaciones regionales de un disco de arranque zonal, si el disco zonal se creó a partir de una imagen o mediante la clonación de un disco que se creó a partir de una imagen, se aplican las siguientes limitaciones:
- Puedes crear, como máximo, seis clones regionales del disco de origen en un período de 60 minutos. Después de ese tiempo, las operaciones se limitan a un clon regional del disco de origen cada diez minutos.
- El límite de seis clones regionales en 60 minutos se comparte con las instantáneas del disco de origen. Esto significa que la cantidad máxima de clonaciones y de instantáneas regionales del mismo disco zonal que puedes crear en un plazo de 60 minutos es seis. Si creas cinco instantáneas estándar del disco de origen en 60 minutos, puedes crear un clon regional o una instantánea más del mismo disco dentro del mismo período de 60 minutos.
Para los clones de otros discos regionales o zonales, se aplican las siguientes limitaciones:
- Puedes crear un clon 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.

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 duplicar un disco existente y crear una clonación 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 y realizar pruebas, depuraciones o escalamientos horizontales rápidos, crea un clon de disco en la misma ubicación que el origen.
Para que un disco zonal tenga alta disponibilidad, crea una clonación 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

Crea una clonación de disco en la misma ubicación que el origen

En esta sección, se describe cómo crear un clon de un disco existente que se encuentra en la misma zona, para los discos zonales, o en la misma región, para los discos regionales, que el disco de origen. Puedes usar la consola de Google Cloud , Google Cloud CLI, REST o las bibliotecas cliente de Cloud.

Para crear un disco regional clonando un disco zonal, consulta Crea un clon de un disco regional a partir un disco zonal.

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-13-trixie-v20260908"
  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 si clonas un disco de arranque o de datos zonal existente de cualquiera de los siguientes tipos:

Hiperdisco balanceado
Hyperdisk Extreme, sin incluir los volúmenes que se crearon a partir de una imagen.
Disco persistente estándar, balanceado y SSD

Para establecer el tamaño y, en el caso de los discos de alta disponibilidad balanceada de Hyperdisk, el rendimiento aprovisionado del disco regional, debes clonar el disco con Google Cloud CLI o REST. No puedes usar la consola de Google Cloud .

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 tamaño y el rendimiento aprovisionado del disco regional, debes clonar el disco con Google Cloud CLI o REST. Si especificas el rendimiento aprovisionado, también debes especificar el tamaño del disco, incluso si es el mismo que el del disco de origen. Si clonas el disco con la consola deGoogle Cloud , no puedes especificar un límite de tamaño o 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 al 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 nuevo disco regional clonado.
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 --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 --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 \
  --type=hyperdisk-balanced-high-availability  \
  --size=DISK_SIZE \
  --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 del disco regional.
REPLICA_ZONE_2: Es la segunda zona de réplica para la clonación de disco regional nueva.
PROJECT_ID: Es el ID del proyecto en el que deseas clonar el disco.
DISK_SIZE: Es el tamaño del disco regional nuevo, en GB (opcional). El tamaño debe ser al menos el mismo que el del disco de origen. Si especificas un límite de IOPS o de capacidad de procesamiento, debes usar esta marca para especificar el tamaño del disco, incluso si es el mismo que el del disco de origen.
IOPS_LIMIT: Opcional: Para crear un disco regional de Hyperdisk Balanced High Availability, puedes especificar una cantidad de IOPS que el disco puede alcanzar, hasta 100,000 IOPS. Si incluyes esta marca, también debes especificar el tamaño del disco con la marca --size.
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 puede alcanzar el disco, hasta 2,400 MiB/s. Si incluyes esta marca, también debes especificar el tamaño del disco con la marca --size.

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 una clonación 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",
  "sizeGb": "DISK_SIZE",
  "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 del disco regional.
REPLICA_ZONE_2: Es la segunda zona de réplica para la clonación del disco regional nuevo.
DISK_SIZE: Opcional: Es el tamaño del disco regional nuevo, en GB. El tamaño debe ser al menos el mismo que el del disco de origen. Si especificas un límite de IOPS o de capacidad de procesamiento, debes incluir este campo para especificar el tamaño del disco, incluso si es el mismo que el del disco de origen.
IOPS_LIMIT: Opcional: Para crear un disco regional de Hyperdisk Balanced High Availability, puedes especificar una cantidad de IOPS que el disco puede controlar, hasta 100,000 IOPS. Si incluyes este campo, también debes especificar el tamaño del disco con el campo size.
THROUGHPUT_LIMIT: Opcional: Para crear un disco regional de alta disponibilidad balanceada de Hyperdisk, puedes especificar la capacidad de procesamiento máxima en MiB/s que el disco puede proporcionar, hasta 2,400 MiB/s. Si incluyes este campo, también debes especificar el tamaño del disco con el campo size.

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 que esté 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 para 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 clonaciones 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 con 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

Latencia de clonación para discos de datos

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

Limitaciones generales

Límites de frecuencia para clonar discos

Mensajes de error

Crea clones de discos

Permisos necesarios para esta tarea

Crea una clonación 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 para discos encriptados con CSEK

Console

gcloud

Go

Go

Java

Java

Python

Python

REST

Crea clonaciones de discos encriptados con CMEK

Console

gcloud

Go

Go

Java

Java

Python

Python

REST

¿Qué sigue?

Duplica un disco con clonaciones