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

Consola

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

   Ir a Instancias de VM
   school Los pasos restantes aparecerán automáticamente en la consola de Google Cloud.

2. Selecciona el proyecto que contiene las instancias de VM.
3. En la columna Nombre, haz clic en el nombre de la VM que tiene el disco persistente para crear la copia de seguridad.
4. 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 persistente conectado, en Discos adicionales, haz clic en el Nombre del disco persistente conectado.
5. Haz clic en Crear instantánea.
6. En Nombre, ingresa un nombre único que ayude a identificar el propósito de la instantánea, por ejemplo:
   • boot-disk-snapshot
   • attached-persistent-disk-snapshot
7. En Tipo, el valor predeterminado es una instantánea normal, que es la mejor opción para las copias de seguridad a largo plazo y la recuperación ante desastres.

   Elige Instantánea de archivo para lograr una retención de datos más rentable.

8. 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, selecciona En función de la ubicación del disco.

9. Para crear una instantánea manual, haz clic en Crear.

gcloud

1. En la consola de Google Cloud, activa Cloud Shell.

   Activar Cloud Shell

   En la parte inferior de la consola de Google Cloud, se inicia una sesión de Cloud Shell en la que se muestra una ventana de línea de comandos. Cloud Shell es un entorno de shell con Google Cloud CLI ya instalada y con valores ya establecidos para el proyecto actual. La sesión puede tardar unos segundos en inicializarse.

2. 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.

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 http://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 http://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

import (
	"context"
	"fmt"
	"io"

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

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

	ctx := context.Background()

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

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

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

	if diskProjectID == "" {
		diskProjectID = projectID
	}

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

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

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

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

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

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

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

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

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

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

	return nil
}

Java

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

public class CreateSnapshot {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    }
  }
}

Node.js

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

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

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

  let disk;

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

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

  if (!diskProjectId) {
    diskProjectId = projectId;
  }

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

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

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

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

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

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

createSnapshot();

Python

from __future__ import annotations

import sys
from typing import Any

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

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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result

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

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

    Args:
        project_id: project ID or project number of the Cloud project you want
            to use to store the snapshot.
        disk_name: name of the disk you want to snapshot.
        snapshot_name: name of the snapshot to be created.
        zone: name of the zone in which is the disk you want to snapshot (for zonal disks).
        region: name of the region in which is the disk you want to snapshot (for regional disks).
        location: The Cloud Storage multi-region or the Cloud Storage region where you
            want to store your snapshot.
            You can specify only one storage location. Available locations:
            http://cloud.go888ogle.com.fqhub.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)

Consola

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

   Ir a Instancias de VM
   school Los pasos restantes aparecerán automáticamente en la consola de Google Cloud.

2. Elige el proyecto que contiene las instancias de VM.
3. 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.
4. En Almacenamiento, haz clic en el nombre del Disco de arranque o el Disco adicional para crear una programación de instantáneas.
5. Haz clic en editEditar. Es posible que debas hacer clic en el menú more_vert Más acciones y, luego, en editEditar.
6. En Programación de instantáneas, elige Crear una programación.
7. En Nombre, ingresa uno de los siguientes nombres para la programación de instantáneas:
   • boot-disk-snapshot-schedule
   • attached-persistent-disk-snapshot-schedule

8. 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.

9. Para terminar de crear la programación de instantáneas, haz clic en Crear.
10. 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]

En el ejemplo anterior, se usa lo siguiente:

• [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.

• [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 http://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"]
   }
 }
}

En el ejemplo anterior, se ilustra lo siguiente:

• [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 http://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"]
  }
 }
}

Console

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

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

   Ir a la página Discos

2. Elige el nombre del disco al que deseas conectar una programación de instantáneas. Se abrirá la página Administrar disco.
3. En la página Administrar disco, posiciona el cursor y haz clic en el menú more_vertMás acciones y seleccionaedit Editar.
4. Usa el menú desplegable Programación de instantáneas para agregar la programación al disco. Sino, crea una programación nueva.
5. Si creaste una programación nueva, haz clic en Crear.
6. 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]

En el ejemplo anterior, se ilustra lo siguiente:

• [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 http://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/[ZONE]/disks/[DISK_NAME]/addResourcePolicies

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

En el ejemplo anterior, se ilustra lo siguiente:

• [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.

Consola

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

   Ir a instantáneas

2. Busca el nombre de la instantánea que deseas restablecer.

3. Ir a la página Discos

   Ir a la página Discos

4. Haz clic en Crear disco nuevo.

5. 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.

6. En Tipo de fuente, haz clic en Instantánea.

7. Selecciona el nombre de la instantánea que deseas restablecer.

8. 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.

9. Haz clic en Crear para crear el disco.

Puedes conectar el disco nuevo a una instancia existente.

1. Ve a la página Instancias de VM.

   Ir a la página Instancias de VM

2. Haz clic en el nombre de la instancia en la que deseas restablecer el disco que no sea de arranque.
3. En la parte superior de esta página, haz clic en Editar.
4. En Discos adicionales, haz clic en Adjuntar disco existente.
5. Selecciona el nombre del disco nuevo creado a partir de la instantánea.
6. Haz clic en Listo para conectar el disco.
7. 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

1. Usa el comando gcloud compute snapshots list para encontrar el nombre de la instantánea que deseas restablecer:

   gcloud compute snapshots list
   

2. 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á.

3. 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, http://www.googleapis.com/compute/v1/projects/PROJECT_ID /zones/ZONE/diskTypes/pd-ssd.

4. 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

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

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

   Reemplaza PROJECT_ID con el ID del proyecto.

2. 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 http://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 http://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á.

3. 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 http://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

import (
	"context"
	"fmt"
	"io"

	compute "cloud.go888ogle.com.fqhub.com/go/compute/apiv1"
	computepb "cloud.go888ogle.com.fqhub.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

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

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

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)