Crie horários para instantâneos de discos

Linux Windows

---

Cria uma programação de instantâneos para fazer cópias de segurança regulares e automáticas dos volumes de Persistent Disk zonais e regionais e dos volumes de Google Cloud Hyperdisk. Use programações de instantâneos como prática recomendada para fazer uma cópia de segurança das suas cargas de trabalho do Compute Engine.

Se quiser criar uma programação de instantâneos que capture o estado dos dados da aplicação no momento da cópia de segurança, também conhecido como consistente com a aplicação, guest-flush ou instantâneo VSS, consulte o artigo Crie instantâneos de disco consistentes com a aplicação Linux ou Crie um instantâneo de disco consistente com a aplicação Windows.

Para mais informações sobre as propriedades da programação de instantâneos, consulte o artigo Propriedades da programação de instantâneos.

Antes de começar

• Reveja as limitações para agendamentos de capturas instantâneas.
• 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.

  Go

  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 criar uma programação de instantâneos: compute.resourcePolicies.create no projeto ou na organização
• Para anexar um horário de instantâneos a um disco:
  • compute.disks.addResourcePolicies no disco
  • compute.resourcePolicies.use na política de recursos
• Para criar um disco com uma programação de instantâneos:
  • compute.disks.create no projeto
  • compute.resourcePolicies.create no projeto
  • compute.disks.addResourcePolicies no disco

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

Vista geral da criação de programações de instantâneos

Quando cria uma programação de instantâneos, cria uma política de recursos que pode aplicar a um ou mais volumes de discos persistentes ou Hyperdisk.

Pode criar programações de instantâneos das seguintes formas:

• Crie um agendamento de instantâneos e, de seguida, anexe-o a um disco existente.
• Crie um novo disco com um agendamento de instantâneos.

Usar a encriptação com horários de instantâneos

Se um disco usar uma chave de encriptação gerida pelo cliente (CMEK), quando usa uma programação de instantâneos para criar instantâneos desse disco, todos os instantâneos criados são automaticamente encriptados com a mesma chave.

Não pode usar programações de instantâneos com discos que usam uma chave de encriptação fornecida pelo cliente (CSEK).

Crie uma programação de instantâneos

Pode criar um horário de instantâneos para os seus discos através da Google Cloud consola, da Google Cloud CLI ou da API REST. Tem de criar a sua agenda de instantâneos na mesma região onde reside o disco. Por exemplo, se o disco estiver na zona us-west1-a, tem de criar a programação de instantâneos na região us-west1. No entanto, pode optar por armazenar os instantâneos gerados pela programação de instantâneos numa localização diferente.

Nota: se usar a CLI gcloud ou a Google Cloud consola, tem sempre de definir uma política de retenção quando criar uma programação de instantâneos. Se fizer um pedido através do REST, pode omitir este campo e as suas imagens instantâneas são retidas indefinidamente.

Consola

1. Na Google Cloud consola, aceda à página Instâncias de VM.

   Aceda a Instâncias de VM
   Os passos restantes aparecem automaticamente na consola Google Cloud .

2. Selecione o projeto que contém as suas instâncias de VM.
3. Na coluna Nome, clique no nome da MV que tem o disco persistente para o qual quer criar uma programação de instantâneos.
4. Em Armazenamento, clique no nome do Disco de arranque ou do Disco adicional para criar um agendamento de instantâneos.
5. Clique em Editar. Pode ter de clicar no menu Mais ações e, de seguida, Editar.
6. Em Horário de instantâneo, escolha Criar um horário.
7. Em Nome, introduza um dos seguintes nomes para o horário do instantâneo:
   • boot-disk-snapshot-schedule
   • attached-persistent-disk-snapshot-schedule

8. Na secção Localização, escolha a localização de armazenamento das suas fotos instantâneas. A localização predefinida ou personalizada definida nas definições de instantâneo é selecionada automaticamente. Opcionalmente, pode substituir as definições de instantâneo e armazenar os seus instantâneos num local de armazenamento personalizado fazendo o seguinte:

   1. Escolha o tipo de localização de armazenamento que quer para a sua captura instantânea.

      • Escolha Multirregional para uma maior disponibilidade a um custo mais elevado.
        
      • Escolha Capturas instantâneas regionais para ter mais controlo sobre a localização física dos seus dados a um custo inferior.

   2. No campo Selecionar localização, selecione a região específica ou a região múltipla que quer usar. Para usar a região ou a multirregião mais próxima do seu disco de origem, selecione Com base na localização do disco.

