Administra programaciones de instantáneas para discos

En este documento, se describe cómo administrar las programaciones de instantáneas para tu Persistent Disk zonal y regional y Google Cloud Hyperdisk.

Puedes administrar las programaciones de instantáneas de la siguiente manera:

  • Visualiza programaciones de instantáneas
  • Cambia programaciones de instantáneas
  • Borrar programaciones de instantáneas

También puedes configurar alertas para las instantáneas programadas.

Antes de comenzar

  • Si aún no lo hiciste, configura la autenticación. La autenticación es el proceso mediante el cual se verifica tu identidad para acceder a los servicios y las APIs de Google Cloud . Para ejecutar código o muestras desde un entorno de desarrollo local, puedes autenticarte en Compute Engine seleccionando una de las siguientes opciones:

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

    Console

    When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

    gcloud

    1. Install the Google Cloud CLI, then initialize it by running the following command: 

      gcloud init
    2. Set a default region and zone.

      3. Go

      Para usar las muestras de Go de esta página en un entorno de desarrollo local, instala e inicializa gcloud CLI y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

      1. Install the Google Cloud CLI.

      2. To initialize the gcloud CLI, run the following command: 

        gcloud init

      3. If you're using a local shell, then create local authentication credentials for your user account: 

        gcloud auth application-default login

        You don't need to do this if you're using Cloud Shell.

      Para obtener más información, consulta Set up authentication for a local development environment.

      Java

      Para usar las muestras de Java de esta página en un entorno de desarrollo local, instala e inicializa gcloud CLI y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

      1. Install the Google Cloud CLI.

      2. To initialize the gcloud CLI, run the following command: 

        gcloud init

      3. If you're using a local shell, then create local authentication credentials for your user account: 

        gcloud auth application-default login

        You don't need to do this if you're using Cloud Shell.

      Para obtener más información, consulta Set up authentication for a local development environment.

      Node.js

      Para usar las muestras de Node.js de esta página en un entorno de desarrollo local, instala e inicializa gcloud CLI y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

      1. Install the Google Cloud CLI.

      2. To initialize the gcloud CLI, run the following command: 

        gcloud init

      3. If you're using a local shell, then create local authentication credentials for your user account: 

        gcloud auth application-default login

        You don't need to do this if you're using Cloud Shell.

      Para obtener más información, consulta Set up authentication for a local development environment.

      Python

      Para usar las muestras de Python de esta página en un entorno de desarrollo local, instala e inicializa gcloud CLI y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

      1. Install the Google Cloud CLI.

      2. To initialize the gcloud CLI, run the following command: 

        gcloud init

      3. If you're using a local shell, then create local authentication credentials for your user account: 

        gcloud auth application-default login

        You don't need to do this if you're using Cloud Shell.

      Para obtener más información, consulta Set up authentication for a local development environment.

      REST

      Para usar las muestras de la API de REST en esta página en un entorno de desarrollo local, debes usar las credenciales que proporcionas a la CLI de gcloud.

        Install the Google Cloud CLI, then initialize it by running the following command: 

        gcloud init

      Para obtener más información, consulta Autentica para usar REST en la documentación de autenticación de Google Cloud .

Roles y permisos requeridos

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

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

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

Permisos necesarios

Se requieren los siguientes permisos para crear una programación de instantáneas:

  • Para ver programaciones de instantáneas: compute.resourcePolicies.list en el proyecto o la organización
  • Para actualizar una programación de instantáneas, haz lo siguiente:
    • compute.resourcePolicies.update en la política de recursos
    • compute.resourcePolicies.get en la política de recursos
  • Para reemplazar una programación de instantáneas, sigue estos pasos:
    • compute.resourcePolicies.use en la política de recursos
    • compute.disks.addResourcePolicies en el disco
    • compute.disks.removeResourcePolicies en el disco
  • Para borrar una programación de instantáneas, haz lo siguiente:
    • compute.resourcePolicies.delete en la política de recursos
    • compute.disks.removeResourcePolicies en el disco

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

Visualiza programaciones de instantáneas

Si quieres obtener una lista de programación de instantáneas, usa la consola, el comando de gcloud o el método API de Compute Engine. Con esta solicitud, se muestran el nombre, la descripción y la región de todas las programaciones de instantáneas dentro de un proyecto.

Console

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

    Ir a la página de instantáneas

  2. Selecciona la pestaña Programación de instantáneas.
  3. Usa el campo Filtro para reducir la lista de programaciones de instantáneas.
  4. Haz clic en el nombre de una programación de instantáneas para ver sus detalles.

gcloud

Si quieres ver una lista de las programaciones de instantáneas, usa el comando resource-policies list.

 gcloud compute resource-policies list

Si quieres ver la descripción de una programación de instantáneas específica, usa el comando resource-policies describe.

gcloud compute resource-policies describe SCHEDULE_NAME

Reemplaza SCHEDULE_NAME por el nombre de la programación de instantáneas.

Go

Enumera las programaciones de instantáneas

