Se usó la API de Cloud Translation para traducir esta página.

Crea instantáneas de disco estándar y de archivo

Crea instantáneas estándar para crear una copia de seguridad de los datos de estos tipos de discos de forma periódica:

Puedes crear instantáneas desde discos incluso mientras están conectados a instancias en ejecución. Las instantáneas son recursos globales, por lo que puedes usarlas para restablecer datos en un disco o una VM nuevos dentro del mismo proyecto. También puedes compartir instantáneas entre proyectos.

Antes de comenzar

Si aún no lo hiciste, configura la autenticación. La autenticación es el proceso mediante el cual se verifica tu identidad para acceder a los servicios y las API 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:

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

When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.
gcloud
1. Install the Google Cloud CLI, then initialize it by running the following command:
  gcloud init
  Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
2. Set a default region and zone.

Roles y permisos requeridos

Para obtener los permisos que necesitas para crear una instantánea estándar, pídele a tu administrador que te otorgue los siguientes roles de IAM en el proyecto:

Administrador de instancias de Compute (v1) (roles/compute.instanceAdmin.v1)
Para conectarte a una VM que puede ejecutarse como una cuenta de servicio: Usuario de cuenta de servicio (v1) (roles/iam.serviceAccountUser)

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

Estos roles predefinidos contienen los permisos necesarios para crear una instantánea estándar. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

Se requieren los siguientes permisos para crear una instantánea estándar:

Para crear una instantánea de un disco zonal, haz lo siguiente:
- compute.snapshots.create en el proyecto
- compute.disks.createSnapshot en el disco
Para crear una instantánea de un disco regional mediante los datos del disco, sigue estos pasos:
- compute.snapshots.create en el proyecto
- compute.instances.useReadOnly en la VM de origen
- compute.disks.createSnapshot en el disco
Para crear una instantánea de un disco regional a partir de un punto de control de recuperación de réplicas, sigue estos pasos:
- compute.snapshots.create en el proyecto
- compute.disks.createSnapshot en el disco

También puedes obtener estos permisos con roles personalizados o con otros roles predefinidos.

Prepárate para crear instantáneas

Para prepararte para crear instantáneas de discos persistentes o hiperdiscos, haz lo siguiente:

Revisa las Prácticas recomendadas para las instantáneas de discos de Compute Engine a fin de preparar el disco para la creación de instantáneas.
Si deseas personalizar la ubicación de almacenamiento predeterminada para todas las instantáneas nuevas, actualiza la configuración de la instantánea para tu proyecto. Google Cloud mantiene un valor de ubicación de almacenamiento predeterminado predefinido hasta que actualices la configuración de la instantánea por primera vez. Esta ubicación predefinida es la multirregión más cercana al disco de origen.
Consulta Crea programas para las instantáneas de discos para obtener información sobre cómo crear un programa de instantáneas y adjuntarlo a los discos. Crear copias de seguridad de tus discos periódicamente con instantáneas programadas puede reducir el riesgo de pérdida inesperada de datos.
No puedes crear una instantánea de un volumen de Hyperdisk que esté en modo de multiescritura. Inhabilita el modo de multiescritura para el disco y, luego, crea la instantánea.

Crea una instantánea del volumen de Persistent Disk

Las instrucciones para crear instantáneas de volúmenes de Persistent Disk son diferentes, según si creas una instantánea de Persistent Disk zonal o de Persistent Disk regional.

Crea una instantánea de un volumen de Persistent Disk zonal

Console

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

Ir a Instancias de VM
Los pasos restantes aparecerán automáticamente en la consola de Google Cloud.
Selecciona el proyecto que contiene las instancias de VM.
En la columna Nombre, haz clic en el nombre de la VM que tiene el disco para crear la copia de seguridad.
En Almacenamiento:
- Para crear una copia de seguridad del disco de arranque, en la sección Disco de arranque, haz clic en el Nombre del disco de arranque.
- Para crear una copia de seguridad de un disco de datos conectado, en Discos adicionales, haz clic en el Nombre del disco.
Haz clic en Crear instantánea.
En Nombre, ingresa un nombre único que ayude a identificar el propósito de la instantánea, por ejemplo:
- boot-disk-snapshot
- attached-data-disk-snapshot
En Tipo, el valor predeterminado es una instantánea estándar. Las instantáneas estándar son la mejor opción para las copias de seguridad a largo plazo y la recuperación ante desastres.
Elige Instantánea de archivo para crear una copia de seguridad más rentable que las instantáneas estándar, pero con un tiempo de recuperación de datos más largo.

Para obtener más información, consulta Comparación de tipos de instantáneas.
En la sección Ubicación, elige la ubicación de almacenamiento de instantáneas. La ubicación predeterminada o personalizada predeterminada que se define en la configuración de la instantánea se selecciona de forma automática. De manera opcional, puedes anular la configuración de la instantánea y almacenar tus instantáneas en una ubicación de almacenamiento personalizada si haces lo siguiente:
1. Elige el tipo de ubicación de almacenamiento que deseas para tu instantánea.
  - Elige Multirregional para obtener una mayor disponibilidad a un costo más alto.
  - Elige Instantáneas regionales para tener más control sobre la ubicación física de los datos a un costo más bajo.
2. En el campo Seleccionar ubicación, selecciona la región o multirregión específica que deseas usar. Para usar la región o multirregión más cercana al disco de origen, elige una ubicación de la sección titulada En función de la ubicación del disco.
Para crear una instantánea, haz clic en Crear.

gcloud

Puedes crear tu instantánea en la política de ubicación de almacenamiento que define tu configuración de instantáneas o usar una ubicación de almacenamiento alternativa de tu elección. Para obtener más información, consulta Elige la ubicación de almacenamiento de tu instantánea.

