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

Crea una copia de seguridad de los datos con una instantánea

En esta página, se muestra cómo crear una copia de seguridad de los datos almacenados en la instancia de notebooks administrados por el usuario de Vertex AI Workbench mediante la creación de una instantánea.

Los datos de tu instancia se almacenan en un disco persistente zonal. Puedes crear y usar instantáneas de este disco para crear una copia de seguridad de los datos, crear una programación de copia de seguridad recurrente y restablecer datos en una instancia nueva.

Crea una instantánea

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 instancia nuevos dentro del mismo proyecto. También puedes compartir instantáneas entre proyectos.

Permisos necesarios para esta tarea

Para hacer esta tarea, debes tener los siguientes permisos:

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

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

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 instantánea mediante la política de ubicación de almacenamiento definida en la configuración de la instantánea o mediante 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. 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 de un volumen de Persistent Disk en la ubicación predeterminada o personalizada establecida en tu configuración de instantáneas, 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
```
- 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 SOURCE_DISK \
  --source-disk-zone SOURCE_DISK_ZONE \
  --storage-location STORAGE_LOCATION \
  --snapshot-type SNAPSHOT_TYPE
```
  Reemplaza lo siguiente:
  - SNAPSHOT_NAME: Es un nombre para la instantánea.
  - SOURCE_DISK: El nombre del volumen de Persistent Disk zonal desde el que quieres crear una instantánea.
  - SNAPSHOT_TYPE: Es el tipo de instantánea, ya sea ESTÁNDAR o ARCHIVO. Si no se especifica un tipo de instantánea, se crea una instantánea ESTÁNDAR. Elige Instantánea de archivo para lograr una retención de datos más rentable.
  - SOURCE_DISK_ZONE: La zona del volumen de Persistent Disk zonal desde el que quieres crear una instantánea.
  - STORAGE_LOCATION: Para las ubicaciones de almacenamiento personalizadas, esta es la multirregión de Cloud Storage o la región de Cloud Storage en la que deseas almacenar tu instantánea. Solo puedes especificar una ubicación de almacenamiento.
  Usa la marca --storage-location solo cuando quieras anular la ubicación de almacenamiento predeterminada o personalizada establecida en tu configuración de instantáneas.
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.
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.

API

Crea la instantánea en la política de ubicación de almacenamiento definida en la configuración de la instantánea o mediante 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 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
}
```
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 disco persistente desde el que deseas crear una instantánea.
- 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.
De forma alternativa, para anular la configuración de instantáneas y crear una instantánea en una ubicación de almacenamiento personalizada, realiza 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
}
```
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 disco persistente desde el que deseas crear una instantánea.
- 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.
- STORAGE_LOCATION: es 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.

Go

Antes de probar esta muestra, sigue las instrucciones de configuración de la Guía de inicio rápido de Compute Engine: Usa las bibliotecas cliente.

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 la Guía de inicio rápido de Compute Engine: Usa las bibliotecas 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 esta muestra, sigue las instrucciones de configuración de la Guía de inicio rápido de Compute Engine: Usa las bibliotecas 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

SDK de Vertex AI para Python

Antes de probar esta muestra, sigue las instrucciones de configuración de la Guía de inicio rápido de Compute Engine: Usa las bibliotecas cliente.

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


def create_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)

Programa una copia de seguridad recurrente

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

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

Nombre de la programación
Descripción de la programación
Frecuencia de las instantáneas (por hora, diaria, semanal)
Hora de inicio de las instantáneas
Región donde está disponible el calendario de instantáneas
Política de borrado del disco de origen para manejar instantáneas generadas de forma automática, en caso de que se borre el disco de origen
Política de retención para definir cuánto tiempo se deben conservar las instantáneas generadas a partir de la programación de instantáneas

Restricciones

