Esta página se ha traducido con Cloud Translation API.

Crear una copia de seguridad de tus datos mediante una captura

En esta página se explica cómo crear una instantánea para hacer una copia de seguridad de los datos almacenados en tu instancia de cuadernos gestionados por el usuario de Vertex AI Workbench.

Los datos de tu instancia se almacenan en un disco persistente de zona. Puedes crear y usar capturas de este disco para crear copias de seguridad de tus datos, crear una programación de copias de seguridad periódicas y restaurar datos en una instancia nueva.

Crear una captura

Puedes crear capturas de discos incluso cuando estén vinculados a instancias en ejecución. Las copias de seguridad son recursos globales, por lo que puedes usarlas para restaurar datos en un disco o una instancia nuevos del mismo proyecto. También puedes compartir capturas entre proyectos.

Permisos que se necesitan para completar esta tarea

Para realizar esta tarea, debes tener los siguientes permisos:

compute.snapshots.create en el proyecto
compute.disks.createSnapshot en el disco

Consola

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

Ve a Instancias de VM.
Los pasos restantes aparecerán automáticamente en la Google Cloud consola.
Selecciona el proyecto que contiene tus instancias de VM.
En la columna Nombre, haz clic en el nombre de la VM que tiene el disco que quieres crear como 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 adjunto, en Discos adicionales, haz clic en el Nombre del disco.
Haz clic en Crear copia.
En Nombre, introduzca un nombre único que le 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 ideales para las copias de seguridad a largo plazo y la recuperación tras fallos.
Elige Captura de archivo para crear una copia de seguridad más rentable que las capturas 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ánea.
En la sección Ubicación, elige la ubicación de almacenamiento de tu foto de perfil. Se selecciona automáticamente la ubicación predefinida o personalizada que haya definido en la configuración de la vista general. Si quieres, puedes anular los ajustes de las instantáneas y almacenarlas en una ubicación de almacenamiento personalizada siguiendo estos pasos:
1. Elige el tipo de ubicación de almacenamiento que quieras para tu copia.
  - Elige Multirregional para disfrutar de una mayor disponibilidad a un coste más elevado.
  - Elige Instantáneas regionales para tener más control sobre la ubicación física de tus datos a un coste más bajo.
2. En el campo Seleccionar ubicación, elige la región o multirregión específica que quieras usar. Para usar la región o multirregión más cercana a tu disco de origen, elige una ubicación en la sección Según la ubicación del disco.
Para crear una captura, haz clic en Crear.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Crea la captura con la política de ubicación de almacenamiento definida en los ajustes de la captura o con una ubicación de almacenamiento alternativa que elijas. Para obtener más información, consulta Elegir la ubicación de almacenamiento de las copias de seguridad. Debes especificar un nombre de instantánea. El nombre debe tener entre 1 y 63 caracteres, y cumplir la RFC 1035.
- Para crear una captura de un volumen de disco persistente en la ubicación predefinida o personalizada configurada en los ajustes de la captura, usa el comando gcloud compute snapshots create.
```
gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk SOURCE_DISK \
    --snapshot-type SNAPSHOT_TYPE \
    --source-disk-zone SOURCE_DISK_ZONE
```
- También puedes anular la configuración de la instantánea y crear una instantánea en una ubicación de almacenamiento personalizada. Para ello, incluye la marca --storage-location para indicar dónde quieres almacenar la instantánea:
```
gcloud compute snapshots create SNAPSHOT_NAME \
  --source-disk SOURCE_DISK \
  --source-disk-zone SOURCE_DISK_ZONE \
  --storage-location STORAGE_LOCATION \
  --snapshot-type SNAPSHOT_TYPE
```
  Haz los cambios siguientes:
  - SNAPSHOT_NAME: nombre de la captura.
  - SOURCE_DISK: nombre del volumen de Persistent Disk de zona del que quieres crear una captura.
  - SNAPSHOT_TYPE: el tipo de instantánea, STANDARD o ARCHIVE. Si no se especifica ningún tipo de captura, se crea una captura STANDARD. Elige Archivar para conservar los datos de forma más rentable.
  - SOURCE_DISK_ZONE: la zona del volumen de Persistent Disk zonal del que quieres crear una captura.
  - STORAGE_LOCATION: En el caso de las ubicaciones de almacenamiento personalizadas, se trata de la multirregión de Cloud Storage o de la región de Cloud Storage en la que quieras almacenar tu snapshot. Solo puedes especificar una ubicación de almacenamiento.
  Usa la marca --storage-location solo cuando quieras anular la ubicación de almacenamiento predefinida o personalizada que hayas configurado en los ajustes de la instantánea.
