Faça a gestão dos horários de instantâneos para discos

Linux Windows

Este documento descreve como gerir as programações de instantâneos para os seus volumes de Persistent Disk zonais e regionais e Google Cloud Hyperdisk.

Pode gerir os agendamentos de capturas instantâneas da seguinte forma:

• Veja os horários dos resumos
• Altere os agendamentos de instantâneos
• Elimine agendamentos de instantâneos

Também pode configurar alertas para as capturas de ecrã agendadas.

Antes de começar

• Se ainda não o tiver feito, configure a autenticação. A autenticação valida a sua identidade para aceder a Google Cloud serviços e APIs. Para executar código ou exemplos a partir de um ambiente de desenvolvimento local, pode autenticar-se no Compute Engine selecionando uma das seguintes opções:

  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. Instale a CLI Google Cloud. Após a instalação, inicialize a CLI gcloud executando o seguinte comando:

     gcloud init

     Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

     Nota: se instalou a CLI gcloud anteriormente, certifique-se de que tem a versão mais recente executando gcloud components update.
  2. Set a default region and zone.

  Ir

  Para usar os Go exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.

  Instale a CLI Google Cloud.

  Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

  Nota: se instalou a CLI gcloud anteriormente, certifique-se de que tem a versão mais recente executando gcloud components update.

  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.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para mais informações, consulte Set up authentication for a local development environment.

  Java

  Para usar os Java exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.

  Instale a CLI Google Cloud.

  Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

  Nota: se instalou a CLI gcloud anteriormente, certifique-se de que tem a versão mais recente executando gcloud components update.

  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.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para mais informações, consulte Set up authentication for a local development environment.

  Node.js

  Para usar os Node.js exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.

  Instale a CLI Google Cloud.

  Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

  Nota: se instalou a CLI gcloud anteriormente, certifique-se de que tem a versão mais recente executando gcloud components update.

  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.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para mais informações, consulte Set up authentication for a local development environment.

  Python

  Para usar os Python exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.

  Instale a CLI Google Cloud.

  Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

  Nota: se instalou a CLI gcloud anteriormente, certifique-se de que tem a versão mais recente executando gcloud components update.

  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.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para mais informações, consulte Set up authentication for a local development environment.

  REST

  Para usar os exemplos da API REST nesta página num ambiente de desenvolvimento local, usa as credenciais que fornece à CLI gcloud.

  Instale a CLI Google Cloud.

  Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

  Nota: se instalou a CLI gcloud anteriormente, certifique-se de que tem a versão mais recente executando gcloud components update.

  Para mais informações, consulte o artigo Autenticar para usar REST na Google Cloud documentação de autenticação.

Funções e autorizações necessárias

Para receber as autorizações de que precisa para criar um agendamento de instantâneos, peça ao seu administrador para lhe conceder as seguintes funções de IAM no projeto:

• Administrador de instâncias do Compute (v1) (roles/compute.instanceAdmin.v1)
• Para estabelecer ligação a uma VM que pode ser executada como uma conta de serviço: Utilizador da conta de serviço (v1) (roles/iam.serviceAccountUser)

Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Estas funções predefinidas contêm as autorizações necessárias para criar uma programação de instantâneos. Para ver as autorizações exatas que são necessárias, expanda a secção Autorizações necessárias:

Autorizações necessárias

São necessárias as seguintes autorizações para criar um agendamento de instantâneos:

• Para ver as programações de instantâneos: compute.resourcePolicies.list no projeto ou na organização
• Para atualizar uma programação de instantâneos:
  • compute.resourcePolicies.update na política de recursos
  • compute.resourcePolicies.get na política de recursos
• Para substituir uma programação de instantâneos:
  • compute.resourcePolicies.use na política de recursos
  • compute.disks.addResourcePolicies no disco
  • compute.disks.removeResourcePolicies no disco
• Para eliminar uma programação de instantâneos:
  • compute.resourcePolicies.delete na política de recursos
  • compute.disks.removeResourcePolicies no disco

Também pode conseguir estas autorizações com funções personalizadas ou outras funções predefinidas.

Veja os horários dos resumos

Para obter uma lista de agendamentos de instantâneos, use o comando gcloud da consola ou o método da API Compute Engine. Este pedido apresenta o nome, a descrição e a região de todos os agendamentos de instantâneos num projeto.