import (
	"context"
	"fmt"
	"io"

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

// listSnapshotSchedule retrieves a list of snapshot schedules.
func listSnapshotSchedule(w io.Writer, projectID, region, filter string) error {
	// projectID := "your_project_id"
	// snapshotName := "your_snapshot_name"
	// region := "eupore-central2"

	// Formatting for filters:
	// https://cloud.google.com/python/docs/reference/compute/latest/google.cloud.compute_v1.types.ListResourcePoliciesRequest

	ctx := context.Background()

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

	req := &computepb.ListResourcePoliciesRequest{
		Project: projectID,
		Region:  region,
		Filter:  proto.String(filter),
	}
	it := snapshotsClient.List(ctx, req)

	for {
		policy, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "- %s", policy.GetName())
	}
	return nil
}

Describe una programación de instantáneas

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
)

// getSnapshotSchedule gets a snapshot schedule.
func getSnapshotSchedule(w io.Writer, projectID, scheduleName, region string) error {
	// projectID := "your_project_id"
	// snapshotName := "your_snapshot_name"
	// region := "eupore-central2"

	ctx := context.Background()

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

	req := &computepb.GetResourcePolicyRequest{
		Project:        projectID,
		Region:         region,
		ResourcePolicy: scheduleName,
	}
	schedule, err := snapshotsClient.Get(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to get snapshot schedule: %w", err)
	}

	fmt.Fprintf(w, "Found snapshot schedule: %s\n", schedule.GetName())

	return nil
}

Java

Enumera las programaciones de instantáneas

import com.google.cloud.compute.v1.ListResourcePoliciesRequest;
import com.google.cloud.compute.v1.ResourcePoliciesClient;
import com.google.cloud.compute.v1.ResourcePoliciesClient.ListPagedResponse;
import com.google.cloud.compute.v1.ResourcePolicy;
import java.io.IOException;

public class ListSnapshotSchedules {

  public static void main(String[] args) throws IOException {
    // 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 region you want to list snapshot schedules from.
    String region = "us-central1";
    // Name of the snapshot schedule you want to list.
    String snapshotScheduleName = "YOUR_SCHEDULE_NAME";

    listSnapshotSchedules(projectId, region, snapshotScheduleName);
  }

  // Lists snapshot schedules in a specified region, optionally filtered.
  public static ListPagedResponse listSnapshotSchedules(
          String projectId, String region, String snapshotScheduleName) throws IOException {
    String filter = String.format("name = %s", snapshotScheduleName);
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (ResourcePoliciesClient resourcePoliciesClient = ResourcePoliciesClient.create()) {

      ListResourcePoliciesRequest request = ListResourcePoliciesRequest.newBuilder()
              .setProject(projectId)
              .setRegion(region)
              .setFilter(filter)
              .build();
      ListPagedResponse response = resourcePoliciesClient.list(request);
      for (ResourcePolicy resourcePolicy : response.iterateAll()) {
        System.out.println(resourcePolicy);
      }
      return response;
    }
  }
}

Describe una programación de instantáneas

import com.google.cloud.compute.v1.GetResourcePolicyRequest;
import com.google.cloud.compute.v1.ResourcePoliciesClient;
import com.google.cloud.compute.v1.ResourcePolicy;
import java.io.IOException;

public class GetSnapshotSchedule {

  public static void main(String[] args) throws IOException {
    // 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 region in which your snapshot schedule is located.
    String region = "us-central1";
    // Name of your snapshot schedule.
    String snapshotScheduleName = "YOUR_SCHEDULE_NAME";

    getSnapshotSchedule(projectId, region, snapshotScheduleName);
  }

  // Retrieves the details of a snapshot schedule.
  public static ResourcePolicy getSnapshotSchedule(
        String projectId, String region, String snapshotScheduleName) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (ResourcePoliciesClient resourcePoliciesClient = ResourcePoliciesClient.create()) {
      GetResourcePolicyRequest request = GetResourcePolicyRequest.newBuilder()
              .setProject(projectId)
              .setRegion(region)
              .setResourcePolicy(snapshotScheduleName)
              .build();
      ResourcePolicy resourcePolicy = resourcePoliciesClient.get(request);
      System.out.println(resourcePolicy);

      return resourcePolicy;
    }
  }
}

Node.js 

// Import the Compute library
const computeLib = require('@google-cloud/compute');

// Instantiate a resourcePoliciesClient
const resourcePoliciesClient = new computeLib.ResourcePoliciesClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The project name.
const projectId = await resourcePoliciesClient.getProjectId();

// The location of the snapshot schedule resource policy.
// region = 'us-central1';

// The name of the snapshot schedule.
// snapshotScheduleName = 'snapshot-schedule-name';

async function callGetSnapshotSchedule() {
  const [response] = await resourcePoliciesClient.get({
    project: projectId,
    region,
    resourcePolicy: snapshotScheduleName,
  });

  console.log(JSON.stringify(response));
}

await callGetSnapshotSchedule();

Python

Enumera las programaciones de instantáneas