9. Para concluir a criação da programação de instantâneos, clique em Criar.
10. Para anexar este agendamento de instantâneos ao disco persistente, clique em Guardar.

gcloud

• Para agendar instantâneos com âmbito global para um disco, use o comando gcloud compute resource-policies create snapshot-schedule. Defina a frequência do agendamento como horária, diária ou semanal.

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

• (Pré-visualização) Para agendar instantâneos com âmbito regional para um disco, use o comando gcloud compute resource-policies create snapshot-schedule e especifique a região do instantâneo.

  gcloud beta compute resource-policies create snapshot-schedule SCHEDULE_NAME \
      --description "SCHEDULE_DESCRIPTION" \
      --max-retention-days MAX_RETENTION_DAYS \
      --start-time START_TIME \
      --hourly-schedule SNAPSHOT_INTERVAL \
      --daily-schedule \
      --weekly-schedule SNAPSHOT_INTERVAL or --weekly-schedule-from-file FILE_NAME \
      --on-source-disk-delete DELETION_OPTION \
      --storage-location=STORAGE_LOCATION \
      --region REGION \
      --snapshot-region SNAPSHOT_REGION
  

Substitua o seguinte:

• SCHEDULE_NAME: o nome da agenda de resumos.
• SCHEDULE_DESCRIPTION: uma descrição da agenda de capturas. Use aspas à volta da descrição.
• REGION: a localização da política de recursos de agendamento de instantâneos.
• SNAPSHOT_REGION: a região à qual a captura de ecrã agendada se destina.

• MAX_RETENTION_DAYS: o número de dias para reter a imagem instantânea.

  Por exemplo, um valor de 3 significa que as capturas de ecrã são retidas durante 3 dias antes de serem eliminadas. Tem de usar um valor igual ou superior a 1.

• START_TIME: a hora de início no fuso horário UTC. A hora tem de começar na hora.

  Por exemplo:

  • Tem de especificar as 14:00 PST como 22:00.
  • Se definir uma hora de início de 22:13, recebe um erro.

  Se usar a flag --weekly-schedule-from-file e especificar uma hora de início no ficheiro, não precisa de incluir esta flag.