Para crear una instantánea en la ubicación predefinida o en la ubicación personalizada predeterminada que se estableció en la configuración de instantánea, usa el comando gcloud compute snapshots create.
```
gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-zone=SOURCE_ZONE \
    --source-disk=SOURCE_DISK_NAME \
    --snapshot-type=SNAPSHOT_TYPE
```
De lo contrario, si quieres anular la configuración de la instantánea y crear una instantánea en una ubicación de almacenamiento personalizada, incluye la marca --storage-location para indicar dónde almacenar la instantánea.
```
gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-zone=SOURCE_ZONE \
    --source-disk=SOURCE_DISK_NAME \
    --snapshot-type=SNAPSHOT_TYPE \
    --storage-location=STORAGE_LOCATION
```
Reemplaza lo siguiente:
- SNAPSHOT_NAME: Es un nombre para la instantánea.
- SOURCE_ZONE: Es la zona del disco de origen.
- SOURCE_DISK_NAME: Es el nombre del volumen de Persistent Disk desde el que deseas crear una instantánea.
- SNAPSHOT_TYPE: Es el tipo de instantánea, ya sea STANDARD o ARCHIVE. Si no se especifica un tipo de instantánea, se crea una instantánea STANDARD.
- STORAGE_LOCATION: Opcional: la multirregión de Cloud Storage o la región de Cloud Storage en la que quieres almacenar la instantánea. Solo puedes especificar una ubicación de almacenamiento.
  
  Usa el parámetro --storage-location solo cuando quieras anular la ubicación de almacenamiento predeterminada o personalizada establecida en tu configuración de instantáneas.
Nota: Google recomienda usar el comando gcloud compute snapshots create en lugar del comando gcloud compute disks snapshot porque admite más funciones, como la creación de instantáneas en un proyecto diferente del proyecto de disco de origen.

Terraform

Para crear una instantánea del disco persistente zonal, usa el recurso google_compute_snapshot.

resource "google_compute_snapshot" "snapdisk" {
  name        = "snapshot-name"
  source_disk = google_compute_disk.default.name
  zone        = "us-central1-a"
}

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 un entorno de desarrollo local.

import (
	"context"
	"fmt"
	"io"

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

// createSnapshot creates a snapshot of a disk.
func createSnapshot(
	w io.Writer,
	projectID, diskName, snapshotName, zone, region, location, diskProjectID string,
) error {
	// projectID := "your_project_id"
	// diskName := "your_disk_name"
	// snapshotName := "your_snapshot_name"
	// zone := "europe-central2-b"
	// region := "eupore-central2"
	// location = "eupore-central2"
	// diskProjectID = "YOUR_DISK_PROJECT_ID"

	ctx := context.Background()

	snapshotsClient, err := compute.NewSnapshotsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewSnapshotsRESTClient: %w", err)
	}
	defer snapshotsClient.Close()

	if zone == "" && region == "" {
		return fmt.Errorf("you need to specify `zone` or `region` for this function to work")
	}

	if zone != "" && region != "" {
		return fmt.Errorf("you can't set both `zone` and `region` parameters")
	}

	if diskProjectID == "" {
		diskProjectID = projectID
	}

	disk := &computepb.Disk{}
	locations := []string{}
	if location != "" {
		locations = append(locations, location)
	}

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

		getDiskReq := &computepb.GetDiskRequest{
			Project: projectID,
			Zone:    zone,
			Disk:    diskName,
		}

		disk, err = disksClient.Get(ctx, getDiskReq)
		if err != nil {
			return fmt.Errorf("unable to get disk: %w", err)
		}
	} else {
		regionDisksClient, err := compute.NewRegionDisksRESTClient(ctx)
		if err != nil {
			return fmt.Errorf("NewRegionDisksRESTClient: %w", err)
		}
		defer regionDisksClient.Close()

		getDiskReq := &computepb.GetRegionDiskRequest{
			Project: projectID,
			Region:  region,
			Disk:    diskName,
		}

		disk, err = regionDisksClient.Get(ctx, getDiskReq)
		if err != nil {
			return fmt.Errorf("unable to get disk: %w", err)
		}
	}

	req := &computepb.InsertSnapshotRequest{
		Project: projectID,
		SnapshotResource: &computepb.Snapshot{
			Name:             proto.String(snapshotName),
			SourceDisk:       proto.String(disk.GetSelfLink()),
			StorageLocations: locations,
		},
	}

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

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

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

	return nil
}

Java

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.