from google.cloud import compute_v1
from google.cloud.compute_v1.services.resource_policies import pagers


def snapshot_schedule_list(project_id: str, region: str) -> pagers.ListPager:
    """
    Lists snapshot schedules for a specified project and region.
    Args:
        project_id (str): The ID of the Google Cloud project.
        region (str): The region where the snapshot schedules are located.
    Returns:
        ListPager: A pager for iterating through the list of snapshot schedules.
    """
    client = compute_v1.ResourcePoliciesClient()

    request = compute_v1.ListResourcePoliciesRequest(
        project=project_id,
        region=region,
        filter='status = "READY"',  # Optional filter
    )

    schedules = client.list(request=request)
    return schedules

Describe una programación de instantáneas

from google.cloud import compute_v1


def snapshot_schedule_get(
    project_id: str, region: str, snapshot_schedule_name: str
) -> compute_v1.ResourcePolicy:
    """
    Retrieves a snapshot schedule for a specified project and region.
    Args:
        project_id (str): The ID of the Google Cloud project.
        region (str): The region where the snapshot schedule is located.
        snapshot_schedule_name (str): The name of the snapshot schedule.
    Returns:
        compute_v1.ResourcePolicy: The retrieved snapshot schedule.
    """
    client = compute_v1.ResourcePoliciesClient()
    schedule = client.get(
        project=project_id, region=region, resource_policy=snapshot_schedule_name
    )
    return schedule

REST

Realiza una solicitud GET a resourcePolicies.aggregatedList para mostrar una lista de las programaciones de instantáneas en un proyecto.

GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/aggregated/resourcePolicies

Reemplaza PROJECT_ID por el nombre del proyecto.

Visualiza programaciones de instantáneas por región

Para ver las programaciones de instantáneas de un proyecto dentro de una región en particular, usa la consola de Google Cloud, gcloud CLI o REST.

Console

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

    Ir a la página de instantáneas

  2. Selecciona la pestaña Programación de instantáneas.
  3. Usa el campo Filtro para enumerar las programaciones de instantáneas de una región específica.

gcloud

Si quieres ver las programaciones de instantáneas de un proyecto dentro de una región específica, usa el comando resource-policies list.

gcloud compute resource-policies list PROJECT_ID --filter REGION

Reemplaza lo siguiente:

  • PROJECT_ID: nombre del proyecto
  • REGION: la región, por ejemplo, us-west1

REST

Realiza una solicitud GET al método resourcePolicies.list para recuperar las programaciones de instantáneas creadas dentro de una región.

GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/resourcePolicies

Reemplaza lo siguiente:

  • PROJECT_ID: nombre del proyecto
  • REGION: la región, por ejemplo, us-west1

Cambia una programación de instantáneas

Después de crear una programación de instantáneas, puedes modificar los siguientes campos de forma dinámica a través del procedimiento Actualiza una programación de instantáneas:

  • Descripción
  • Programación de instantáneas
  • Etiquetas aplicadas a las instantáneas generadas
  • Política de eliminación 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

Si deseas actualizar otros valores para una programación de instantáneas, debes borrar la programación de instantáneas y crear una nueva, como se describe en Reemplaza una programación de instantáneas.

Las actualizaciones de programación de instantáneas entrarán en vigor en la primera instantánea después de las actualizaciones. Si se ejecuta una instantánea mientras actualizas la programación de instantáneas, los cambios se aplicarán en la siguiente instantánea.

Actualizar una programación de instantáneas

Puedes usar Google Cloud CLI o la API de Compute Engine para cambiar algunas de las propiedades de tu programación de instantáneas, como se describe en Cambia una programación de instantáneas.

Si deseas cambiar otras propiedades de tu programación de instantáneas, usa el método descrito en Reemplaza una programación de instantáneas.

Console

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

    Ir a la página de instantáneas

  2. Elige Programación de instantáneas para ver una lista de tus programaciones.
  3. Haz clic en el nombre de la programación de instantáneas que deseas modificar.
  4. En la página de detalles de la programación de instantáneas, haz clic en el botón Editar programación.

gcloud

Usa el comando compute resource-policies update para actualizar la descripción, la programación, una política de retención o las etiquetas de una programación de instantáneas.

gcloud compute resource-policies update snapshot-schedule SCHEDULE_NAME \
   --region=REGION \
   --description="DESCRIPTION" \
   --snapshot-labels="KEY=VALUE" \
   --max-retention-days=DAYS \
   --on-source-disk-delete=DELETE_OPTION \
   --start-time=START_TIME \
   SCHEDULE_FLAG