La CLI de gcloud espera hasta que la operación devuelva el estado READY o FAILED, o hasta que alcance el tiempo de espera máximo y devuelva los últimos detalles conocidos de la instantánea.

Nota: Google recomienda usar el comando gcloud compute snapshots createen lugar del comando gcloud compute disks snapshot porque admite más funciones, como crear snapshots en un proyecto diferente del proyecto del disco de origen.

Terraform

Para crear una captura del disco persistente de zona, 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"
}

Para saber cómo aplicar o quitar una configuración de Terraform, consulta Comandos básicos de Terraform.

API

Crea la captura en la política de ubicación de almacenamiento definida en los ajustes de la captura o en una ubicación de almacenamiento alternativa que elijas. Para obtener más información, consulta Elegir la ubicación de almacenamiento de las copias de seguridad.

Para crear una captura en la ubicación predefinida o personalizada que hayas configurado en los ajustes de captura, 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
}
```
Haz los cambios siguientes:
- DESTINATION_PROJECT_ID: el ID del proyecto en el que quieres crear la instantánea.
- SNAPSHOT_NAME: nombre de la captura.
- SOURCE_PROJECT_ID: el ID del proyecto del disco de origen.
- SOURCE_ZONE: la zona del disco de origen.
- SOURCE_DISK_NAME: Nombre del disco persistente a partir del que quieres crear una captura.
- SNAPSHOT_TYPE: el tipo de instantánea, STANDARD o ARCHIVE. Si no se especifica ningún tipo de captura, se crea una captura STANDARD.
También puedes anular la configuración de la instantánea y crear una en una ubicación de almacenamiento personalizada. Para ello, haz una solicitud POST al método snapshots.insert e 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
}
```
Haz los cambios siguientes:
- DESTINATION_PROJECT_ID: el ID del proyecto en el que quieres crear la instantánea.
- SNAPSHOT_NAME: nombre de la captura.
- SOURCE_PROJECT_ID: el ID del proyecto del disco de origen.
- SOURCE_ZONE: la zona del disco de origen.
- SOURCE_DISK_NAME: Nombre del disco persistente a partir del que quieres crear una captura.
- SNAPSHOT_TYPE: el tipo de instantánea, STANDARD o ARCHIVE. Si no se especifica ningún tipo de captura, se crea una captura STANDARD.
- STORAGE_LOCATION: la multirregión de Cloud Storage o la región de Cloud Storage en la que quieras almacenar tu snapshot. Solo puedes especificar una ubicación de almacenamiento.
  
  Usa el parámetro storageLocations solo cuando quieras anular la ubicación de almacenamiento predefinida o personalizada que hayas configurado en los ajustes de la instantánea.

Go

Antes de probar este ejemplo, sigue las instrucciones de configuración de la guía de inicio rápido de Compute Engine con bibliotecas de cliente.

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configurar la autenticación en 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 este ejemplo, sigue las instrucciones de configuración de la guía de inicio rápido de Compute Engine con bibliotecas de cliente.


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 este ejemplo, sigue las instrucciones de configuración de la guía de inicio rápido de Compute Engine con bibliotecas de cliente.