Un disco persistente puede tener como máximo 10 programaciones de instantáneas conectadas a la vez.
No puedes crear instantáneas de archivo mediante una programación de instantáneas.
Puedes crear un máximo de 1,000 programaciones de instantáneas en uso por región.
Las programaciones de instantáneas se aplican solo en el proyecto en el que se crearon. Las programaciones de instantáneas no se pueden usar en otras organizaciones ni proyectos.
Puede que debas solicitar un aumento de la cuota de recursos a través de la consola si necesitas recursos adicionales en tu región.
No puedes borrar una programación de instantáneas si está adjunta a un disco. Debes desconectar la programación de todos los discos y, luego, borrarla.
Puedes actualizar una programación de instantáneas existente para cambiar la descripción, la programación y las etiquetas. Si deseas actualizar otros valores para una programación de instantáneas, debes borrar la programación de instantáneas y crear una nueva.
Para los discos persistentes que usan una clave de encriptación proporcionada por el cliente (CSEK), no puedes crear programaciones de instantáneas.
Para los discos persistentes que usan una clave de encriptación administrada por el cliente (CMEK), todas las instantáneas creadas con una programación de instantáneas se encriptan de manera automática con la misma clave.

Crear una programación

Permisos necesarios para 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 instantáneas para tus discos persistentes a través de la consola de Google Cloud, Google Cloud CLI o la API de Compute Engine. Debes crear el programa de instantáneas en la misma región en la que reside tu disco persistente. Por ejemplo, si el disco persistente está en la zona us-west1-a, la programación de la instantáneas debe residir en la región us-west1. Para obtener más información, consulta Elige una ubicación de almacenamiento.

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.
Elige el proyecto que contiene las instancias de VM.
En la columna Nombre, haz clic en el nombre de la VM que tiene el disco persistente para el que deseas crear una programación de instantáneas.
En Almacenamiento, haz clic en el nombre del Disco de arranque o el Disco adicional para crear una programación de instantáneas.
Haz clic en Editar. Es posible que debas hacer clic en el menú Más acciones y, luego, en Editar.
En Programación de instantáneas, elige Crear una programación.
En Nombre, ingresa uno de los siguientes nombres para la programación de instantáneas:
- boot-disk-snapshot-schedule
- attached-persistent-disk-snapshot-schedule
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 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 Elegir 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.
Para terminar de crear la programación de instantáneas, haz clic en Crear.
Para adjuntar esta programación de instantáneas al disco persistente, haz clic en Guardar.

gcloud

Si quieres crear una programación de instantáneas para discos persistentes, usa el comando compute resource-policies create snapshot-schedule gcloud. Establece la frecuencia de la programación por hora, 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 programación de instantáneas nueva.
"[SCHEDULE_DESCRIPTION]" es la descripción de la programación de instantáneas. Coloca la descripción entre comillas.
[MAX_RETENTION_DAYS] es la cantidad de días que se retendrá la instantánea. Por ejemplo, si se configura en 3, las instantáneas se conservan durante 3 días antes de que se borren. Debes establecer una política de retención de al menos 1 día.
[START_TIME] es la hora de inicio en UTC. La hora debe ser en punto. Por ejemplo:
- 2:00 p.m. PST es 22:00.
- Si estableces la hora de inicio a las 22:13, recibirás un error.
[SNAPSHOT_INTERVAL] define el intervalo en el que quieres que ocurra la captura de instantáneas. Establece la programación por hora con un número entero entre 1 y 23. Elige un número que se divida de forma equitativa en 24. Por ejemplo, si estableces --hourly-schedule en 12, la instantánea se generará cada 12 horas. Para una programación semanal, debes definir los días en que quieres que ocurra la instantánea. Debes escribir los días de la semana, estos no distinguen entre mayúsculas y minúsculas. Las marcas de frecuencia de la instantánea hourly-schedule, daily-schedule y weekly-schedule son mutuamente excluyentes. Debes elegir una para tu programación de instantáneas.
Nota: Si quieres especificar un horario semanal con diferentes días de la semana y con diferentes horarios de inicio, usa --weekly-schedule-from-file en su lugar.
[FILE_NAME] es el nombre del archivo que contiene la programación de instantáneas semanal, si eliges proporcionar la programación en este formato. Ten en cuenta que puedes especificar programaciones semanales en diferentes días de la semana y horas con un archivo (pero no puedes especificar varias programaciones semanales directo en la línea de comandos). Por ejemplo, tu archivo podría especificar una programación de instantáneas el lunes y el miércoles: [{"day": "MONDAY", "startTime": "04:00"}, {"day": "WEDNESDAY", "startTime": "02:00"}]. Si incluyes una hora de inicio en el archivo, no necesitas establecer la marca --start-time. La programación usa el estándar de hora UTC.
[DELETION_OPTION] determina qué sucede con tus instantáneas si se borra el disco de origen. Puedes elegir el valor predeterminado keep-auto-snapshots si omites esta marca, o puedes usar apply-retention-policy para aplicar una política de retención.