Consola

1. Na Google Cloud consola, aceda à página Instantâneos.

   Aceda à página Instantâneos

2. Selecione o separador Programações de instantâneos.
3. Use o campo Filtrar para restringir a lista de agendamentos de instantâneos.
4. Clique no nome de uma programação de instantâneos para ver os respetivos detalhes.

gcloud

Para ver uma lista dos seus agendamentos de instantâneos, use o comando resource-policies list.

 gcloud compute resource-policies list

Para ver a descrição de uma agenda de instantâneos específica, use o comando resource-policies describe.

gcloud compute resource-policies describe SCHEDULE_NAME

Substitua SCHEDULE_NAME pelo nome da agenda de instantâneos.

Ir

Apresentar agendamentos de instantâneos

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
}

Descreva um agendamento de instantâneos

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

Apresentar agendamentos de instantâneos

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;
    }
  }
}

Descreva agendamentos de instantâneos

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

Apresentar agendamentos de instantâneos

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

Descreva um agendamento de instantâneos

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

Faça um GET pedido para resourcePolicies.aggregatedList para devolver uma lista das programações de instantâneos de um projeto.

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

Substitua PROJECT_ID pelo nome do projeto.

Veja os horários dos resumos por região

Para ver as programações de instantâneos de um projeto numa região específica, use a Google Cloud consola, a CLI gcloud ou a API REST.

Consola

1. Na Google Cloud consola, aceda à página Instantâneos.

   Aceda à página Instantâneos

2. Selecione o separador Programações de instantâneos.
3. Use o campo Filtro para listar as programações de instantâneos de uma região específica.

gcloud

Para ver as programações de instantâneos de um projeto numa região específica, use o comando resource-policies list.

gcloud compute resource-policies list PROJECT_ID --filter REGION

Substitua o seguinte:

• PROJECT_ID: o nome do projeto
• REGION: a região, por exemplo, us-west1

REST

Faça um pedido GET ao método resourcePolicies.list para obter os agendamentos de instantâneos criados numa região.

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

Substitua o seguinte:

• PROJECT_ID: o nome do projeto
• REGION: a região, por exemplo, us-west1

Altere um agendamento de instantâneos

Depois de criar um horário de instantâneo, pode modificar os seguintes campos dinamicamente através do procedimento Atualizar um horário de instantâneo:

• Descrição
• Programação de instantâneos
• Etiquetas aplicadas às imagens instantâneas geradas
• Política de eliminação do disco de origem para processar instantâneos gerados automaticamente se o disco de origem for eliminado
• Política de retenção para definir durante quanto tempo devem ser mantidos os instantâneos gerados a partir da programação de instantâneos

Para atualizar outros valores de um agendamento de instantâneos, tem de eliminar o agendamento de instantâneos e criar um novo, conforme descrito em Substitua um agendamento de instantâneos.

As atualizações da programação de resumos entram em vigor no primeiro resumo após as atualizações. Se um instantâneo estiver em execução enquanto atualiza a agenda de instantâneos, as alterações entram em vigor no instantâneo seguinte.

Nota: quando atualiza uma programação de instantâneos, apenas os instantâneos criados após a atualização usam os valores da programação de instantâneos atualizados. Os instantâneos existentes não são atualizados.

Atualize um agendamento de instantâneos

Pode usar a CLI Google Cloud ou a API Compute Engine para alterar algumas das propriedades da sua programação de instantâneos, conforme descrito no artigo Alterar uma programação de instantâneos.

Para alterar outras propriedades do agendamento de resumos, use o método descrito no artigo Substitua um agendamento de resumos.

Consola

1. Na Google Cloud consola, aceda à página Instantâneos.

   Aceda à página Instantâneos

2. Selecione Horários de capturas de ecrã para ver uma lista dos seus horários.
3. Clique no nome da programação de instantâneos que quer modificar.
4. Na página de detalhes do horário da captura instantânea, clique no botão Editar horário.

gcloud

Use o comando compute resource-policies update para atualizar a descrição, o agendamento, a política de retenção ou as etiquetas de um agendamento de instantâneos.

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

Substitua o seguinte:

• SCHEDULE_NAME: o nome da agenda de resumos.
• REGION: a região onde reside a sua agenda de capturas de ecrã.
• DESCRIPTION: uma descrição da programação do instantâneo. Use aspas à volta da descrição.
• KEY e VALUE: um par de chave-valor que pode ser usado para agrupar recursos relacionados ou associados.
• DAYS: número máximo de dias que o resumo é retido antes de ser eliminado.
• DELETE_OPTION: comportamento de retenção das cópias instantâneas automáticas após a eliminação do disco original. O valor tem de ser um dos seguintes:
  • apply-retention-policy: Quando o disco de origem é eliminado, continua a aplicar o período de retenção a todos os instantâneos criados pela agenda de instantâneos.
  • keep-auto-snapshots: (Predefinição) Se o disco de origem for eliminado, mantenha todas as capturas de ecrã criadas pela programação de capturas de ecrã, independentemente do período de retenção.
• START_TIME: a hora de início em UTC. A hora tem de começar na hora exata. Por exemplo:
  • As 14:00 PST são 22:00.
  • Se definir uma hora de início de 22:13, recebe um erro.

• SCHEDULE_FLAG: um dos seguintes flags:

  • --hourly-schedule=HOURLY_INTERVAL: o número de horas entre cada instantâneo. O valor HOURLY_INTERVAL tem de ser um número inteiro entre 1 e 23. Por exemplo, definir --hourly-schedule como 12 significa que a captura de ecrã é gerada a cada 12 horas.
  • --daily-schedule: faz um instantâneo diariamente, à(s) START_TIME

  • --weekly-schedule=WEEKLY_INTERVAL: define o dia em que quer que a criação de instantâneos ocorra. Tem de indicar o dia da semana por extenso. Os valores não são sensíveis a maiúsculas e minúsculas.

    Nota: se quiser especificar um horário semanal com dias diferentes da semana e com horas de início diferentes, use a flag --weekly-schedule-from-file em vez de --weekly-schedule.

  • --weekly-schedule-from-file=FILE_NAME: especifica um ficheiro que contém o horário de instantâneos semanais. Pode especificar horários semanais em diferentes dias da semana e em diferentes horas através de um ficheiro. Por exemplo, o seu ficheiro pode especificar um horário de instantâneo na segunda-feira e na quarta-feira: none [{"day": "MONDAY", "startTime": "04:00"}, {"day": "WEDNESDAY", "startTime": "02:00"}] Se incluir uma hora de início no ficheiro, não precisa de definir a flag --start-time. O horário usa o fuso horário UTC. A hora tem de começar na hora. Por exemplo:

    • As 14:00 PST são 22:00.
    • Se definir uma hora de início de 22:13, recebe um erro.

  Os flags de frequência de instantâneos hourly-schedule, daily-schedule, weekly-schedule e weekly-schedule-from-file são mutuamente exclusivos. Só pode usar um para o seu agendamento de instantâneos.

Exemplos:

Para alterar uma programação de resumo para uma programação diária:

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

Para alterar um resumo para uma programação por hora e também atualizar a descrição e a etiqueta do resumo:

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"

Para alterar as políticas de retenção de instantâneos e eliminação de discos de origem para uma agenda de instantâneos:

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

Ir

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

Construa um pedido PATCH para o método resourcePolicies para atualizar a descrição, a programação, a política de retenção, a política de eliminação do disco de origem ou as etiquetas de uma programação de instantâneos. No corpo do pedido, só precisa de especificar o name e os campos que quer atualizar.

• Altere a descrição e a 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"}
      }
  }
  

• Altere o horário do resumo para De hora em 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
             }
          }
      }
  }
  

• Altere a programação do resumo para diária:

  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
             }
          }
      }
  }
  

• Alterar o horário das capturas instantâneas para semanal:

  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
                   }
                ]
             }
          }
      }
  }
  

• Altere a política de retenção de instantâneos:

  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"
          }
     }
  }
  

Substitua o seguinte:

• PROJECT_ID: o nome do projeto.
• REGION: a região onde a agenda de instantâneos está localizada.
• SCHEDULE_NAME: o nome da agenda de resumos.
• DESCRIPTION: uma descrição da programação do instantâneo. Use aspas à volta da descrição.
• KEY e VALUE: um par de chave-valor que pode ser usado para agrupar recursos relacionados ou associados.
• HOURLY_INTERVAL: define o intervalo no qual quer que a criação de imagens ocorra. Defina o horário de cada hora com um número inteiro entre 1 e 23. Para que as capturas de ecrã sejam criadas à mesma hora todos os dias, escolha um número que seja divisível por 24 (1, 2, 3, 4, 6, 8 ou 12). Por exemplo, definir --hourly-schedule como 12 significa que a captura instantânea é gerada a cada 12 horas.
• DAILY_INTERVAL: define o número de dias entre cada captura de ecrã. Para criar uma captura instantânea todos os dias, use o valor 1.
• WEEKLY_INTERVAL: define um horário que é executado em dias específicos da semana. Especifique um ou mais dias. As seguintes opções estão disponíveis: MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY e SUNDAY. Tem de escrever os dias da semana por extenso; não são sensíveis a maiúsculas e minúsculas. Pode definir até 7 intervalos para dayOfWeeks, um para cada dia da semana.
• START_TIME: a hora de início em UTC. A hora tem de começar na hora exata. Por exemplo:
  • As 14:00 PST correspondem a 22:00 UTC.
  • Se definir uma hora de início de 22:13, recebe um erro.
• DAYS: número máximo de dias que o resumo é retido antes de ser eliminado.
• DELETE_OPTION: comportamento de retenção das cópias instantâneas automáticas após a eliminação do disco original. O valor tem de ser um dos seguintes:
  • APPLY_RETENTION_POLICY: Quando o disco de origem é eliminado, continua a aplicar o período de retenção a todos os instantâneos criados pela agenda de instantâneos.
  • KEEP_AUTO_SNAPSHOTS: (Predefinição) Se o disco de origem for eliminado, mantenha todas as capturas de ecrã criadas pela programação de capturas de ecrã, independentemente do período de retenção.

Substitua um agendamento de instantâneos

Siga estes passos para eliminar a programação de instantâneos e criar uma nova. Use este método para modificar as propriedades da agenda de instantâneos que não podem ser alteradas através do procedimento atualizar uma agenda de instantâneos.

Se estiver a substituir um horário de instantâneos já associado a um disco, tem de desassociar primeiro o horário do disco e eliminá-lo. Em seguida, pode criar um novo agendamento e anexá-lo ao disco.

As imagens instantâneas geradas a partir do horário de imagens instantâneas desanexado não são geridas pela nova política. Essas capturas de ecrã são retidas indefinidamente até as eliminar.

Use a Google Cloud consola, a CLI gcloud ou o REST para remover e substituir o seu horário de capturas instantâneas.

Consola

1. Na Google Cloud consola, aceda à página Discos.

   Aceda à página Discos

2. Selecione o disco que tem o horário que quer desanexar.
3. Na página Gerir disco, clique em Editar. Pode ter de clicar primeiro no menu Mais ações.
4. Abra o menu pendente Agendamento de instantâneos.
5. Clique em Sem programação para desanexar a programação do disco.
6. Pode criar um novo agendamento ou trocar o agendamento enquanto edita as opções do disco.
7. Clique em Guardar para concluir a tarefa.

gcloud

1. Use o comando gcloud disks remove-resource-policies para desanexar o horário de instantâneos do disco com o horário que quer alterar.

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

   Substitua o seguinte:

   • DISK_NAME: o nome do disco com o agendamento de instantâneos anexado
   • SCHEDULE_NAME: o nome da programação de instantâneos que quer desassociar deste disco
   • REGION: a região onde reside a sua agenda de instantâneos
   • ZONE: a zona onde o disco zonal reside

2. Use o comando gcloud disks add-resource-policies para adicionar o novo horário de instantâneo ao disco.

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

   Substitua o seguinte:

   • DISK_NAME: o nome do disco com a política de recursos de agendamento de instantâneos
   • SCHEDULE_NAME: o nome do agendamento de instantâneos que quer adicionar a este disco
   • ZONE: a zona onde o seu disco reside

REST