import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.RegionDisksClient;
import com.google.cloud.compute.v1.Snapshot;
import com.google.cloud.compute.v1.SnapshotsClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateSnapshot {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // You need to pass `zone` or `region` parameter relevant to the disk you want to
    // snapshot, but not both. Pass `zone` parameter for zonal disks and `region` for
    // regional disks.

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

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

    // Name of the snapshot that you want to create.
    String snapshotName = "YOUR_SNAPSHOT_NAME";

    // The zone of the source disk from which you create the snapshot (for zonal disks).
    String zone = "europe-central2-b";

    // The region of the source disk from which you create the snapshot (for regional disks).
    String region = "your-disk-region";

    // The Cloud Storage multi-region or the Cloud Storage region where you
    // want to store your snapshot.
    // You can specify only one storage location. Available locations:
    // https://cloud.google.com/storage/docs/locations#available-locations
    String location = "europe-central2";

    // Project ID or project number of the Cloud project that
    // hosts the disk you want to snapshot. If not provided, the value will be defaulted
    // to 'projectId' value.
    String diskProjectId = "YOUR_DISK_PROJECT_ID";

    createSnapshot(projectId, diskName, snapshotName, zone, region, location, diskProjectId);
  }

  // Creates a snapshot of a disk.
  public static void createSnapshot(String projectId, String diskName, String snapshotName,
      String zone, String region, String location, String diskProjectId)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {

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

      if (zone.isEmpty() && region.isEmpty()) {
        throw new Error("You need to specify 'zone' or 'region' for this function to work");
      }

      if (!zone.isEmpty() && !region.isEmpty()) {
        throw new Error("You can't set both 'zone' and 'region' parameters");
      }

      // If Disk's project id is not specified, then the projectId parameter will be used.
      if (diskProjectId.isEmpty()) {
        diskProjectId = projectId;
      }

      // If zone is not empty, use the DisksClient to create a disk.
      // Else, use the RegionDisksClient.
      Disk disk;
      if (!zone.isEmpty()) {
        DisksClient disksClient = DisksClient.create();
        disk = disksClient.get(projectId, zone, diskName);
      } else {
        RegionDisksClient regionDisksClient = RegionDisksClient.create();
        disk = regionDisksClient.get(diskProjectId, region, diskName);
      }

      // Set the snapshot properties.
      Snapshot snapshotResource;
      if (!location.isEmpty()) {
        snapshotResource = Snapshot.newBuilder()
            .setName(snapshotName)
            .setSourceDisk(disk.getSelfLink())
            .addStorageLocations(location)
            .build();
      } else {
        snapshotResource = Snapshot.newBuilder()
            .setName(snapshotName)
            .setSourceDisk(disk.getSelfLink())
            .build();
      }

      // Wait for the operation to complete.
      Operation operation = snapshotsClient.insertAsync(projectId, snapshotResource)
          .get(3, TimeUnit.MINUTES);

      if (operation.hasError()) {
        System.out.println("Snapshot creation failed!" + operation);
        return;
      }

      // Retrieve the created snapshot.
      Snapshot snapshot = snapshotsClient.get(projectId, snapshotName);
      System.out.printf("Snapshot created: %s", snapshot.getName());

    }
  }
}

Node.js

Antes de probar esta muestra, sigue las instrucciones de configuración de Node.js 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 Node.js de Compute Engine.

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const diskName = 'YOUR_DISK_NAME';
// const snapshotName = 'YOUR_SNAPSHOT_NAME';
// const zone = 'europe-central2-b';
// const region = '';
// const location = 'europe-central2';
// let diskProjectId = 'YOUR_DISK_PROJECT_ID';

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