A continuación, se indican algunos ejemplos adicionales para configurar una programación de instantáneas. En todos los ejemplos siguientes, se dan estas situaciones:

Se incluye la regla de eliminación del disco. La marca --on-source-disk-delete se establece en el valor predeterminado keep-auto-snapshots para mantener de forma permanente todas las instantáneas generadas de manera automática. Una alternativa es configurar esta marca en apply-retention-policy a fin de usar tu política de retención de instantáneas.
La ubicación de almacenamiento está establecida en 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 instantáneas generadas.
La política de retención se establece en 10 días.

Programación por hora: en este ejemplo, la programación de instantáneas comienza a las 10:00 p.m. UTC y se hace 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 comienza a las 10:00 p.m. UTC y se produce todos los días a la misma hora. La marca --daily-schedule debe estar presente, pero no establecida.

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 instantáneas comienza a las 10:00 p.m. UTC y se realiza todos los martes y jueves de cada semana.

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, realiza una solicitud POST a resourcePolicies.insert a fin de crear una programación de instantáneas. Como mínimo, debes incluir el nombre de la programación de instantáneas, la ubicación regional de almacenamiento y la frecuencia.

De forma predeterminada, el parámetro onSourceDiskDelete se establece en keepAutoSnapshots. Esto significa que, si se borra el disco de origen, las instantáneas generadas de manera automática para ese disco se conservarán por tiempo indefinido. Como alternativa, puedes establecer la marca en applyRetentionPolicy para aplicar la política de retención.

En el siguiente ejemplo, se establece una programación diaria de instantáneas que comienza a las 12:00 p.m. UTC y se repite todos los días. En el ejemplo, también se establece una política de retención de 5 días. Después de 5 días, las instantáneas se quitan de forma automática.

También puedes incluir opciones de localidad de instantáneas y etiquetas de instantáneas en tu solicitud para garantizar que tus instantáneas se almacenen 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 instantáneas.
[SCHEDULE_DESCRIPTION] es la descripción de la programación de instantáneas.
[SCHEDULE_NAME] es el nombre de la programación de instantáneas.

Del mismo modo, puedes crear una programación semanal o mensual. Revisa la referencia de la API para obtener detalles específicos sobre cómo establecer una programación semanal o mensual.

Por ejemplo, con la siguiente solicitud, se crea una programación semanal que se ejecuta los martes y jueves, a las 9:00 y 2: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"]
  }
 }
}

Adjunta una programación de instantáneas a un disco

Permisos necesarios para 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 se debe usar

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

Console

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

En la consola de Google Cloud, ve a la página Discos.
Ir a la página Discos
Elige el nombre del disco al que deseas conectar una programación de instantáneas. Se abrirá la página Administrar disco.
En la página Administrar disco, posiciona el cursor y haz clic en el menú Más acciones y selecciona Editar.
Usa el menú desplegable Programación de instantáneas para agregar la programación al disco. Sino, crea una programación nueva.
Si creaste una programación nueva, haz clic en Crear.
Haz clic en Guardar para completar la tarea.