1. Desassocie a programação de instantâneos atual de um disco criando um pedido POST para disks.removeResourcePolicies.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/disks/DISK_NAME/removeResourcePolicies
   
   {
     "resourcePolicies": [
        "regions/REGION/resourcePolicies/SCHEDULE_NAME"
     ]
   }
   

   Substitua o seguinte:

   • PROJECT_ID: o nome do projeto
   • ZONE: a zona onde o disco reside
   • DISK_NAME: o nome do disco com o programa de instantâneos associado
   • REGION: a localização da programação de instantâneos
   • SCHEDULE_NAME: o nome da agenda de instantâneos que está a remover deste disco

2. Associe a nova programação de instantâneos ao disco criando um pedido para o método disks.addResourcePolicies.POST

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/disks/DISK_NAME/addResourcePolicies
   
   {
     "resourcePolicies": [
       "regions/REGION/resourcePolicies/SCHEDULE_NAME"
     ]
   }
   

   Substitua o seguinte:

   • PROJECT_ID: o nome do projeto
   • ZONE: a localização do disco
   • DISK_NAME: o nome do disco
   • REGION: a localização da programação de instantâneos
   • SCHEDULE_NAME: o nome da agenda de instantâneos que está a aplicar a este disco

Elimine um agendamento de instantâneos

Se eliminar um agendamento de instantâneos, todos os instantâneos gerados automaticamente associados ao agendamento de instantâneos são mantidos permanentemente. No entanto, depois de o agendamento ser eliminado, deixa de poder gerar instantâneos.

A sua política de retenção faz parte do seu agendamento de instantâneos. Após a eliminação do horário, a política de retenção deixa de se aplicar. As fotos instantâneas que já foram geradas são mantidas permanentemente até as eliminar manualmente.

Para eliminar uma programação de instantâneos existente, use aGoogle Cloud consola, a CLI Google Cloud ou o método da API Compute Engine. Se o horário já estiver associado a um disco, desassocie o horário primeiro do disco e, em seguida, elimine o horário. Não pode eliminar um horário de instantâneos associado a um disco.

Consola

1. Na Google Cloud consola, aceda à página Instantâneos.

   Aceda à página Instantâneos

2. Selecione Horários de capturas de ecrã para ver uma lista dos seus horários.
3. Selecione qualquer horário não associado a um disco.

4. Clique em Eliminar.

   Nota: se o horário já estiver anexado a um disco, tem de primeiro desanexar o horário do respetivo disco, para poder eliminar o horário.

gcloud

Para eliminar um horário de instantâneos, use o comando resource-policies delete.

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

Substitua o seguinte:

• SCHEDULE_NAME: o nome da programação de instantâneos
• REGION: a localização da programação de instantâneos

Ir

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 eliminar um horário de instantâneo, faça um pedido DELETE para o método resourcePolicies.delete. Se o horário de instantâneos já estiver associado a um disco, recebe um erro.

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

Substitua o seguinte:

• PROJECT_ID: o nome do projeto
• REGION: a localização da programação de instantâneos
• SCHEDULE_NAME: o nome da programação de instantâneos

Registo e monitorização

Cada instantâneo agendado associado a um disco cria continuamente um evento do sistema, que é monitorizado e registado em todos os momentos. Os registos de auditoria de eventos do sistema estão sempre ativados.

Estes registos fornecem informações comportamentais sobre as suas cópias instantâneas agendadas para cada disco associado. Pode ver os seus registos no menu Registo na Google Cloud consola.

Para mais informações sobre a utilização do Explorador de registos, consulte o artigo Veja registos através do Explorador de registos.

Consola

1. Na Google Cloud consola, aceda à página Explorador de registos.

   Aceda à página do Explorador de registos

2. Na lista pendente Todos os recursos, aponte para Disco e selecione Todos os disk_id.

3. Na lista pendente Todos os registos, selecione cloudaudit.googleapis.com/system_event e clique em OK.

4. Na lista pendente Qualquer nível de registo, selecione o tipo de registo.

O que se segue?

• Saiba mais sobre as frequências de agendamento de instantâneos, as políticas de retenção e as regras de nomenclatura no artigo Acerca dos agendamentos de instantâneos para discos.
• Veja e elimine as capturas instantâneas geradas, conforme descrito em Gerir capturas instantâneas de disco.
• Saiba como ver registos.