Reemplaza lo siguiente:

  • SCHEDULE_NAME: el nombre de la programación de instantáneas.
  • REGION: la región en la que reside tu programación de instantáneas.
  • DESCRIPTION: una descripción de la programación de instantáneas. Coloca la descripción entre comillas.
  • KEY y VALUE: un par clave-valor que se puede usar para agrupar recursos relacionados o asociados.
  • DAYS: la cantidad máxima de días de instantánea se conserva antes de que se borre.
  • DELETE_OPTION: Comportamiento de retención de instantáneas automáticas después de que se borra el disco original. El valor debe ser uno de los siguientes:
    • apply-retention-policy: Cuando se borre el disco de origen, continúa aplicando la ventana de retención para cualquier instantánea creada por la programación de instantáneas.
    • keep-auto-snapshots: (Predeterminado) Si se borra el disco de origen, conserva las instantáneas creadas por la programación de instantáneas, sin importar el período de retención.
  • START_TIME: 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.

  • SCHEDULE_FLAG: una de las marcas siguientes:

    • --hourly-schedule=HOURLY_INTERVAL: la cantidad de horas entre cada instantánea. HOURLY_INTERVAL debe ser un número entero entre 1 y 23. Por ejemplo, si estableces --hourly-schedule en 12, la instantánea se generará cada 12 horas.
    • --daily-schedule: hace una instantánea al día, en el START_TIME

    • --weekly-schedule=WEEKLY_INTERVAL: define el día en el que deseas que ocurra la instantánea. Debes escribir el día de la semana. Los valores no distinguen mayúsculas de minúsculas.

    • --weekly-schedule-from-file=FILE_NAME: especifica un archivo que contiene la programación de instantáneas semanal. Puedes especificar programaciones semanales en diferentes días de la semana y diferentes horas con un archivo. Por ejemplo, tu archivo podría especificar una programación de instantáneas el lunes y el miércoles: none [{"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. 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.

    Las marcas de frecuencia de la instantánea hourly-schedule, daily-schedule, weekly-schedule y weekly-schedule-from-file son excluyentes entre sí. Solo puedes usar una para tu programación de instantáneas.

Ejemplos:

Para cambiar una programación de instantáneas a una programación diaria, sigue estos pasos:

gcloud compute resource-policies update snapshot-schedule SCHEDULE_NAME \
    --region=REGION --daily-schedule --start-time=START_TIME

Para cambiar una instantánea a una programación por hora y, también, actualizar la descripción y la etiqueta de la instantánea, haz lo siguiente:

gcloud compute resource-policies update snapshot-schedule SCHEDULE_NAME \
    --region=REGION --description="DESCRIPTION" \
    --hourly-schedule=HOURLY_INTERVAL --start-time=START_TIME \
    --snapshot-labels="KEY=VALUE"

Si deseas cambiar las políticas de retención de instantáneas y eliminación de discos de origen para una programación de instantáneas, haz lo siguiente:

gcloud compute resource-policies update snapshot-schedule SCHEDULE_NAME \
    --region=REGION --max-retention-days=DAYS \
    --on-source-disk-delete=DELETE_OPTION

Go

import (
	"context"
	"fmt"
	"io"

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

// editSnapshotSchedule edits a snapshot schedule.
func editSnapshotSchedule(w io.Writer, projectID, scheduleName, region string) error {
	// projectID := "your_project_id"
	// snapshotName := "your_snapshot_name"
	// region := "eupore-central2"

	ctx := context.Background()

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

	req := &computepb.PatchResourcePolicyRequest{
		Project:        projectID,
		Region:         region,
		ResourcePolicy: scheduleName,
		ResourcePolicyResource: &computepb.ResourcePolicy{
			Name:        proto.String(scheduleName),
			Description: proto.String("MY HOURLY SNAPSHOT SCHEDULE"),
			SnapshotSchedulePolicy: &computepb.ResourcePolicySnapshotSchedulePolicy{
				Schedule: &computepb.ResourcePolicySnapshotSchedulePolicySchedule{
					HourlySchedule: &computepb.ResourcePolicyHourlyCycle{
						HoursInCycle: proto.Int32(12),
						StartTime:    proto.String("22:00"),
					},
				},
			},
		},
	}
	op, err := snapshotsClient.Patch(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create snapshot schedule: %w", err)
	}

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

	fmt.Fprint(w, "Snapshot schedule changed\n")

	return nil
}

Java 

import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.PatchResourcePolicyRequest;
import com.google.cloud.compute.v1.ResourcePoliciesClient;
import com.google.cloud.compute.v1.ResourcePolicy;
import com.google.cloud.compute.v1.ResourcePolicySnapshotSchedulePolicy;
import com.google.cloud.compute.v1.ResourcePolicySnapshotSchedulePolicyRetentionPolicy;
import com.google.cloud.compute.v1.ResourcePolicySnapshotSchedulePolicyRetentionPolicy.OnSourceDiskDelete;
import com.google.cloud.compute.v1.ResourcePolicySnapshotSchedulePolicySchedule;
import com.google.cloud.compute.v1.ResourcePolicySnapshotSchedulePolicySnapshotProperties;
import com.google.cloud.compute.v1.ResourcePolicyWeeklyCycle;
import com.google.cloud.compute.v1.ResourcePolicyWeeklyCycleDayOfWeek;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class EditSnapshotSchedule {

  public static void main(String[] args) throws Exception {
    // 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 region where your snapshot schedule is located.
    String region = "us-central1";
    // Name of the snapshot schedule you want to update.
    String snapshotScheduleName = "YOUR_SCHEDULE_NAME";

    editSnapshotSchedule(projectId, region, snapshotScheduleName);
  }

  // Edits a snapshot schedule.
  public static Status editSnapshotSchedule(
          String projectId, String region, String snapshotScheduleName)
          throws IOException, InterruptedException, ExecutionException, 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.
    try (ResourcePoliciesClient resourcePoliciesClient = ResourcePoliciesClient.create()) {
      Map<String, String> snapshotLabels = new HashMap<>();
      snapshotLabels.put("key", "value");

      ResourcePolicySnapshotSchedulePolicySnapshotProperties.Builder snapshotProperties =
              ResourcePolicySnapshotSchedulePolicySnapshotProperties.newBuilder();
      snapshotProperties.putAllLabels(snapshotLabels);

      ResourcePolicyWeeklyCycleDayOfWeek dayOfWeek = ResourcePolicyWeeklyCycleDayOfWeek.newBuilder()
              .setDay("Tuesday")
              .setStartTime("09:00")
              .build();
      ResourcePolicyWeeklyCycle weeklySchedule = ResourcePolicyWeeklyCycle.newBuilder()
              .addDayOfWeeks(dayOfWeek)
              .build();

      int maxRetentionDays = 3;

      ResourcePolicySnapshotSchedulePolicyRetentionPolicy.Builder retentionPolicy =
              ResourcePolicySnapshotSchedulePolicyRetentionPolicy.newBuilder();
      retentionPolicy.setOnSourceDiskDelete(OnSourceDiskDelete.APPLY_RETENTION_POLICY.toString());
      retentionPolicy.setMaxRetentionDays(maxRetentionDays);

      String description = "Updated description";

      ResourcePolicy updatedSchedule = ResourcePolicy.newBuilder()
              .setName(snapshotScheduleName)
              .setDescription(description)
              .setSnapshotSchedulePolicy(
                      ResourcePolicySnapshotSchedulePolicy.newBuilder()
                              .setSchedule(ResourcePolicySnapshotSchedulePolicySchedule.newBuilder()
                                      .setWeeklySchedule(weeklySchedule))
                              .setSnapshotProperties(snapshotProperties)
                              .setRetentionPolicy(retentionPolicy.build())
                              .build())
              .build();

      PatchResourcePolicyRequest request = PatchResourcePolicyRequest.newBuilder()
              .setProject(projectId)
              .setRegion(region)
              .setResourcePolicy(snapshotScheduleName)
              .setResourcePolicyResource(updatedSchedule)
              .build();

      Operation response = resourcePoliciesClient.patchAsync(request).get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        throw new Error("Failed to update snapshot schedule! " + response.getError());
      }
      return response.getStatus();
    }
  }
}

Node.js 

// Import the Compute library
const computeLib = require('@google-cloud/compute');
const compute = computeLib.protos.google.cloud.compute.v1;

// Instantiate a resourcePoliciesClient
const resourcePoliciesClient = new computeLib.ResourcePoliciesClient();
// Instantiate a regionOperationsClient
const regionOperationsClient = new computeLib.RegionOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The project name.
const projectId = await resourcePoliciesClient.getProjectId();

// The location of the snapshot schedule resource policy.
// region = 'us-central1';

// The name of the snapshot schedule.
// snapshotScheduleName = 'snapshot-schedule-name';

async function callEditSnapshotSchedule() {
  const [response] = await resourcePoliciesClient.patch({
    project: projectId,
    region,
    resourcePolicy: snapshotScheduleName,
    resourcePolicyResource: compute.ResourcePolicy({
      snapshotSchedulePolicy:
        compute.ResourcePolicyInstanceSchedulePolicySchedule({
          schedule: compute.ResourcePolicySnapshotSchedulePolicySchedule({
            weeklySchedule: compute.ResourcePolicyWeeklyCycle({
              dayOfWeeks: [
                compute.ResourcePolicyWeeklyCycleDayOfWeek({
                  day: 'Tuesday',
                  startTime: '9:00',
                }),
              ],
            }),
          }),
        }),
    }),
  });

  let operation = response.latestResponse;

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

  console.log(`Snapshot schedule: ${snapshotScheduleName} edited.`);
}

await callEditSnapshotSchedule();

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 snapshot_schedule_update(
    project_id: str,
    region: str,
    schedule_name: str,
    schedule_description: str,
    labels: dict,
) -> compute_v1.ResourcePolicy:
    """
    Updates a snapshot schedule for a specified project and region.
    Args:
        project_id (str): The ID of the Google Cloud project.
        region (str): The region where the snapshot schedule is located.
        schedule_name (str): The name of the snapshot schedule to update.
        schedule_description (str): The new description for the snapshot schedule.
        labels (dict): A dictionary of new labels to apply to the snapshot schedule.
    Returns:
        compute_v1.ResourcePolicy: The updated snapshot schedule.
    """

    # Every Monday, starts between 12:00 AM and 1:00 AM
    day = compute_v1.ResourcePolicyWeeklyCycleDayOfWeek(
        day="MONDAY", start_time="00:00"
    )
    weekly_schedule = compute_v1.ResourcePolicyWeeklyCycle(day_of_weeks=[day])

    schedule = compute_v1.ResourcePolicySnapshotSchedulePolicySchedule()
    # You can change the schedule type to daily_schedule, weekly_schedule, or hourly_schedule
    schedule.weekly_schedule = weekly_schedule

    # Autodelete snapshots after 10 days
    retention_policy = compute_v1.ResourcePolicySnapshotSchedulePolicyRetentionPolicy(
        max_retention_days=10
    )
    snapshot_properties = (
        compute_v1.ResourcePolicySnapshotSchedulePolicySnapshotProperties(
            guest_flush=False, labels=labels
        )
    )

    snapshot_policy = compute_v1.ResourcePolicySnapshotSchedulePolicy()
    snapshot_policy.schedule = schedule
    snapshot_policy.retention_policy = retention_policy
    snapshot_policy.snapshot_properties = snapshot_properties

    resource_policy_resource = compute_v1.ResourcePolicy(
        name=schedule_name,
        description=schedule_description,
        snapshot_schedule_policy=snapshot_policy,
    )

    client = compute_v1.ResourcePoliciesClient()
    operation = client.patch(
        project=project_id,
        region=region,
        resource_policy=schedule_name,
        resource_policy_resource=resource_policy_resource,
    )
    wait_for_extended_operation(operation, "Resource Policy updating")

    return client.get(project=project_id, region=region, resource_policy=schedule_name)

REST

Crea una solicitud PATCH al método resourcePolicies para actualizar la descripción, el programa, la política de retención, la política de eliminación del disco de origen o las etiquetas de una programación de instantáneas. En el cuerpo de la solicitud, solo necesitas especificar el name y los campos que deseas actualizar.

  • Cambia la descripción y la etiqueta:

    PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/resourcePolicies/SCHEDULE_NAME
{
    "name": "SCHEDULE_NAME",
    "description": "DESCRIPTION",
    "snapshotProperties": {
        "labels": {"KEY": "VALUE"}
    }
}

  • Cambia la programación de instantáneas a por hora:

    PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/resourcePolicies/SCHEDULE_NAME
{
    "name": "SCHEDULE_NAME",
    "snapshotSchedulePolicy": {
        "schedule": {
          "hourlySchedule": {
              "hoursInCycle": HOURLY_INTERVAL,
              "startTime": START_TIME
           }
        }
    }
}

  • Cambia la programación de instantáneas a todos los días:

    PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/resourcePolicies/SCHEDULE_NAME
{
    "name": "SCHEDULE_NAME",
    "snapshotSchedulePolicy": {
        "schedule": {
          "dailySchedule": {
              "daysInCycle": DAILY_INTERVAL,
              "startTime": START_TIME
           }
        }
    }
}

  • Cambia la programación de instantáneas a todas las semanas:

    PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/resourcePolicies/SCHEDULE_NAME
{
    "name": "SCHEDULE_NAME",
    "snapshotSchedulePolicy": {
        "schedule": {
           "weeklySchedule": {
              "dayOfWeeks": [
                 {
                    "day": WEEKLY_INTERVAL,
                    "startTime": START_TIME
                 }
              ]
           }
        }
    }
}

  • Cambia la política de retención de instantáneas:

    PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/resourcePolicies/SCHEDULE_NAME
{
    "name": "SCHEDULE_NAME",
    "snapshotSchedulePolicy": {
        "retentionPolicy": {
            "maxRetentionDays": DAYS,
            "onSourceDiskDelete":"DELETE_OPTION"
        }
   }
}

Reemplaza lo siguiente:

  • PROJECT_ID: Nombre del proyecto.
  • REGION: la región en la que se encuentra la programación de instantáneas.
  • SCHEDULE_NAME: el nombre de la programación de instantáneas.
  • DESCRIPTION: una descripción de la programación de instantáneas. Coloca la descripción entre comillas.
  • KEY y VALUE: un par clave-valor que se puede usar para agrupar recursos relacionados o asociados.
  • HOURLY_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. Para que las instantáneas se creen a la misma hora todos los días, elige un número que se divida de manera equitativa en 24 (1, 2, 3, 4, 6, 8 o 12). Por ejemplo, si estableces --hourly-schedule en 12, la instantánea se generará cada 12 horas.
  • DAILY_INTERVAL: define la cantidad de días entre cada instantánea. Para crear una instantánea todos los días, usa el valor 1.
  • WEEKLY_INTERVAL: Define una programación que se ejecute en días específicos de la semana. Especifica uno o más días. Las siguientes opciones están disponibles: MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY y SUNDAY. Debes escribir los días de la semana, estos no distinguen entre mayúsculas y minúsculas. Puedes definir hasta 7 intervalos para dayOfWeeks, uno para cada día de la semana.
  • START_TIME: la hora de inicio en UTC. La hora debe ser en punto. Por ejemplo:
    • 2:00 p.m. PST es 22:00 UTC.
    • Si estableces la hora de inicio a las 22:13, recibirás un error.
  • DAYS: la cantidad máxima de días de instantánea se conserva antes de que se borre.
  • DELETE_OPTION: Comportamiento de retención de instantáneas automáticas después de que se borra el disco original. El valor debe ser uno de los siguientes:
    • APPLY_RETENTION_POLICY: Cuando se borre el disco de origen, continúa aplicando la ventana de retención para cualquier instantánea creada por la programación de instantáneas.
    • KEEP_AUTO_SNAPSHOTS: (Predeterminado) Si se borra el disco de origen, conserva las instantáneas creadas por la programación de instantáneas, sin importar el período de retención.

Reemplaza una programación de instantáneas

Sigue estos pasos para borrar la programación de instantáneas y crear una nueva. Usa este método para modificar las propiedades de programación de instantáneas que no se pueden cambiar a través del procedimiento actualiza una programación de instantáneas.

Si reemplazas una programación de instantáneas que ya está conectada a un disco, primero debes desconectar la programación del disco y borrarla. Luego, puedes crear una programación nueva y conectarla al disco.

La política nueva no administrará las instantáneas que se generan a partir de la programación de instantáneas separadas. Esas instantáneas se conservarán de manera indefinida hasta que las borres.

Usa la consola de Google Cloud, gcloud CLI o REST para quitar y reemplazar la programación de instantáneas.

Console

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

    Ir a la página Discos

  2. Elige el disco que tiene la programación que quieres desvincular.
  3. En la página Administrar disco, haz clic en Editar. Es posible que primero debas hacer clic en el menú Más acciones.
  4. Abre el menú desplegable Programación de instantáneas.
  5. Haz clic en Sin programación para desconectar la programación del disco.
  6. Puedes crear una programación nueva o cambiar la programación mientras editas las opciones del disco.
  7. Haz clic en Guardar para completar la tarea.

gcloud

  1. Usa el comando gcloud disks remove-resource-policies para desconectar la programación de instantáneas del disco con la programación que quieres cambiar.

    gcloud compute disks remove-resource-policies DISK_NAME \
    --resource-policies SCHEDULE_NAME \
    --region REGION \
    --zone ZONE

    Reemplaza lo siguiente:

    • DISK_NAME: el nombre del disco con la programación de instantáneas conectada
    • SCHEDULE_NAME: el nombre de la programación de instantáneas que quieres desconectar del disco
    • REGION: la región en la que reside la programación de instantáneas
    • ZONE: la zona donde reside tu disco zonal

  2. Usa el comando gcloud disks add-resource-policies para agregar la programación de instantáneas nueva al disco.

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

    Reemplaza lo siguiente:

    • DISK_NAME: el nombre del disco con la política de recursos de la programación de instantáneas
    • SCHEDULE_NAME: el nombre de la programación de instantáneas que quieres agregar a este disco
    • ZONE: la zona en la que reside tu disco

REST

  1. Para desconectar la programación de instantáneas actual de un disco, crea una solicitud POST a disks.removeResourcePolicies.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/disks/DISK_NAME/removeResourcePolicies

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

    Reemplaza lo siguiente:

    • PROJECT_ID: nombre del proyecto
    • ZONE: la zona en la que reside el disco
    • DISK_NAME: el nombre del disco con la programación de instantáneas asociada
    • REGION: la ubicación de la programación de instantáneas
    • SCHEDULE_NAME: el nombre de la programación de instantáneas que quitas de este disco

  2. Para adjuntar la programación de instantáneas nueva al disco, crea una solicitud POST para el método disks.addResourcePolicies.

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

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

    Reemplaza lo siguiente:

    • PROJECT_ID: nombre del proyecto
    • ZONE: la ubicación del disco
    • DISK_NAME: Es el nombre del disco
    • REGION: la ubicación de la programación de instantáneas
    • SCHEDULE_NAME: el nombre de la programación de instantáneas que aplicas a este disco

Borrar una programación de instantáneas

Si borras una programación de instantáneas, todas las instantáneas generadas de forma automática que estaban asociadas a esta programación se conservan de forma permanente. Sin embargo, una vez que se borra la programación, ya no se generarán instantáneas.

Tu política de retención es parte de la programación de instantáneas. Una vez que se borra la programación, tu política de retención ya no se aplica. Las instantáneas generadas se conservan de forma permanente hasta que las borres de forma manual.

Para borrar una programación de instantáneas existente, usa la consola de Google Cloud, Google Cloud CLI o el método de la API de Compute Engine. Si la programación ya está adjunta a un disco, primero deberás desvincular la programación del disco y, luego, borrar la programación. No puedes borrar una programación de instantáneas adjunta a un disco.

Console

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

    Ir a la página de instantáneas

  2. Elige Programación de instantáneas para ver una lista de tus programaciones.
  3. Elige cualquier programación no asociada a un disco.

  4. Haz clic en Borrar.

gcloud

Para borrar una programación de instantáneas, usa el comando resource-policies delete.

gcloud compute resource-policies delete SCHEDULE_NAME \
    --region REGION

Reemplaza lo siguiente:

  • SCHEDULE_NAME: el nombre de la programación de instantáneas.
  • REGION: la ubicación de la programación de instantáneas

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
)