gcloud

Si quieres conectar una programación de instantáneas a un disco, usa el comando disks add-resource-policies de gcloud.

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

Donde:

[DISK_NAME] es el nombre del disco existente.
[SCHEDULE_NAME] es el nombre de la programación de instantáneas.
[ZONE] es la ubicación de tu disco.

API

En la API, debes crear una solicitud POST para disks.addResourcePolicies a fin de conectar una programación de instantáneas a un disco existente.

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 instantáneas.
[DISK_NAME] es el nombre del disco.
[SCHEDULE_NAME] es el nombre de la programación de instantáneas en esa región en la que aplicas a este disco.

Restablece datos a partir de una instantánea

Si creaste una copia de seguridad de un disco de arranque o que no es de arranque con una instantánea, puedes crear un disco nuevo basado en la instantánea.

Restricciones

El disco nuevo debe tener, como mínimo, el mismo tamaño que el disco de origen original de la instantánea. Si creas un disco que es más grande que el disco de origen original de la instantánea, debes cambiar el tamaño del sistema de archivos en ese disco persistente para incluir el espacio de disco adicional. Según el sistema operativo y el tipo de sistema de archivos, es posible que debas usar otra herramienta de cambio de tamaño para el sistema de archivos. Para obtener más información, consulta la documentación de tu sistema operativo.

Crea un disco a partir de una instantánea y conéctalo a una VM

Permisos necesarios para esta tarea

Para realizar esta tarea, debes tener los siguientes permisos:

compute.disks.create en el proyecto para crear un disco nuevo
compute.instances.attachDisk en la instancia de VM
permiso compute.disks.use en el disco que se conectará

Console

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

Ir a instantáneas
Busca el nombre de la instantánea que deseas restablecer.
Ir a la página Discos

Ir a la página Discos
Haz clic en Crear disco nuevo.
Especifica los siguientes parámetros de configuración:
- Un nombre para el disco
- Un tipo para el disco
- De manera opcional, puedes anular la selección de región y zona predeterminadas. Puedes seleccionar cualquier región y zona, independientemente de la ubicación de almacenamiento de la instantánea de origen.
En Tipo de fuente, haz clic en Instantánea.
Selecciona el nombre de la instantánea que deseas restablecer.
Selecciona el tamaño del disco nuevo, en gigabytes. Este número debe ser igual o mayor que el disco de origen para la instantánea.
Haz clic en Crear para crear el disco.

Puedes conectar el disco nuevo a una instancia existente.

Ve a la página Instancias de VM.
Ir a la página Instancias de VM
Haz clic en el nombre de la instancia en la que deseas restablecer el disco que no sea de arranque.
En la parte superior de esta página, haz clic en Editar.
En Discos adicionales, haz clic en Adjuntar disco existente.
Selecciona el nombre del disco nuevo creado a partir de la instantánea.
Haz clic en Listo para conectar el disco.
En la parte inferior de la página de detalles de la instancia, haz clic en Guardar para aplicar los cambios en la instancia.

gcloud