/**
 * 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 este ejemplo, sigue las instrucciones de configuración de la guía de inicio rápido de Compute Engine con bibliotecas de 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_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)

Programar una copia de seguridad periódica

Cuando creas una programación de instantáneas, creas una política de recursos que puedes aplicar a uno o varios discos persistentes. Puedes crear programaciones de instantáneas de las siguientes formas:

Crea una programación de instantáneas y, a continuación, vincúlala a un disco persistente.
Crea un disco persistente con una programación de capturas.

Una programación de instantáneas incluye las siguientes propiedades:

Nombre de la programación
Descripción de la programación
Frecuencia de las capturas (por horas, diaria o semanal)
Hora de inicio de la captura
Región en la que está disponible la programación de las capturas
Política de eliminación del disco de origen para gestionar las instantáneas generadas automáticamente si se elimina el disco de origen
Política de conservación para definir durante cuánto tiempo se conservarán las capturas generadas a partir de la programación de capturas

Restricciones

Un disco persistente puede tener como máximo 10 programaciones de instantáneas asociadas a la vez.
No puedes crear capturas de archivo mediante una programación de capturas.
Puedes crear un máximo de 1000 programaciones de instantáneas en uso por región.
Las programaciones de capturas solo se aplican en el proyecto en el que se crearon. Las programaciones de instantáneas no se pueden usar en otros proyectos ni organizaciones.
Es posible que tengas que solicitar un aumento de la cuota de recursos a través de la consola si necesitas recursos adicionales en tu región.
No puedes eliminar una programación de instantáneas si está vinculada a un disco. Debes desvincular la programación de todos los discos y, a continuación, eliminarla.
Puedes actualizar una programación de capturas para cambiar la descripción, la programación y las etiquetas. Para actualizar otros valores de una programación de capturas, debes eliminarla y crear una nueva.
En el caso de los discos persistentes que usan una clave de cifrado proporcionada por el cliente (CSEK), no puedes crear programaciones de capturas.
En el caso de los discos persistentes que usan una clave de cifrado gestionada por el cliente (CMEK), todas las capturas creadas con una programación de capturas se cifran automáticamente con la misma clave.

Crear programación

Permisos que se necesitan para completar esta tarea

Para realizar esta tarea, debes tener los siguientes permisos:

compute.resourcePolicies.create en el proyecto o la organización

Crea una programación de snapshots para tus discos persistentes con la Google Cloud consola, la CLI de Google Cloud o la API de Compute Engine. Debes crear la programación de capturas en la misma región en la que se encuentre el disco persistente. Por ejemplo, si tu disco persistente se encuentra en la zona us-west1-a, tu programación de capturas debe estar en la región us-west1. Para obtener más información, consulta Elegir una ubicación de almacenamiento.

Consola

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

Ve a Instancias de VM.
Los pasos restantes aparecerán automáticamente en la Google Cloud consola.
Selecciona el proyecto que contiene tus instancias de VM.
En la columna Nombre, haz clic en el nombre de la VM que tiene el disco persistente para el que quieres crear una programación de capturas.
En Almacenamiento, haz clic en el nombre del disco de arranque o del disco adicional para crear una programación de instantáneas.
Haz clic en Editar. Puede que tengas que hacer clic en el menú Más acciones y, a continuación, Editar.
En Programación de capturas, elige Crear programación.
En Nombre, introduce uno de los siguientes nombres para la programación de capturas:
- boot-disk-snapshot-schedule
- attached-persistent-disk-snapshot-schedule
En la sección Ubicación, elige la ubicación de almacenamiento de tu instantánea. Se selecciona automáticamente la ubicación predefinida o personalizada que haya definido en la configuración de la vista general. Si quieres, puedes anular los ajustes de las instantáneas y almacenarlas en una ubicación de almacenamiento personalizada. Para ello, sigue estos pasos:
1. Elige el tipo de ubicación de almacenamiento que quieras para tu copia.
  - Elige Multirregional para disfrutar de una mayor disponibilidad a un coste más elevado.
  - Elige Copias de seguridad regionales para tener más control sobre la ubicación física de tus datos a un coste más bajo.
2. En el campo Seleccionar ubicación, elige la región o multirregión específica que quieras usar. Para usar la región o multirregión más cercana a tu disco de origen, selecciona Según la ubicación del disco.
Para terminar de crear la programación de capturas, haz clic en Crear.
Para adjuntar esta programación de instantáneas al disco persistente, haz clic en Guardar.

gcloud

Para crear una programación de capturas de discos persistentes, usa el comando compute resource-policies create snapshot-schedule gcloud. Define la frecuencia de la programación como horaria, diaria o semanal.

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

donde:

[SCHEDULE_NAME] es el nombre de la nueva programación de capturas.
"[SCHEDULE_DESCRIPTION]" es una descripción de la programación de capturas. Escribe la descripción entre comillas.
[MAX_RETENTION_DAYS] es el número de días que se conservará la instantánea. Por ejemplo, si se define el valor 3, las capturas se conservarán durante 3 días antes de eliminarse. Debes definir una política de conservación de al menos 1 día.
[START_TIME] es la hora de inicio en UTC. La hora debe empezar en punto. Por ejemplo:
- Las 14:00 (PST) son las 22:00.
- Si defines una hora de inicio de 22:13, recibirás un error.
[SNAPSHOT_INTERVAL] define el intervalo en el que quieres que se creen las instantáneas. Define la programación horaria con un número entero entre 1 y 23. Elige un número de horas que se divida entre 24 de forma uniforme. Por ejemplo, si se define --hourly-schedule en 12, la instantánea se genera cada 12 horas. En una programación semanal, define los días en los que quieres que se creen las instantáneas. Debes escribir los días de la semana, sin distinguir entre mayúsculas y minúsculas. Las marcas de frecuencia de las capturas hourly-schedule, daily-schedule y weekly-schedule se excluyen entre sí. Debes elegir una para tu programación de capturas.

Nota: Si quieres especificar una programación semanal con diferentes días de la semana y con diferentes horas de inicio, usa --weekly-schedule-from-file.
[FILE_NAME] es el nombre del archivo que contiene la programación de la captura semanal, si decides proporcionar la programación en este formato. Ten en cuenta que puedes especificar programaciones semanales en diferentes días de la semana y a diferentes horas mediante un archivo (pero no puedes especificar varias programaciones semanales directamente en la línea de comandos). Por ejemplo, puede que en tu archivo se especifique una programación de instantáneas para los lunes y los miércoles: [{"day": "MONDAY", "startTime": "04:00"}, {"day": "WEDNESDAY", "startTime": "02:00"}] Si incluyes una hora de inicio en el archivo, no es necesario que definas la marca --start-time. La programación usa el estándar de hora UTC.
[DELETION_OPTION] determina qué ocurre con tus copias si se elimina el disco de origen. Elige la opción predeterminada keep-auto-snapshots omitiendo esta marca o usa apply-retention-policy para aplicar una política de retención.

Estos son otros ejemplos para configurar una programación de capturas. En todos los ejemplos siguientes:

Se incluye la regla de eliminación de discos. La marca --on-source-disk-delete tiene el valor predeterminado keep-auto-snapshots para conservar de forma permanente todas las capturas generadas automáticamente. Otra opción es asignar el valor apply-retention-policy a esta marca para usar tu política de conservación de copias de seguridad.
La ubicación de almacenamiento se ha definido como US, por lo que todas las instantáneas generadas se almacenarán en la multirregión de EE. UU.
Las etiquetas env=dev y media=images se aplican a todas las capturas generadas.
La política de conservación es de 10 días.

Programación por horas: en este ejemplo, la programación de capturas empieza a las 22:00 UTC y se realiza cada 4 horas.

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

Programación diaria: en este ejemplo, la programación de instantáneas empieza a las 22:00 UTC y se repite todos los días a la misma hora. La marca --daily-schedule debe estar presente, pero no debe tener ningún valor asignado.

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

Programación semanal: en este ejemplo, la programación de la instantánea empieza a las 22:00 UTC y se repite todas las semanas los martes y los jueves.

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

API

En la API, crea una solicitud POST a resourcePolicies.insert para crear una programación de capturas. Como mínimo, debe incluir el nombre de la programación de la captura, la ubicación regional del almacenamiento de la captura y la frecuencia de la captura.

De forma predeterminada, el parámetro onSourceDiskDelete tiene el valor keepAutoSnapshots. Esto significa que, si se elimina el disco de origen, la instantánea generada automáticamente de ese disco se conservará indefinidamente. También puedes definir la marca en applyRetentionPolicy para aplicar tu política de conservación.

En el siguiente ejemplo se define una programación de creación de instantáneas diarias que empieza a las 12:00 UTC y se repite todos los días. En el ejemplo también se define una política de conservación de 5 días. Después de ese periodo, las capturas se eliminan automáticamente.

También puedes incluir opciones de localidad de la instantánea y etiquetas de la instantánea en tu solicitud para asegurarte de que las instantáneas se almacenan en la ubicación que elijas.

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

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

donde:

[PROJECT_ID] es el nombre del proyecto.
[REGION] es la ubicación de la política de recursos de la programación de capturas.
[SCHEDULE_DESCRIPTION] es la descripción de la programación de capturas.
[SCHEDULE_NAME] es el nombre de la programación de capturas.

Del mismo modo, puedes crear una programación semanal o mensual. Consulta la referencia de la API para obtener información específica sobre cómo definir una programación semanal o mensual.

Por ejemplo, la siguiente solicitud crea una programación semanal que se ejecuta los martes y los jueves a las 9:00 y a las 14:00, respectivamente.

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

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

Adjuntar una programación de capturas a un disco

Permisos que se necesitan para completar esta tarea

Para realizar esta tarea, debes tener los siguientes permisos:

compute.disks.addResourcePolicies en el disco
compute.resourcePolicies.use en la política de recursos que quieras usar.

Una vez que tengas una programación, adjúntala a un disco. Usa la consola, el comando gcloud o el método de la API Compute Engine.

Consola

Asocia una programación de instantáneas a un disco.

En la Google Cloud consola, ve a la página Discos.
Ir a la página Discos
Selecciona el nombre del disco al que quieras adjuntar una programación de instantáneas. Se abrirá la página Gestionar disco.
En la página Gestionar disco, coloca el cursor sobre el menú Más acciones y haz clic en él. A continuación, selecciona Editar.
Utilice el menú desplegable Programación de instantáneas para añadir la programación al disco. También puedes crear una nueva programación.
Si has creado una programación, haz clic en Crear.
Haz clic en Guardar para completar la tarea.

gcloud

Para adjuntar una programación de capturas a un disco, usa el comando disks add-resource-policies gcloud.

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

donde:

[DISK_NAME] es el nombre del disco.
[SCHEDULE_NAME] es el nombre de la programación de capturas.
[ZONE] es la ubicación de tu disco.

API

En la API, crea una solicitud POST para disks.addResourcePolicies para asociar una programación de instantáneas a un disco.

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

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

donde:

[PROJECT_ID] es el nombre del proyecto.
[ZONE] es la ubicación del disco.
[REGION] es la ubicación de la programación de capturas.
[DISK_NAME] es el nombre del disco.
[SCHEDULE_NAME] es el nombre de la programación de capturas de esa región que estás aplicando a este disco.

Restaurar datos a partir de una captura

Si has creado una copia de seguridad de un disco de arranque o de un disco que no es de arranque con una captura, puedes crear un disco a partir de la captura.

Restricciones

El nuevo disco debe tener al menos el mismo tamaño que el disco de origen original de la captura. Si creas un disco más grande que el disco de origen original de la instantánea, debes cambiar el tamaño del sistema de archivos de ese disco persistente para incluir el espacio adicional. En función de tu sistema operativo y del tipo de sistema de archivos, es posible que tengas que usar otra herramienta para cambiar el tamaño del sistema de archivos. Para obtener más información, consulta la documentación de tu sistema operativo.

Crear un disco a partir de una instantánea y adjuntarlo a una VM

Permisos que se necesitan para completar esta tarea

Para realizar esta tarea, debes tener los siguientes permisos:

compute.disks.create en el proyecto para crear un disco.
compute.instances.attachDisk en la instancia de VM
Permiso compute.disks.use en el disco para adjuntar

Consola

En la Google Cloud consola, ve a la página Snapshots (Capturas).

Ir a Capturas
Busca el nombre de la copia de seguridad que quieras restaurar.
Ve a la página Discos.

Ir a la página Discos
Haz clic en Crear disco.
Especifica los siguientes parámetros de configuración:
- Nombre del disco.
- Tipo de disco.
- También puedes anular la selección predeterminada de región y zona. Puedes seleccionar cualquier región y zona, independientemente de la ubicación de almacenamiento de la captura de origen.
En Tipo de fuente, haz clic en Vista del día.
Selecciona el nombre de la copia de seguridad que quieras restaurar.
Selecciona el tamaño del nuevo disco en gigabytes. Este número debe ser igual o superior al disco de origen original de la instantánea.
Haz clic en Crear para crear el disco.

A continuación, puedes conectar el nuevo disco a una instancia.

Ve a la página Instancias de VM.
Ve a la página Instancias de VM.
Haga clic en el nombre de la instancia en la que quiera restaurar el disco que no es de arranque.
En la parte superior de la página de detalles de la instancia, haz clic en Editar.
En Discos adicionales, haz clic en Adjuntar disco existente.
Selecciona el nombre del nuevo disco creado a partir de tu captura.
Haz clic en Hecho para adjuntar el disco.
En la parte inferior de la página de detalles de la instancia, haz clic en Guardar para aplicar los cambios a la instancia.

gcloud

Usa el comando gcloud compute snapshots list para buscar el nombre de la copia de seguridad que quieras restaurar:
```
gcloud compute snapshots list
```
Usa el comando gcloud compute snapshots describe para buscar el tamaño de la instantánea que quieras restaurar:
```
gcloud compute snapshots describe SNAPSHOT_NAME
```
Sustituye SNAPSHOT_NAME por el nombre de la instantánea que se va a restaurar.
Usa el comando gcloud compute disks create para crear un disco regional o de zona a partir de tu captura. Si necesitas un disco persistente SSD para obtener más rendimiento o IOPS, incluye la marca --type y especifica pd-ssd.
```
gcloud compute disks create DISK_NAME \
    --size=DISK_SIZE \
    --source-snapshot=SNAPSHOT_NAME \
    --type=DISK_TYPE
```
Haz los cambios siguientes:
- DISK_NAME: el nombre del nuevo disco.
- DISK_SIZE: tamaño del nuevo disco en gigabytes. Este número debe ser igual o mayor que el disco de origen original de la instantánea.
- SNAPSHOT_NAME: el nombre de la captura que se está restaurando.
- DISK_TYPE: URL completa o parcial del tipo de disco. Por ejemplo, https://www.googleapis.com/compute/v1/projects/PROJECT_ID /zones/ZONE/diskTypes/pd-ssd.
Acopla el nuevo disco a una instancia que ya tengas con el gcloud compute instances attach-disk comando:
```
gcloud compute instances attach-disk INSTANCE_NAME \
    --disk DISK_NAME
```
Haz los cambios siguientes:
- INSTANCE_NAME es el nombre de la instancia.
- DISK_NAME es el nombre del disco creado a partir de tu captura.

API

Crea una solicitud GET a snapshots.list para mostrar la lista de capturas de tu proyecto.

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

Sustituye PROJECT_ID por el ID del proyecto.
Crea una solicitud POST para crear un disco zonal con el método disks.insert. Incluye las propiedades name, sizeGb y type. Para restaurar un disco mediante una instantánea, debes incluir la propiedad sourceSnapshot.
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/disks

{
 "name": "DISK_NAME",
 "sizeGb": "DISK_SIZE",
 "type": "zones/ZONE/diskTypes/DISK_TYPE"
 "sourceSnapshot": "SNAPSHOT_NAME"
}
```
Haz los cambios siguientes:
- PROJECT_ID: tu ID de proyecto.
- ZONE la zona en la que se encuentran la instancia y el nuevo disco.
- DISK_NAME: el nombre del nuevo disco.
- DISK_SIZE: tamaño del nuevo disco, en gigabytes. Este número debe ser igual o mayor que el disco de origen original de la instantánea.
- DISK_TYPE: URL completa o parcial del tipo de disco. Por ejemplo, https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ ZONE/diskTypes/pd-ssd.
- SNAPSHOT_NAME: la captura de origen del disco que estás restaurando.
Después, puedes adjuntar el nuevo disco a una instancia creando una solicitud POST al instances.attachDiskmétodo e incluyendo la URL del disco de zona que acabas de crear a partir de tu captura.
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/attachDisk

{
 "source": "/compute/v1/projects/PROJECT_ID/zones/ZONE/disks/DISK_NAME"
}
```
Haz los cambios siguientes:
- PROJECT_ID es el ID del proyecto.
- ZONE es la zona en la que se encuentran tu instancia y el nuevo disco.
- INSTANCE_NAME es el nombre de la instancia en la que vas a añadir el disco nuevo.
- DISK_NAME es el nombre del nuevo disco.

Go

Antes de probar este ejemplo, sigue las Go instrucciones de configuración de la guía de inicio rápido de Vertex AI con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go de Vertex AI.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en 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"
)

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

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

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

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

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

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

	return nil
}

Java

Antes de probar este ejemplo, sigue las Java instrucciones de configuración de la guía de inicio rápido de Vertex AI con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de Vertex AI.


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

public class CreateDiskFromSnapshot {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Node.js

Antes de probar este ejemplo, sigue las Node.js instrucciones de configuración de la guía de inicio rápido de Vertex AI con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de Vertex AI.

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const diskName = 'YOUR_DISK_NAME';
// const diskType = 'zones/us-west3-b/diskTypes/pd-ssd';
// const diskSizeGb = 10;
// const snapshotLink = 'projects/project_name/global/snapshots/snapshot_name';

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

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

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

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

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

createDiskFromSnapshot();

Python

Para saber cómo instalar o actualizar el SDK de Vertex AI para Python, consulta Instalar el SDK de Vertex AI para Python. Para obtener más información, consulta la documentación de referencia de la API Python.

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

    wait_for_extended_operation(operation, "disk creation")

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

Montar el disco

En el terminal, usa el comando lsblk para enumerar los discos que están conectados a tu instancia y busca el disco que quieras montar.
```
$ sudo lsblk

NAME   MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda      8:0    0   10G  0 disk
└─sda1   8:1    0   10G  0 part /
sdb      8:16   0  250G  0 disk
```
En este ejemplo, sdb es el nombre del dispositivo del nuevo disco persistente en blanco.
Usa la herramienta de montaje para montar el disco en la instancia y habilita la opción discard:
```
$ sudo mount -o discard,defaults /dev/DEVICE_NAME /home/jupyter
```
Haz los cambios siguientes:
- DEVICE_NAME: el nombre del dispositivo del disco que se va a montar.
Configura los permisos de lectura y escritura en el disco. En este ejemplo, se concede acceso de escritura al disco a todos los usuarios.
```
$ sudo chmod a+w /home/jupyter
```

Siguientes pasos

Consulta cómo guardar un cuaderno en GitHub.
Consulta más información sobre cómo crear capturas.
Más información sobre cómo programar capturas