// deleteSnapshotSchedule deletes a snapshot schedule.
func deleteSnapshotSchedule(w io.Writer, projectID, scheduleName, region string) error {
	// projectID := "your_project_id"
	// snapshotName := "your_snapshot_name"
	// region := "eupore-central2"

	ctx := context.Background()

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

	req := &computepb.DeleteResourcePolicyRequest{
		Project:        projectID,
		Region:         region,
		ResourcePolicy: scheduleName,
	}
	op, err := snapshotsClient.Delete(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to delete snapshot schedule: %w", err)
	}

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

	fmt.Fprint(w, "Snapshot schedule deleted\n")

	return nil
}

Java 

import com.google.cloud.compute.v1.DeleteResourcePolicyRequest;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.ResourcePoliciesClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class DeleteSnapshotSchedule {
  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 region where your snapshot schedule is located.
    String region = "us-central1";
    // Name of the snapshot schedule you want to delete.
    String snapshotScheduleName = "YOUR_SCHEDULE_NAME";

    deleteSnapshotSchedule(projectId, region, snapshotScheduleName);
  }

  // Deletes a snapshot schedule policy.
  public static Status deleteSnapshotSchedule(
          String projectId, String region, String snapshotScheduleName)
          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.
    try (ResourcePoliciesClient resourcePoliciesClient = ResourcePoliciesClient.create()) {
      DeleteResourcePolicyRequest request = DeleteResourcePolicyRequest.newBuilder()
              .setProject(projectId)
              .setRegion(region)
              .setResourcePolicy(snapshotScheduleName)
              .build();
      Operation response = resourcePoliciesClient.deleteAsync(request).get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        throw new Error("Snapshot schedule deletion failed! " + response.getError());
      }
      return response.getStatus();
    }
  }
}