Usa el comando gcloud compute snapshots list para encontrar el nombre de la instantánea que deseas restablecer:
```
gcloud compute snapshots list
```
Usa el comando gcloud compute snapshots describe para encontrar el tamaño de la instantánea que deseas restablecer:
```
gcloud compute snapshots describe SNAPSHOT_NAME
```
Reemplaza SNAPSHOT_NAME por el nombre de la instantánea que se restablecerá.
Usa el comando gcloud compute disks create para crear un nuevo disco regional ozonal desde tu instantánea. Si necesitas un disco persistente SSD para obtener capacidad de procesamiento o IOPS adicionales, incluye la marca --type y especifica pd-ssd.
```
gcloud compute disks create DISK_NAME \
    --size=DISK_SIZE \
    --source-snapshot=SNAPSHOT_NAME \
    --type=DISK_TYPE
```
Reemplaza lo siguiente:
- DISK_NAME: Es el nombre del disco nuevo.
- DISK_SIZE: Es el tamaño del disco nuevo en GB. Este número debe ser igual o mayor que el disco de origen para la instantánea.
- SNAPSHOT_NAME: Es el nombre de la instantánea que se restablecerá.
- DISK_TYPE: Es la URL parcial o completa para el tipo de disco. Por ejemplo, https://www.googleapis.com/compute/v1/projects/PROJECT_ID /zones/ZONE/diskTypes/pd-ssd.
Conecta el disco nuevo a una instancia existente con el comando gcloud compute instances attach-disk:
```
gcloud compute instances attach-disk INSTANCE_NAME \
    --disk DISK_NAME
```
Reemplaza lo siguiente:
- INSTANCE_NAME es el nombre de la instancia.
- DISK_NAME es el nombre del disco creado a partir de la instantánea.

API

Crea una solicitud GET a snapshots.list para ver la lista de instantáneas de tu proyecto.

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

Reemplaza PROJECT_ID con el ID del proyecto.
Crea una solicitud POST para crear un disco zonal mediante el método disks.insert. Incluye las propiedades name, sizeGb y type. Para restablecer un disco con 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"
}
```
Reemplaza lo siguiente:
- PROJECT_ID: el ID de tu proyecto
- ZONE: Es la zona en la que se encuentran la instancia y el disco nuevo.
- DISK_NAME: Es el nombre del disco nuevo.
- DISK_SIZE: Es el tamaño del disco nuevo en gigabytes. Este número debe ser igual o mayor que el disco de origen para la instantánea.
- DISK_TYPE: Es la URL parcial o completa para el tipo de disco. Por ejemplo https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ ZONE/diskTypes/pd-ssd.
- SNAPSHOT_NAME es la instantánea de origen del disco que se restablecerá.
Puedes conectar el disco nuevo a una instancia existente si construyes una solicitud POST al método instances.attachDisk e incluyes la URL al disco zonal que acabas de crear a partir de tu instantánea.
```
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"
}
```
Reemplaza lo siguiente:
- PROJECT_ID es el ID del proyecto.
- ZONE es la zona en la que se encuentran tu instancia y el disco nuevo.
- INSTANCE_NAME es el nombre de la instancia a la que agregas el disco nuevo.
- DISK_NAME es el nombre del disco nuevo.

Go

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

Para autenticarte en Vertex AI, 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"
)

// 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 instrucciones de configuración para Java incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Java.


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 instrucciones de configuración para Node.js incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Node.js.

/**
 * 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

SDK de Vertex AI para Python

Si deseas obtener información para instalar o actualizar el SDK de Vertex AI para Python, consulta Instala el SDK de Vertex AI para Python. Si deseas obtener más información, consulta la documentación del SDK de Vertex AI de referencia de la API de Vertex para 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)

Activa el disco

En la terminal, usa el comando lsblk para ver una lista de los discos que están conectados a tu instancia y buscar el disco que quieres activar.
```
$ 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 para el nuevo disco persistente en blanco.
Usa la herramienta de activación para activar el disco en la instancia y habilita la opción discard:
```
$ sudo mount -o discard,defaults /dev/DEVICE_NAME /home/jupyter
```
Reemplaza lo siguiente:
- DEVICE_NAME: Es el nombre del dispositivo del disco que se activará.
Configura los permisos de lectura y escritura en el disco. En este ejemplo, se debe otorgar acceso de escritura al disco para todos los usuarios.
```
$ sudo chmod a+w /home/jupyter
```

¿Qué sigue?

Obtén información para guardar un notebook en GitHub.
Más información sobre cómo crear instantáneas.
Más información sobre cómo programar instantáneas.