• SNAPSHOT_INTERVAL: o intervalo entre a criação de instantâneos sucessivos. 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.

  • Defina um horário diário incluindo a flag --daily-schedule sem qualquer valor.
  • Defina uma programação por hora com a flag --hourly-schedule definida para um valor inteiro entre 1 e 23. Para gerar instantâneos à mesma hora todos os dias, escolha um número de horas que seja divisível por 24. Por exemplo, definir --hourly-schedule como 12 significa que é criado um instantâneo a cada 12 horas.
  • Defina um horário semanal com a flag --weekly-schedule definida para o dia da semana em que quer que a captura instantânea seja criada. Tem de indicar o dia da semana por extenso. Os valores não são sensíveis a maiúsculas e minúsculas. Por exemplo, para fazer uma cópia de segurança do disco todas as sextas-feiras, o comando incluiria --weekly-schedule=friday.

  • Defina um horário semanal avançado, especificando diferentes dias da semana e com diferentes horas de início, incluindo a flag --weekly-schedule-from-file. Substitua FILE_NAME pelo nome do ficheiro que contém o horário de instantâneos semanais. Embora possa especificar diferentes dias da semana e diferentes horas de início através de um ficheiro, não pode especificar vários horários semanais diretamente na linha de comandos. Por exemplo, o ficheiro pode especificar dois horários semanais, na segunda-feira e na quarta-feira, mas não pode duplicar esta definição na linha de comandos:

    [
      {"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 na linha de comandos. O horário usa o fuso horário UTC.

• DELETION_OPTION: determina o que acontece aos seus instantâneos se o disco de origem for eliminado. Se quiser manter todos os instantâneos gerados, pode omitir esta flag. Caso contrário, especifique apply-retention-policy para usar as definições numa política de retenção.

• STORAGE_LOCATION: opcional: a localização de armazenamento. Se omitir esta flag, é usada a localização de armazenamento predefinida.

Exemplos

Em todos os exemplos seguintes:

• A regra de eliminação de discos está incluída; a flag --on-source-disk-delete está definida como o valor predefinido de keep-auto-snapshots para manter permanentemente todos os instantâneos gerados automaticamente. Em alternativa, defina esta flag como apply-retention-policy para usar a sua política de retenção de instantâneos.
• A localização de armazenamento está definida manualmente como US, pelo que todas as fotos instantâneas geradas são armazenadas na multirregião dos EUA.
• As etiquetas env=dev e media=images são aplicadas a todas as capturas de ecrã geradas.
• A política de retenção está definida para 10 dias.

Agendamento por hora: neste exemplo, o agendamento de instantâneos começa às 22:00 UTC (14:00 PST) e ocorre a cada 4 horas.

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

Horário diário: neste exemplo, o horário da captura instantânea começa às 22:00 UTC (14:00 PST) e ocorre todos os dias à mesma hora. A flag --daily-schedule tem de estar presente, mas sem um valor associado.

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

Horário semanal: neste exemplo, o horário da captura de ecrã começa às 22:00 UTC (14:00 PST) e ocorre todas as semanas à terça-feira.

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

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

// createSnapshotSchedule creates a snapshot schedule.
func createSnapshotSchedule(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.InsertResourcePolicyRequest{
		Project: projectID,
		Region:  region,
		ResourcePolicyResource: &computepb.ResourcePolicy{
			Name:        proto.String(scheduleName),
			Description: proto.String("MY DAILY SNAPSHOT SCHEDULE"),
			Region:      proto.String("europe-central2"),
			SnapshotSchedulePolicy: &computepb.ResourcePolicySnapshotSchedulePolicy{
				RetentionPolicy: &computepb.ResourcePolicySnapshotSchedulePolicyRetentionPolicy{
					MaxRetentionDays: proto.Int32(10),
					// Check the OnSourceDiskDelete enum for the list of possible values.
					OnSourceDiskDelete: proto.String("KEEP_AUTO_SNAPSHOTS"),
				},
				Schedule: &computepb.ResourcePolicySnapshotSchedulePolicySchedule{
					DailySchedule: &computepb.ResourcePolicyDailyCycle{
						DaysInCycle: proto.Int32(1),
						StartTime:   proto.String("22:00"),
					},
				},
				SnapshotProperties: &computepb.ResourcePolicySnapshotSchedulePolicySnapshotProperties{
					StorageLocations: []string{"eu"},
					Labels: map[string]string{
						"env":   "dev",
						"media": "images",
					},
				},
			},
		},
	}
	op, err := snapshotsClient.Insert(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 created\n")

	return nil
}

Java

import com.google.cloud.compute.v1.InsertResourcePolicyRequest;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.ResourcePoliciesClient;
import com.google.cloud.compute.v1.ResourcePolicy;
import com.google.cloud.compute.v1.ResourcePolicyHourlyCycle;
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 java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateSnapshotSchedule {
  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 in which you want to create the snapshot schedule.
    String region = "us-central1";
    // Name of the snapshot schedule you want to create.
    String snapshotScheduleName = "YOUR_SCHEDULE_NAME";
    // Description of the snapshot schedule.
    String scheduleDescription = "YOUR_SCHEDULE_DESCRIPTION";
    // Maximum number of days to retain snapshots.
    int maxRetentionDays = 10;
    // Storage location for the snapshots.
    // More about storage locations:
    // https://cloud.google.com/compute/docs/disks/snapshots?authuser=0#selecting_a_storage_location
    String storageLocation = "US";

    createSnapshotSchedule(projectId, region, snapshotScheduleName, scheduleDescription,
            maxRetentionDays, storageLocation);
  }

  // Creates a snapshot schedule policy.
  public static Status createSnapshotSchedule(String projectId, String region,
            String snapshotScheduleName, String scheduleDescription, int maxRetentionDays,
            String storageLocation)
          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()) {
      int snapshotInterval = 10; // Create a snapshot every 10 hours
      String startTime = "08:00"; // Define the hourly schedule

      ResourcePolicyHourlyCycle hourlyCycle = ResourcePolicyHourlyCycle.newBuilder()
              .setHoursInCycle(snapshotInterval)
              .setStartTime(startTime)
              .build();

      ResourcePolicySnapshotSchedulePolicyRetentionPolicy retentionPolicy =
              ResourcePolicySnapshotSchedulePolicyRetentionPolicy.newBuilder()
                      .setMaxRetentionDays(maxRetentionDays)
                      .setOnSourceDiskDelete(OnSourceDiskDelete.KEEP_AUTO_SNAPSHOTS.toString())
              .build();

      ResourcePolicySnapshotSchedulePolicySnapshotProperties snapshotProperties =
              ResourcePolicySnapshotSchedulePolicySnapshotProperties.newBuilder()
                      .addStorageLocations(storageLocation)
                      .build();

      ResourcePolicySnapshotSchedulePolicy snapshotSchedulePolicy =
              ResourcePolicySnapshotSchedulePolicy.newBuilder()
                      .setRetentionPolicy(retentionPolicy)
                      .setSchedule(ResourcePolicySnapshotSchedulePolicySchedule.newBuilder()
                               .setHourlySchedule(hourlyCycle)
                               .build())
                      .setSnapshotProperties(snapshotProperties)
                      .build();

      ResourcePolicy resourcePolicy = ResourcePolicy.newBuilder()
              .setName(snapshotScheduleName)
              .setDescription(scheduleDescription)
              .setSnapshotSchedulePolicy(snapshotSchedulePolicy)
              .build();
      InsertResourcePolicyRequest request = InsertResourcePolicyRequest.newBuilder()
              .setProject(projectId)
              .setRegion(region)
              .setResourcePolicyResource(resourcePolicy)
              .build();

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

      if (response.hasError()) {
        throw new Error("Snapshot schedule creation failed! " + 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';

// The description of the snapshot schedule.
const snapshotScheduleDescription = 'snapshot schedule description...';

async function callCreateSnapshotSchedule() {
  const [response] = await resourcePoliciesClient.insert({
    project: projectId,
    region,
    resourcePolicyResource: new compute.ResourcePolicy({
      name: snapshotScheduleName,
      description: snapshotScheduleDescription,
      snapshotSchedulePolicy:
        new compute.ResourcePolicyInstanceSchedulePolicySchedule({
          retentionPolicy:
            new compute.ResourcePolicySnapshotSchedulePolicyRetentionPolicy({
              maxRetentionDays: 5,
            }),
          schedule: new compute.ResourcePolicySnapshotSchedulePolicySchedule({
            // Similarly, you can create a weekly or monthly schedule.
            // Review the resourcePolicies.insert method for details specific to setting a weekly or monthly schedule.
            // To see more details, open: `https://cloud.google.com/compute/docs/disks/scheduled-snapshots?authuser=0#create_snapshot_schedule`
            dailySchedule: new compute.ResourcePolicyDailyCycle({
              startTime: '12:00',
              daysInCycle: 1,
            }),
          }),
          snapshotProperties:
            new compute.ResourcePolicySnapshotSchedulePolicySnapshotProperties(
              {
                guestFlush: false,
                labels: {
                  env: 'dev',
                  media: 'images',
                },
                // OPTIONAL: the storage location. If you omit this flag, the default storage location is used.
                // storageLocations: 'storage-location',
              }
            ),
        }),
    }),
  });

  let operation = response.latestResponse;

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

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

await callCreateSnapshotSchedule();

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_create(
    project_id: str,
    region: str,
    schedule_name: str,
    schedule_description: str,
    labels: dict,
) -> compute_v1.ResourcePolicy:
    """
    Creates a snapshot schedule for disks 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 will be created.
        schedule_name (str): The name of the snapshot schedule group.
        schedule_description (str): The description of the snapshot schedule group.
        labels (dict): The labels to apply to the snapshots. Example: {"env": "dev", "media": "images"}
    Returns:
        compute_v1.ResourcePolicy: The created resource policy.
    """

    # # Every hour, starts at 12:00 AM
    # hourly_schedule = compute_v1.ResourcePolicyHourlyCycle(
    #     hours_in_cycle=1, start_time="00:00"
    # )
    #
    # # 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])

    # In this example we use daily_schedule - every day, starts between 12:00 AM and 1:00 AM
    daily_schedule = compute_v1.ResourcePolicyDailyCycle(
        days_in_cycle=1, start_time="00:00"
    )

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

    # Autodelete snapshots after 5 days
    retention_policy = compute_v1.ResourcePolicySnapshotSchedulePolicyRetentionPolicy(
        max_retention_days=5
    )
    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.insert(
        project=project_id,
        region=region,
        resource_policy_resource=resource_policy_resource,
    )
    wait_for_extended_operation(operation, "Resource Policy creation")

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

REST

• Para criar uma programação de instantâneos para instantâneos com âmbito global, crie um pedido POST para resourcePolicies.insert. Tem de incluir o nome do horário do instantâneo e a frequência do instantâneo.

  Também pode especificar manualmente uma localização de armazenamento de instantâneos e adicionar etiquetas de recursos no seu pedido.

  Por predefinição, o parâmetro onSourceDiskDelete está definido como keepAutoSnapshots. Isto significa que, se o disco de origem for eliminado, o instantâneo gerado automaticamente para esse disco é retido indefinidamente. Em alternativa, pode definir a flag como applyRetentionPolicy para aplicar a política de retenção.

  O exemplo seguinte define um agendamento de instantâneos diários que começa às 12:00 UTC (04:00 PST) e se repete todos os dias. O exemplo também define uma política de retenção de 5 dias. Após 5 dias, as capturas de ecrã são removidas automaticamente.

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/resourcePolicies
  
      {
      "name": "SCHEDULE_NAME",
      "description": "SCHEDULE_DESCRIPTION",
      "snapshotSchedulePolicy": {
        "schedule": {
          "dailySchedule": {
            "startTime": "12:00",
            "daysInCycle": "1"
          }
        },
        "retentionPolicy": {
          "maxRetentionDays": "5"
        },
        "snapshotProperties": {
          "guestFlush": "False",
          "labels": {
            "env": "dev",
            "media": "images"
          },
          "storageLocations": "STORAGE_LOCATION"
        }
      }
      }
  

• (Pré-visualização) Para criar uma agenda de instantâneos para instantâneos com âmbito regional, crie um pedido POST para resourcePolicies.insert e especifique a região do instantâneo.

  POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/regions/REGION/resourcePolicies
  
      {
      "name": "SCHEDULE_NAME",
      "description": "SCHEDULE_DESCRIPTION",
      "snapshotSchedulePolicy": {
        "schedule": {
          "dailySchedule": {
            "startTime": "12:00",
            "daysInCycle": "1"
          }
        },
        "retentionPolicy": {
          "maxRetentionDays": "5"
        },
        "snapshotProperties": {
          "guestFlush": "False",
          "region": "SNAPSHOT_REGION"
        }
      }
      }
  

Substitua o seguinte:

• PROJECT_ID: o nome do projeto
• REGION: a localização da política de recursos de agendamento de instantâneos
• SNAPSHOT_REGION: a região à qual o resumo agendado está limitado
• SCHEDULE_DESCRIPTION: a descrição do agendamento de instantâneos
• SCHEDULE_NAME: o nome da agenda de instantâneos
• STORAGE_LOCATION: opcional: a localização de armazenamento. Se omitir esta flag, é usada a localização de armazenamento predefinida.

Da mesma forma, pode criar um horário semanal ou mensal. Reveja o método resourcePolicies.insert para ver detalhes específicos sobre a definição de uma agenda semanal ou mensal.

Por exemplo, o seguinte pedido cria um agendamento semanal que é executado na terça-feira às 09:00 UTC.

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

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

Anexe um agendamento de instantâneos a um disco

Depois de criar um agendamento, anexe-o a um disco existente. Use a consola, a CLI gcloud ou a API Compute Engine.

Consola

Anexe um agendamento de instantâneos a um disco existente.

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

   Aceda a Discos

2. Selecione o nome do disco ao qual quer anexar uma programação de instantâneos. É apresentada a página Gerir disco.

3. Na página Gerir disco, clique em Editar. Pode ter de clicar primeiro no menu Mais ações.

4. Use o menu pendente Horário da captura instantânea para adicionar o horário ao disco. Em alternativa, crie um novo horário.

5. Se criou um novo horário, clique em Criar.

6. Clique em Guardar para concluir a tarefa.

gcloud

Para anexar um horário de instantâneos a um disco, use o comando gcloud disks add-resource-policies.

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

Substitua o seguinte:

• DISK_NAME: o nome do disco existente
• SCHEDULE_NAME: o nome da agenda de instantâneos
• ZONE: a localização do disco

Go

import (
	"context"
	"fmt"
	"io"

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

// attachSnapshotSchedule attaches a snapshot schedule to disk.
func attachSnapshotSchedule(w io.Writer, projectID, scheduleName, diskName, region string) error {
	// projectID := "your_project_id"
	// snapshotName := "your_snapshot_name"
	// diskName := "your_disk_name"
	// region := "europe-central2"

	ctx := context.Background()

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

	req := &computepb.AddResourcePoliciesRegionDiskRequest{
		Project: projectID,
		Region:  region,
		Disk:    diskName,
		RegionDisksAddResourcePoliciesRequestResource: &computepb.RegionDisksAddResourcePoliciesRequest{
			ResourcePolicies: []string{
				fmt.Sprintf("projects/%s/regions/%s/resourcePolicies/%s", projectID, region, scheduleName),
			},
		},
	}
	op, err := disksClient.AddResourcePolicies(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to attach 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 attached\n")

	return nil
}

Java

import com.google.cloud.compute.v1.AddResourcePoliciesDiskRequest;
import com.google.cloud.compute.v1.DisksAddResourcePoliciesRequest;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class AttachSnapshotScheduleToDisk {
  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 zone where your disk is located.
    String zone = "us-central1-a";
    // Name of the disk you want to attach the snapshot schedule to.
    String diskName = "YOUR_DISK_NAME";
    // Name of the snapshot schedule you want to attach.
    String snapshotScheduleName = "YOUR_SNAPSHOT_SCHEDULE_NAME";
    // Name of the region where your snapshot schedule is located.
    String region = "us-central1";

    attachSnapshotScheduleToDisk(projectId, zone, diskName, snapshotScheduleName, region);
  }

  // Attaches a snapshot schedule to a disk.
  public static Status attachSnapshotScheduleToDisk(
        String projectId, String zone, String diskName, String snapshotScheduleName, String region)
        throws IOException, ExecutionException, InterruptedException, TimeoutException {

    String resourcePolicyLink = String.format(
            "projects/%s/regions/%s/resourcePolicies/%s", projectId, region, 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 (DisksClient disksClient = DisksClient.create()) {

      AddResourcePoliciesDiskRequest request = AddResourcePoliciesDiskRequest.newBuilder()
              .setProject(projectId)
              .setZone(zone)
              .setDisk(diskName)
              .setDisksAddResourcePoliciesRequestResource(
                      DisksAddResourcePoliciesRequest.newBuilder()
                              .addResourcePolicies(resourcePolicyLink)
                              .build())
              .build();

      Operation response = disksClient.addResourcePoliciesAsync(request).get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        throw new Error("Error attaching snapshot schedule to disk: " + response.getError());
      }
      return response.getStatus();
    }
  }
}

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_attach(
    project_id: str, zone: str, region: str, disk_name: str, schedule_name: str
) -> None:
    """
    Attaches a snapshot schedule to a specified disk.
    Args:
        project_id (str): The ID of the Google Cloud project.
        zone (str): The zone where the disk is located.
        region (str): The region where the snapshot schedule was created
        disk_name (str): The name of the disk to which the snapshot schedule will be attached.
        schedule_name (str): The name of the snapshot schedule that you are applying to this disk
    Returns:
        None
    """
    disks_add_request = compute_v1.DisksAddResourcePoliciesRequest(
        resource_policies=[f"regions/{region}/resourcePolicies/{schedule_name}"]
    )

    client = compute_v1.DisksClient()
    operation = client.add_resource_policies(
        project=project_id,
        zone=zone,
        disk=disk_name,
        disks_add_resource_policies_request_resource=disks_add_request,
    )
    wait_for_extended_operation(operation, "Attaching snapshot schedule to disk")

REST

Construa um pedido POST para disks.addResourcePolicies anexar um agendamento de instantâneos a um disco existente.

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 zona onde o disco está localizado
• REGION: a região onde o horário do instantâneo foi criado
• DISK_NAME: o nome do disco
• SCHEDULE_NAME: o nome da programação de instantâneos que está a aplicar a este disco

Crie um disco com um horário de instantâneos

Pode usar a Google Cloud consola ou a CLI gcloud para criar um disco e um horário de instantâneos em simultâneo.

Consola

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

   Aceda a Discos

2. Clique em Criar disco.

3. Preencha os campos obrigatórios para criar um disco zonal ou regional.

4. Crie o disco na mesma região que a programação de instantâneos.

5. Preencha os campos do horário do Snapshot.

6. Use o menu pendente e preencha os campos para criar o horário.

7. Clique em Criar para criar o horário.

8. Clique em Criar para criar o disco.

gcloud

Use o comando gcloud disks create para criar um disco persistente ou um Hyperdisk zonal ou regional e anexar-lhe uma programação de instantâneos.

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

Substitua o seguinte:

• DISK_NAME: o nome do novo disco
• SCHEDULE_NAME: o nome da agenda de instantâneos
• ZONE: a localização onde está a criar o disco. O disco tem de estar numa zona que esteja na mesma região que a programação de instantâneos.

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

// createDiskWithSnapshotSchedule creates a new empty regional disk with snapshot schedule
func createDiskWithSnapshotSchedule(
	w io.Writer,
	projectID, region, diskName, diskType, scheduleName string,
	replicaZones []string,
	diskSizeGb int64,
) error {
	// projectID := "your_project_id"
	// region := "us-west3" // should match diskType below
	// diskName := "your_disk_name"
	// diskType := "regions/us-west3/diskTypes/pd-ssd"
	// scheduleName := "your_schedule_name"
	// replicaZones := []string{"us-west3-a", "us-west3-b"}
	// diskSizeGb := 120

	// Exactly two replica zones must be specified
	replicaZoneURLs := []string{
		fmt.Sprintf("projects/%s/zones/%s", projectID, replicaZones[0]),
		fmt.Sprintf("projects/%s/zones/%s", projectID, replicaZones[1]),
	}

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

	req := &computepb.InsertRegionDiskRequest{
		Project: projectID,
		Region:  region,
		DiskResource: &computepb.Disk{
			Name:         proto.String(diskName),
			Region:       proto.String(region),
			Type:         proto.String(diskType),
			SizeGb:       proto.Int64(diskSizeGb),
			ReplicaZones: replicaZoneURLs,
			ResourcePolicies: []string{
				fmt.Sprintf("projects/%s/regions/%s/resourcePolicies/%s", projectID, region, scheduleName),
			},
		},
	}

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

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

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

	return nil
}

Java

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

public class CreateDiskWithSnapshotSchedule {
  public static void main(String[] args)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the zone in which you want to create the disk.
    String zone = "us-central1-a";
    // Name of the disk you want to create.
    String diskName = "YOUR_DISK_NAME";
    // Name of the schedule you want to link to the disk.
    String snapshotScheduleName = "YOUR_SCHEDULE_NAME";

    createDiskWithSnapshotSchedule(projectId, zone, diskName, snapshotScheduleName);
  }

  // Creates disk with linked snapshot schedule.
  public static Status createDiskWithSnapshotSchedule(
      String projectId, String zone, String diskName, 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 (DisksClient disksClient = DisksClient.create()) {
      String region = zone.substring(0, zone.lastIndexOf('-'));
      // Get the resource policy to link to the disk
      String resourcePolicyLink = String.format("projects/%s/regions/%s/resourcePolicies/%s",
              projectId, region, snapshotScheduleName);

      Disk disk = Disk.newBuilder()
              .setName(diskName)
              .setZone(zone)
              .addAllResourcePolicies(List.of(resourcePolicyLink))
              .build();

      Operation response = disksClient.insertAsync(projectId, zone, disk).get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        throw new Error("Disk creation failed! " + response.getError());
      }
      return response.getStatus();
    }
  }
}

O que se segue?

• Saiba como gerir agendamentos de resumos.
• Saiba mais sobre as frequências de instantâneos programados, as políticas de retenção e as regras de nomenclatura em Acerca das programações de instantâneos para discos.
• Saiba como criar uma imagem personalizada a partir do resumo.
• Saiba como ver registos.