Node.js 

// Import the Compute library
const computeLib = require('@google-cloud/compute');

// Instantiate a resourcePoliciesClient
const resourcePoliciesClient = new computeLib.ResourcePoliciesClient();
// Instantiate a regionOperationsClient
const regionOperationsClient = new computeLib.RegionOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The project name.
const projectId = await resourcePoliciesClient.getProjectId();

// The location of the snapshot schedule resource policy.
// region = 'us-central1';

// The name of the snapshot schedule.
// snapshotScheduleName = 'snapshot-schedule-name'

async function callDeleteSnapshotSchedule() {
  // If the snapshot schedule is already attached to a disk, you will receive an error.
  const [response] = await resourcePoliciesClient.delete({
    project: projectId,
    region,
    resourcePolicy: snapshotScheduleName,
  });

  let operation = response.latestResponse;

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

  console.log(`Snapshot schedule: ${snapshotScheduleName} deleted.`);
}

await callDeleteSnapshotSchedule();

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 snapshot_schedule_delete(
    project_id: str, region: str, snapshot_schedule_name: str
) -> None:
    """
    Deletes a snapshot schedule for a specified project and region.
    Args:
        project_id (str): The ID of the Google Cloud project.
        region (str): The region where the snapshot schedule is located.
        snapshot_schedule_name (str): The name of the snapshot schedule to delete.
    Returns:
        None
    """
    client = compute_v1.ResourcePoliciesClient()
    operation = client.delete(
        project=project_id, region=region, resource_policy=snapshot_schedule_name
    )
    wait_for_extended_operation(operation, "Resource Policy deletion")