async function createSnapshot() {
  const snapshotsClient = new compute.SnapshotsClient();

  let disk;

  if (!zone && !region) {
    throw new Error(
      'You need to specify `zone` or `region` for this function to work.'
    );
  }

  if (zone && region) {
    throw new Error("You can't set both `zone` and `region` parameters");
  }

  if (!diskProjectId) {
    diskProjectId = projectId;
  }

  if (zone) {
    const disksClient = new compute.DisksClient();
    [disk] = await disksClient.get({
      project: diskProjectId,
      zone,
      disk: diskName,
    });
  } else {
    const regionDisksClient = new compute.RegionDisksClient();
    [disk] = await regionDisksClient.get({
      project: diskProjectId,
      region,
      disk: diskName,
    });
  }

  const snapshotResource = {
    name: snapshotName,
    sourceDisk: disk.selfLink,
  };

  if (location) {
    snapshotResource.storageLocations = [location];
  }

  const [response] = await snapshotsClient.insert({
    project: projectId,
    snapshotResource,
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.GlobalOperationsClient();

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

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

createSnapshot();

Python

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.

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


def create_snapshot(
    project_id: str,
    disk_name: str,
    snapshot_name: str,
    *,
    zone: str | None = None,
    region: str | None = None,
    location: str | None = None,
    disk_project_id: str | None = None,
) -> compute_v1.Snapshot:
    """
    Create a snapshot of a disk.

    You need to pass `zone` or `region` parameter relevant to the disk you want to
    snapshot, but not both. Pass `zone` parameter for zonal disks and `region` for
    regional disks.

    Args:
        project_id: project ID or project number of the Cloud project you want
            to use to store the snapshot.
        disk_name: name of the disk you want to snapshot.
        snapshot_name: name of the snapshot to be created.
        zone: name of the zone in which is the disk you want to snapshot (for zonal disks).
        region: name of the region in which is the disk you want to snapshot (for regional disks).
        location: The Cloud Storage multi-region or the Cloud Storage region where you
            want to store your snapshot.
            You can specify only one storage location. Available locations:
            https://cloud.google.com/storage/docs/locations#available-locations
        disk_project_id: project ID or project number of the Cloud project that
            hosts the disk you want to snapshot. If not provided, will look for
            the disk in the `project_id` project.

    Returns:
        The new snapshot instance.
    """
    if zone is None and region is None:
        raise RuntimeError(
            "You need to specify `zone` or `region` for this function to work."
        )
    if zone is not None and region is not None:
        raise RuntimeError("You can't set both `zone` and `region` parameters.")

    if disk_project_id is None:
        disk_project_id = project_id

    if zone is not None:
        disk_client = compute_v1.DisksClient()
        disk = disk_client.get(project=disk_project_id, zone=zone, disk=disk_name)
    else:
        regio_disk_client = compute_v1.RegionDisksClient()
        disk = regio_disk_client.get(
            project=disk_project_id, region=region, disk=disk_name
        )

    snapshot = compute_v1.Snapshot()
    snapshot.source_disk = disk.self_link
    snapshot.name = snapshot_name
    if location:
        snapshot.storage_locations = [location]

    snapshot_client = compute_v1.SnapshotsClient()
    operation = snapshot_client.insert(project=project_id, snapshot_resource=snapshot)

    wait_for_extended_operation(operation, "snapshot creation")

    return snapshot_client.get(project=project_id, snapshot=snapshot_name)

REST

Para crear la instantánea en la ubicación predeterminada o personalizada establecida en tu configuración de instantáneas, haz una solicitud POST al método snapshots.insert.

POST https://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/global/snapshots
{
    "name": "SNAPSHOT_NAME",
    "sourceDisk": "projects/SOURCE_PROJECT_ID/zones/SOURCE_ZONE/disks/SOURCE_DISK_NAME",
    "snapshotType": "SNAPSHOT_TYPE"
}

De forma alternativa, para anular la configuración de instantáneas y crear una instantánea en una ubicación de almacenamiento personalizada, haz una solicitud POST al método snapshots.insert y, además, incluye la propiedad storageLocations en tu solicitud:

POST https://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/global/snapshots
{
    "name": "SNAPSHOT_NAME",
    "sourceDisk": "projects/SOURCE_PROJECT_ID/zones/SOURCE_ZONE/disks/SOURCE_DISK_NAME",
    "snapshotType": "SNAPSHOT_TYPE",
    "storageLocations": [
        "STORAGE_LOCATION"
    ],
}

Reemplaza lo siguiente:

DESTINATION_PROJECT_ID: Es el ID del proyecto en el que deseas crear la instantánea.
SNAPSHOT_NAME: Es un nombre para la instantánea.
SOURCE_PROJECT_ID: Es el ID del proyecto del disco de origen.
SOURCE_ZONE: Es la zona del disco de origen.
SOURCE_DISK_NAME: Es el nombre del volumen de Persistent Disk desde el que deseas crear una instantánea.
SNAPSHOT_TYPE: Es el tipo de instantánea, ya sea STANDARD o ARCHIVE. Si no se especifica un tipo de instantánea, se crea una instantánea STANDARD.
STORAGE_LOCATION: Opcional: la multirregión de Cloud Storage o la región de Cloud Storage en la que quieres almacenar la instantánea. Solo puedes especificar una ubicación de almacenamiento.

Usa el parámetro storageLocations solo cuando quieras anular la ubicación de almacenamiento predeterminada o personalizada establecida en tu configuración de instantáneas.

Nota: Google recomienda usar el método snapshots.insert en lugar del método disks.createSnapshot porque admite más funciones, como crear instantáneas en un proyecto diferente del proyecto del disco de origen.

Crea una instantánea del volumen de un Persistent Disk regional

Puedes crear instantáneas de tu volumen de Persistent Disk regional de una de las siguientes maneras:

A través de los datos en el disco de origen. Para usar este método de creación de instantáneas, debes tener una réplica zonal sincronizada disponible.
A través del uso del punto de control de recuperación de réplicas de un disco degradado. Puedes crear instantáneas desde un punto de control solo con Google Cloud CLI o REST.

Después de preparar el disco, puedes crear una instantánea. Cuando creas una instantánea de un Persistent Disk regional, debes indicar la región en la que se encuentra el disco de origen.

Console

Dirígete a la página Crear una instantánea en la consola de Google Cloud.
Ir a la página Crear una instantánea
Ingresa un Nombre para la instantánea.
Selecciona un Tipo de instantánea. El valor predeterminado es una instantánea STANDARD, que es la mejor opción para la copia de seguridad a largo plazo y la recuperación ante desastres.

Elige Instantánea de archivo para lograr una retención de datos más rentable.
Opcional: ingresa una descripción de la instantánea.
En Disco de origen, elige el disco existente del que deseas crear una instantánea.
En la sección Ubicación, elige la ubicación de almacenamiento de instantáneas.

La ubicación predeterminada predefinida o personalizada que se define en la configuración de la instantánea se elige de forma automática. De manera opcional, puedes anular la configuración de la instantánea y almacenar tus instantáneas en una ubicación de almacenamiento personalizada si haces lo siguiente:
1. Elige el tipo de ubicación de almacenamiento que deseas para tu instantánea.
  - Elige Multirregional para obtener una mayor disponibilidad a un costo más alto.
  - Elige Instantáneas regionales para tener más control sobre la ubicación física de los datos a un costo más bajo.
2. En el campo Seleccionar ubicación, elige la región o multirregión específica que deseas usar. Para usar la región o multirregión más cercana al disco de origen, elige En función de la ubicación del disco.
Haz clic en Crear para crear la instantánea.

gcloud

Puedes crear una instantánea con los datos del disco de origen o con su punto de control de recuperación de réplicas.

Desde datos de disco

Puedes crear una instantánea desde los datos de tu disco con la política de ubicación de almacenamiento definida por la configuración de instantáneas o con una ubicación de almacenamiento alternativa de tu elección. Para obtener más información, consulta Elige la ubicación de almacenamiento de tu instantánea.

Para crear una instantánea en la ubicación predefinida o en la ubicación personalizada predeterminada que se estableció en la configuración de instantánea, usa el comando gcloud compute snapshots create.
```
gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-region=SOURCE_REGION \
    --source-disk=SOURCE_DISK_NAME \
    --snapshot-type=SNAPSHOT_TYPE
```
De lo contrario, si quieres anular la configuración de la instantánea y crear una instantánea en una ubicación de almacenamiento personalizada, incluye la marca --storage-location para indicar dónde almacenar la instantánea.
```
gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-region=SOURCE_REGION \
    --source-disk=SOURCE_DISK_NAME \
    --snapshot-type=SNAPSHOT_TYPE \
    --storage-location=STORAGE_LOCATION
```
Reemplaza lo siguiente:
- SNAPSHOT_NAME: Es un nombre para la instantánea.
- SOURCE_REGION: Es la región del disco de origen.
- SOURCE_DISK_NAME: Es el nombre del Persistent Disk regional o del volumen de Alta disponibilidad balanceada de Hyperdisk desde el que deseas crear una instantánea.
- SNAPSHOT_TYPE: Es el tipo de instantánea, ya sea STANDARD o ARCHIVE. Si no se especifica un tipo de instantánea, se crea una instantánea STANDARD.
- STORAGE_LOCATION: Opcional: la multirregión de Cloud Storage o la región de Cloud Storage en la que quieres almacenar la instantánea. Solo puedes especificar una ubicación de almacenamiento.
  
  Usa el parámetro --storage-location solo cuando quieras anular la ubicación de almacenamiento predeterminada o personalizada establecida en tu configuración de instantáneas.
Nota: Google recomienda usar el comando gcloud compute snapshots create en lugar del comando gcloud compute disks snapshot porque admite más funciones, como la creación de instantáneas en un proyecto diferente del proyecto de disco de origen.

Desde el punto de control

Puedes crear la instantánea a través del punto de control de recuperación de réplicas (vista previa) de un disco degradado . La instantánea se creará siempre y cuando la réplica incompleta esté disponible.

Para crear una instantánea con el punto de control de recuperación de réplicas, usa el comando gcloud compute snapshots create . Incluye la marca --source-disk-for-recovery-checkpoint para especificar que deseas crear la instantánea con un punto de control de recuperación de réplicas. Excluye los parámetros --source-disk y --source-disk-region.

gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-for-recovery-checkpoint=SOURCE_DISK \
    --source-disk-for-recovery-checkpoint-region=SOURCE_REGION \
    --storage-location=STORAGE_LOCATION \
    --snapshot-type=SNAPSHOT_TYPE

Reemplaza lo siguiente:

DESTINATION_PROJECT_ID: Es el ID del proyecto en el que deseas crear la instantánea.
SNAPSHOT_NAME: Es un nombre para la instantánea.
SOURCE_PROJECT_ID: Es el ID del proyecto del disco de origen cuyo punto de control deseas usar para crear la instantánea.
SOURCE_REGION: el nombre del disco de origen cuyo punto de control quieres usar para crear la instantánea.
SOURCE_DISK_NAME: el nombre del disco de origen cuyo punto de control quieres usar para crear la instantánea.
STORAGE_LOCATION: Opcional: la multirregión de Cloud Storage o la región de Cloud Storage en la que quieres almacenar la instantánea. Solo puedes especificar una ubicación de almacenamiento.
Usa solo cuando quieras anular la ubicación de almacenamiento predeterminada o personalizada establecida en tu configuración de instantáneas.
SNAPSHOT_TYPE: Es el tipo de instantánea, ya sea ESTANDARD o ARCHIVO. Si no se especifica un tipo de instantánea, se crea una instantánea ESTANDARD.

Puedes usar el punto de control de recuperación de réplicas para crear una instantánea solo en discos degradados. Si intentas crear una instantánea desde un punto de control de recuperación de réplicas cuando el dispositivo está completamente replicado, verás el siguiente mensaje de error:

The device is fully replicated and should not create snapshots out of a recovery checkpoint. Please
create regular snapshots instead.

Google Cloud CLI espera hasta que la operación muestre un estado de READY o FAILED, o hasta que alcance el tiempo de espera máximo y muestre los últimos detalles conocidos de la instantánea.

Terraform

El proveedor de Terraform para Google Cloud no admite la creación de una instantánea de un disco persistente regional. Para realizar un seguimiento de esta limitación, consulta el problema en GitHub.

Go

import (
	"context"
	"fmt"
	"io"

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

// createSnapshot creates a snapshot of a disk.
func createSnapshot(
	w io.Writer,
	projectID, diskName, snapshotName, zone, region, location, diskProjectID string,
) error {
	// projectID := "your_project_id"
	// diskName := "your_disk_name"
	// snapshotName := "your_snapshot_name"
	// zone := "europe-central2-b"
	// region := "eupore-central2"
	// location = "eupore-central2"
	// diskProjectID = "YOUR_DISK_PROJECT_ID"

	ctx := context.Background()

	snapshotsClient, err := compute.NewSnapshotsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewSnapshotsRESTClient: %w", err)
	}
	defer snapshotsClient.Close()

	if zone == "" && region == "" {
		return fmt.Errorf("you need to specify `zone` or `region` for this function to work")
	}

	if zone != "" && region != "" {
		return fmt.Errorf("you can't set both `zone` and `region` parameters")
	}

	if diskProjectID == "" {
		diskProjectID = projectID
	}

	disk := &computepb.Disk{}
	locations := []string{}
	if location != "" {
		locations = append(locations, location)
	}

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

		getDiskReq := &computepb.GetDiskRequest{
			Project: projectID,
			Zone:    zone,
			Disk:    diskName,
		}

		disk, err = disksClient.Get(ctx, getDiskReq)
		if err != nil {
			return fmt.Errorf("unable to get disk: %w", err)
		}
	} else {
		regionDisksClient, err := compute.NewRegionDisksRESTClient(ctx)
		if err != nil {
			return fmt.Errorf("NewRegionDisksRESTClient: %w", err)
		}
		defer regionDisksClient.Close()

		getDiskReq := &computepb.GetRegionDiskRequest{
			Project: projectID,
			Region:  region,
			Disk:    diskName,
		}

		disk, err = regionDisksClient.Get(ctx, getDiskReq)
		if err != nil {
			return fmt.Errorf("unable to get disk: %w", err)
		}
	}

	req := &computepb.InsertSnapshotRequest{
		Project: projectID,
		SnapshotResource: &computepb.Snapshot{
			Name:             proto.String(snapshotName),
			SourceDisk:       proto.String(disk.GetSelfLink()),
			StorageLocations: locations,
		},
	}

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

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

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

	return nil
}

Java


import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.RegionDisksClient;
import com.google.cloud.compute.v1.Snapshot;
import com.google.cloud.compute.v1.SnapshotsClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateSnapshot {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // You need to pass `zone` or `region` parameter relevant to the disk you want to
    // snapshot, but not both. Pass `zone` parameter for zonal disks and `region` for
    // regional disks.

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

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

    // Name of the snapshot that you want to create.
    String snapshotName = "YOUR_SNAPSHOT_NAME";

    // The zone of the source disk from which you create the snapshot (for zonal disks).
    String zone = "europe-central2-b";

    // The region of the source disk from which you create the snapshot (for regional disks).
    String region = "your-disk-region";

    // The Cloud Storage multi-region or the Cloud Storage region where you
    // want to store your snapshot.
    // You can specify only one storage location. Available locations:
    // https://cloud.google.com/storage/docs/locations#available-locations
    String location = "europe-central2";

    // Project ID or project number of the Cloud project that
    // hosts the disk you want to snapshot. If not provided, the value will be defaulted
    // to 'projectId' value.
    String diskProjectId = "YOUR_DISK_PROJECT_ID";

    createSnapshot(projectId, diskName, snapshotName, zone, region, location, diskProjectId);
  }

  // Creates a snapshot of a disk.
  public static void createSnapshot(String projectId, String diskName, String snapshotName,
      String zone, String region, String location, String diskProjectId)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {

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

      if (zone.isEmpty() && region.isEmpty()) {
        throw new Error("You need to specify 'zone' or 'region' for this function to work");
      }

      if (!zone.isEmpty() && !region.isEmpty()) {
        throw new Error("You can't set both 'zone' and 'region' parameters");
      }

      // If Disk's project id is not specified, then the projectId parameter will be used.
      if (diskProjectId.isEmpty()) {
        diskProjectId = projectId;
      }

      // If zone is not empty, use the DisksClient to create a disk.
      // Else, use the RegionDisksClient.
      Disk disk;
      if (!zone.isEmpty()) {
        DisksClient disksClient = DisksClient.create();
        disk = disksClient.get(projectId, zone, diskName);
      } else {
        RegionDisksClient regionDisksClient = RegionDisksClient.create();
        disk = regionDisksClient.get(diskProjectId, region, diskName);
      }

      // Set the snapshot properties.
      Snapshot snapshotResource;
      if (!location.isEmpty()) {
        snapshotResource = Snapshot.newBuilder()
            .setName(snapshotName)
            .setSourceDisk(disk.getSelfLink())
            .addStorageLocations(location)
            .build();
      } else {
        snapshotResource = Snapshot.newBuilder()
            .setName(snapshotName)
            .setSourceDisk(disk.getSelfLink())
            .build();
      }

      // Wait for the operation to complete.
      Operation operation = snapshotsClient.insertAsync(projectId, snapshotResource)
          .get(3, TimeUnit.MINUTES);

      if (operation.hasError()) {
        System.out.println("Snapshot creation failed!" + operation);
        return;
      }

      // Retrieve the created snapshot.
      Snapshot snapshot = snapshotsClient.get(projectId, snapshotName);
      System.out.printf("Snapshot created: %s", snapshot.getName());

    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const diskName = 'YOUR_DISK_NAME';
// const snapshotName = 'YOUR_SNAPSHOT_NAME';
// const zone = 'europe-central2-b';
// const region = '';
// const location = 'europe-central2';
// let diskProjectId = 'YOUR_DISK_PROJECT_ID';

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

async function createSnapshot() {
  const snapshotsClient = new compute.SnapshotsClient();

  let disk;

  if (!zone && !region) {
    throw new Error(
      'You need to specify `zone` or `region` for this function to work.'
    );
  }

  if (zone && region) {
    throw new Error("You can't set both `zone` and `region` parameters");
  }

  if (!diskProjectId) {
    diskProjectId = projectId;
  }

  if (zone) {
    const disksClient = new compute.DisksClient();
    [disk] = await disksClient.get({
      project: diskProjectId,
      zone,
      disk: diskName,
    });
  } else {
    const regionDisksClient = new compute.RegionDisksClient();
    [disk] = await regionDisksClient.get({
      project: diskProjectId,
      region,
      disk: diskName,
    });
  }

  const snapshotResource = {
    name: snapshotName,
    sourceDisk: disk.selfLink,
  };

  if (location) {
    snapshotResource.storageLocations = [location];
  }

  const [response] = await snapshotsClient.insert({
    project: projectId,
    snapshotResource,
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.GlobalOperationsClient();

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

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

createSnapshot();

Python

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


def create_snapshot(
    project_id: str,
    disk_name: str,
    snapshot_name: str,
    *,
    zone: str | None = None,
    region: str | None = None,
    location: str | None = None,
    disk_project_id: str | None = None,
) -> compute_v1.Snapshot:
    """
    Create a snapshot of a disk.

    You need to pass `zone` or `region` parameter relevant to the disk you want to
    snapshot, but not both. Pass `zone` parameter for zonal disks and `region` for
    regional disks.

    Args:
        project_id: project ID or project number of the Cloud project you want
            to use to store the snapshot.
        disk_name: name of the disk you want to snapshot.
        snapshot_name: name of the snapshot to be created.
        zone: name of the zone in which is the disk you want to snapshot (for zonal disks).
        region: name of the region in which is the disk you want to snapshot (for regional disks).
        location: The Cloud Storage multi-region or the Cloud Storage region where you
            want to store your snapshot.
            You can specify only one storage location. Available locations:
            https://cloud.google.com/storage/docs/locations#available-locations
        disk_project_id: project ID or project number of the Cloud project that
            hosts the disk you want to snapshot. If not provided, will look for
            the disk in the `project_id` project.

    Returns:
        The new snapshot instance.
    """
    if zone is None and region is None:
        raise RuntimeError(
            "You need to specify `zone` or `region` for this function to work."
        )
    if zone is not None and region is not None:
        raise RuntimeError("You can't set both `zone` and `region` parameters.")

    if disk_project_id is None:
        disk_project_id = project_id

    if zone is not None:
        disk_client = compute_v1.DisksClient()
        disk = disk_client.get(project=disk_project_id, zone=zone, disk=disk_name)
    else:
        regio_disk_client = compute_v1.RegionDisksClient()
        disk = regio_disk_client.get(
            project=disk_project_id, region=region, disk=disk_name
        )

    snapshot = compute_v1.Snapshot()
    snapshot.source_disk = disk.self_link
    snapshot.name = snapshot_name
    if location:
        snapshot.storage_locations = [location]

    snapshot_client = compute_v1.SnapshotsClient()
    operation = snapshot_client.insert(project=project_id, snapshot_resource=snapshot)

    wait_for_extended_operation(operation, "snapshot creation")

    return snapshot_client.get(project=project_id, snapshot=snapshot_name)

REST

Puedes crear una instantánea con los datos del disco de origen o con su punto de control de recuperación de réplicas.

Desde datos de disco

Para crear la instantánea en la ubicación predeterminada o personalizada establecida en tu configuración de instantáneas, haz una solicitud POST al método snapshots.insert.

POST https://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/global/snapshots
{
  "name": "SNAPSHOT_NAME",
  "sourceDisk": "projects/SOURCE_PROJECT_ID/regions/SOURCE_REGION/disks/SOURCE_DISK_NAME",
  "snapshotType": "SNAPSHOT_TYPE"
}

POST https://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/global/snapshots
{
  "name": "SNAPSHOT_NAME",
  "sourceDisk": "projects/SOURCE_PROJECT_ID/regions/SOURCE_REGION/disks/SOURCE_DISK_NAME",
  "snapshotType": "SNAPSHOT_TYPE",
  "storageLocations": [
      "STORAGE_LOCATION"
  ],
}

Reemplaza lo siguiente:

DESTINATION_PROJECT_ID: Es el ID del proyecto en el que deseas crear la instantánea.
SNAPSHOT_NAME: Es un nombre para la instantánea.
SOURCE_PROJECT_ID: Es el ID del proyecto del disco de origen.
SOURCE_REGION: Es la región del disco de origen.
SOURCE_DISK_NAME: Es el nombre del Persistent Disk regional o del volumen de Alta disponibilidad balanceada de Hyperdisk desde el que deseas crear una instantánea.
SNAPSHOT_TYPE: Es el tipo de instantánea, ya sea STANDARD o ARCHIVE. Si no se especifica un tipo de instantánea, se crea una instantánea STANDARD.
STORAGE_LOCATION: Opcional: la multirregión de Cloud Storage o la región de Cloud Storage en la que quieres almacenar la instantánea. Solo puedes especificar una ubicación de almacenamiento.

Usa el parámetro storageLocations solo cuando quieras anular la ubicación de almacenamiento predeterminada o personalizada establecida en tu configuración de instantáneas.

Desde el punto de control

Como alternativa, puedes crear la instantánea a través del punto de control de recuperación de réplicas de un disco degradado. La instantánea se creará siempre y cuando la réplica incompleta esté disponible.

Para crear una instantánea con el punto de control de recuperación de réplicas, realiza una solicitud POST al método snapshots.insert. Excluye el parámetro sourceDisk y, en su lugar, incluye el parámetro sourceDiskForRecoveryCheckpoint para especificar que deseas crear la instantánea con el punto de control.

POST https://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/global/snapshots

{
  "name": "SNAPSHOT_NAME",
  "sourceDiskForRecoveryCheckpoint": "projects/SOURCE_PROJECT_ID/regions/SOURCE_REGION/disks/SOURCE_DISK_NAME",
  "storageLocations": "STORAGE_LOCATION",
  "snapshotType": "SNAPSHOT_TYPE"
}

Reemplaza lo siguiente:

DESTINATION_PROJECT_ID: Es el ID del proyecto en el que deseas crear la instantánea.
SNAPSHOT_NAME: Es un nombre para la instantánea.
SOURCE_PROJECT_ID: Es el ID del proyecto del disco de origen cuyo punto de control deseas usar para crear la instantánea.
SOURCE_REGION: el nombre del disco de origen cuyo punto de control quieres usar para crear la instantánea.
SOURCE_DISK_NAME: el nombre del disco de origen cuyo punto de control quieres usar para crear la instantánea.
STORAGE_LOCATION: Opcional: la multirregión de Cloud Storage o la región de Cloud Storage en la que quieres almacenar la instantánea. Solo puedes especificar una ubicación de almacenamiento.
Usa el parámetro storageLocations solo cuando quieras anular la ubicación de almacenamiento predeterminada o personalizada establecida en tu configuración de instantáneas.
SNAPSHOT_TYPE: Es el tipo de instantánea, ya sea ESTANDARD o ARCHIVO. Si no se especifica un tipo de instantánea, se crea una instantánea ESTANDARD.

The device is fully replicated and should not create snapshots out of a recovery checkpoint. Please
create regular snapshots instead.

Crea una instantánea de un Hyperdisk

Console

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

Ir a Instancias de VM
Selecciona el proyecto que contiene las instancias de VM.
En la columna Nombre, haz clic en el nombre de la VM que tiene el Hyperdisk del que se creará una copia de seguridad.
En Almacenamiento, en Discos adicionales, haz clic en el Nombre del Hyperdisk conectado.
Haz clic en Crear instantánea.
En Nombre, ingresa un nombre único que ayude a identificar el propósito de la instantánea, por ejemplo, hyperdisk-data-snapshot.
En Tipo, el valor predeterminado es una instantánea normal, que es la mejor opción para las copias de seguridad a largo plazo y la recuperación ante desastres.
En la sección Ubicación, elige la ubicación de almacenamiento de instantáneas.

La ubicación predeterminada predefinida o personalizada que se define en la configuración de la instantánea se elige de forma automática. De manera opcional, puedes anular la configuración de la instantánea y almacenar tus instantáneas en una ubicación de almacenamiento personalizada si haces lo siguiente:
1. Elige el tipo de ubicación de almacenamiento que deseas para tu instantánea.
  - Elige Multirregionalpara obtener una mayor disponibilidad a un costo más alto.
  - Elige Instantáneas regionales para tener más control sobre la ubicación física de los datos a un costo más bajo.
2. En el campo Seleccionar ubicación, elige la región o multirregión específica que deseas usar. Para usar la región o multirregión más cercana al disco de origen, selecciona En función de la ubicación del disco.
Haz clic en Crear.

gcloud

Debes especificar un nombre de instantánea. El nombre debe tener entre 1 y 63 caracteres y cumplir con RFC 1035.

Para crear una instantánea en la ubicación predefinida o en la ubicación personalizada predeterminada que se estableció en la configuración de instantánea, usa el comando gcloud compute snapshots create.
```
gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-zone=SOURCE_ZONE \
    --source-disk=SOURCE_DISK_NAME \
    --snapshot-type=SNAPSHOT_TYPE
```
De lo contrario, si quieres anular la configuración de la instantánea y crear una instantánea en una ubicación de almacenamiento personalizada, incluye la marca --storage-location para indicar dónde almacenar la instantánea.
```
gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-zone=SOURCE_ZONE \
    --source-disk=SOURCE_DISK_NAME \
    --snapshot-type=SNAPSHOT_TYPE \
    --storage-location=STORAGE_LOCATION
```
Reemplaza lo siguiente:
- SNAPSHOT_NAME: Es un nombre para la instantánea.
- SOURCE_ZONE: Es la zona del disco de origen.
- SOURCE_DISK_NAME: Es el nombre del volumen de Hyperdisk desde el que deseas crear una instantánea.
- SNAPSHOT_TYPE: Es el tipo de instantánea, ya sea STANDARD o ARCHIVE. Si no se especifica un tipo de instantánea, se crea una instantánea STANDARD.
- STORAGE_LOCATION: Opcional: la multirregión de Cloud Storage o la región de Cloud Storage en la que quieres almacenar la instantánea. Solo puedes especificar una ubicación de almacenamiento.
  
  Usa el parámetro --storage-location solo cuando quieras anular la ubicación de almacenamiento predeterminada o personalizada establecida en tu configuración de instantáneas.
Nota: Google recomienda usar el comando gcloud compute snapshots create en lugar del comando gcloud compute disks snapshot porque admite más funciones, como la creación de instantáneas en un proyecto diferente del proyecto de disco de origen.

La CLI de gcloud espera hasta que la operación muestre un estado de READY o FAILED, o hasta que alcance el tiempo de espera máximo y muestre los últimos detalles conocidos de la instantánea.

REST

Debes especificar un nombre de instantánea. El nombre debe tener entre 1 y 63 caracteres y cumplir con RFC 1035.

Para crear la instantánea en la ubicación predeterminada o personalizada establecida en tu configuración de instantáneas, haz una solicitud POST al método snapshots.insert.

POST https://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/global/snapshots
{
    "name": "SNAPSHOT_NAME",
    "sourceDisk": "projects/SOURCE_PROJECT_ID/zones/SOURCE_ZONE/disks/SOURCE_DISK_NAME",
    "snapshotType": "SNAPSHOT_TYPE"
}

POST https://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/global/snapshots
{
    "name": "SNAPSHOT_NAME",
    "sourceDisk": "projects/SOURCE_PROJECT_ID/zones/SOURCE_ZONE/disks/SOURCE_DISK_NAME",
    "snapshotType": "SNAPSHOT_TYPE",
    "storageLocations": [
        "STORAGE_LOCATION"
    ],
}

Reemplaza lo siguiente:

DESTINATION_PROJECT_ID: Es el ID del proyecto en el que deseas crear la instantánea.
SNAPSHOT_NAME: Es un nombre para la instantánea.
SOURCE_PROJECT_ID: Es el ID del proyecto del disco de origen.
SOURCE_ZONE: Es la zona del disco de origen.
SOURCE_DISK_NAME: Es el nombre del volumen de Hyperdisk desde el que deseas crear una instantánea.
SNAPSHOT_TYPE: Es el tipo de instantánea, ya sea STANDARD o ARCHIVE. Si no se especifica un tipo de instantánea, se crea una instantánea STANDARD.
STORAGE_LOCATION: Opcional: la multirregión de Cloud Storage o la región de Cloud Storage en la que quieres almacenar la instantánea. Solo puedes especificar una ubicación de almacenamiento.

Usa el parámetro storageLocations solo cuando quieras anular la ubicación de almacenamiento predeterminada o personalizada establecida en tu configuración de instantáneas.

¿Qué sigue?

Obtén información sobre cómo crear instantáneas programadas para discos.
Obtén información sobre cómo ver, borrar y compartir instantáneas de discos.
Obtén más información sobre cómo crear una imagen de disco a partir de instantáneas.