REST

Para borrar una programación de instantáneas, realiza una solicitud DELETE al método resourcePolicies.delete. Si la programación de instantáneas ya está conectada a un disco, recibirás un error.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/resourcePolicies/SCHEDULE_NAME

Reemplaza lo siguiente:

  • PROJECT_ID: nombre del proyecto
  • REGION: la ubicación de la programación de instantáneas
  • SCHEDULE_NAME: el nombre de la programación de instantáneas.

Registro y supervisión

Cada instantánea programada asociada a un disco crea de manera continua un evento del sistema, que se supervisa y registra en todo momento. Los registros de auditoría de eventos del sistema siempre están habilitados.

Estos registros proporcionan información del comportamiento sobre las instantáneas programadas para cada disco asociado. Puedes ver tus registros desde el menú de Logging en la consola de Google Cloud.

Para obtener más información sobre el uso del Explorador de registros, consulta Visualiza registros con el Explorador de registros.

Console

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

    Ir a la página Explorador de registros

  2. En la lista desplegable Todos los recursos, coloca el cursor sobre Disco y selecciona Todos los disk_id.

  3. En la lista desplegable Todos los registros, elige cloudaudit.googleapis.com/system_event y haz clic en Aceptar.

  4. En la lista desplegable Cualquier nivel de registro (Any log level), elige el tipo de registro.

¿Qué sigue?