Esta página foi traduzida pela API Cloud Translation.

Faça uma cópia de segurança dos seus dados através de uma captura instantânea

Esta página mostra como fazer uma cópia de segurança dos dados armazenados na sua instância de notebooks geridos pelo utilizador do Vertex AI Workbench criando um instantâneo.

Os dados na sua instância são armazenados num disco persistente zonal. Pode criar e usar instantâneos deste disco para fazer uma cópia de segurança dos seus dados, criar uma programação de cópias de segurança recorrente e restaurar dados para uma nova instância.

Criar um instantâneo

Pode criar instantâneos a partir de discos, mesmo quando estão anexados a instâncias em execução. As imagens instantâneas são recursos globais, pelo que pode usá-las para restaurar dados para um novo disco ou instância no mesmo projeto. Também pode partilhar instantâneos entre projetos.

Autorizações necessárias para esta tarefa

Para realizar esta tarefa, tem de ter as seguintes autorizações:

compute.snapshots.create no projeto
compute.disks.createSnapshot no disco

Consola

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 .
Selecione o projeto que contém as suas instâncias de VM.
Na coluna Nome, clique no nome da MV que tem o disco a ser cópia de segurança.
Em Armazenamento:
- Para fazer uma cópia de segurança do disco de arranque, na secção Disco de arranque, clique no Nome do disco de arranque.
- Para fazer uma cópia de segurança de um disco de dados anexado, em Discos adicionais, clique no Nome do disco.
Clique em Criar instantâneo.
Em Nome, introduza um nome exclusivo para ajudar a identificar a finalidade do instantâneo, por exemplo:
- boot-disk-snapshot
- attached-data-disk-snapshot
Em Tipo, a predefinição é uma captura de ecrã padrão. Os instantâneos padrão são mais adequados para cópias de segurança a longo prazo e recuperação de desastres.
Escolha Arquivo de instantâneos para criar uma cópia de segurança mais rentável do que os instantâneos padrão, mas com um tempo de recuperação de dados mais longo.

Para mais informações, consulte a secção Comparação de tipos de instantâneos.
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 numa localização de armazenamento personalizada 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, escolha uma localização na secção intitulada Com base na localização do disco.
Para criar uma captura instantânea, clique em Criar.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Crie o instantâneo através da política de localização de armazenamento definida nas suas definições de instantâneo ou através de uma localização de armazenamento alternativa à sua escolha. Para mais informações, consulte o artigo Escolha a localização de armazenamento das capturas de ecrã. Tem de especificar um nome do instantâneo. O nome tem de ter entre 1 e 63 carateres e estar em conformidade com a RFC 1035.
- Para criar um instantâneo de um volume do disco persistente na localização predefinida ou personalizada configurada nas definições de instantâneos, use o comando gcloud compute snapshots create.
```
gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk SOURCE_DISK \
    --snapshot-type SNAPSHOT_TYPE \
    --source-disk-zone SOURCE_DISK_ZONE
```
- Em alternativa, para substituir as definições de instantâneo e criar um instantâneo numa localização de armazenamento personalizada, inclua a flag --storage-location para indicar onde armazenar o instantâneo:
```
gcloud compute snapshots create SNAPSHOT_NAME \
  --source-disk SOURCE_DISK \
  --source-disk-zone SOURCE_DISK_ZONE \
  --storage-location STORAGE_LOCATION \
  --snapshot-type SNAPSHOT_TYPE
```
  Substitua o seguinte:
  - SNAPSHOT_NAME: um nome para o resumo.
  - SOURCE_DISK: o nome do volume do Persistent Disk zonal a partir do qual quer criar um instantâneo.
  - SNAPSHOT_TYPE: o tipo de instantâneo, STANDARD ou ARCHIVE. Se não for especificado um tipo de instantâneo, é criado um instantâneo STANDARD. Escolha Arquivar para uma retenção de dados mais rentável.
  - SOURCE_DISK_ZONE: a zona do volume do Persistent Disk zonal a partir do qual quer criar um instantâneo.
  - STORAGE_LOCATION: Para localizações de armazenamento personalizadas, esta é a multirregião do Cloud Storage ou a região do Cloud Storage onde quer armazenar a sua captura de ecrã. Pode especificar apenas uma localização de armazenamento.
  Use a flag --storage-location apenas quando quiser substituir a localização de armazenamento predefinida ou personalizada configurada nas definições de instantâneo.
A CLI gcloud aguarda até que a operação devolva um estado de READY ou FAILED, ou atinja o limite de tempo máximo e devolva os últimos detalhes conhecidos da captura de ecrã.

Nota: a Google recomenda a utilização do gcloud compute snapshots create comando em vez do comando gcloud compute disks snapshot, porque suporta mais funcionalidades, como a criação de instantâneos num projeto diferente do projeto do disco de origem.

Terraform

Para criar um resumo do disco persistente zonal, use o recurso google_compute_snapshot.

resource "google_compute_snapshot" "snapdisk" {
  name        = "snapshot-name"
  source_disk = google_compute_disk.default.name
  zone        = "us-central1-a"
}

Para saber como aplicar ou remover uma configuração do Terraform, consulte os comandos básicos do Terraform.

API

Crie o instantâneo na política de localização de armazenamento definida nas definições de instantâneo ou usando uma localização de armazenamento alternativa à sua escolha. Para mais informações, consulte o artigo Escolha a localização de armazenamento das capturas de ecrã.

Para criar o seu instantâneo na localização predefinida ou personalizada configurada nas definições de instantâneos, faça um pedido POST ao método snapshots.insert:
```
POST https://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/global/snapshots

{
  "name": SNAPSHOT_NAME
  "sourceDisk": "projects/SOURCE_PROJECT_ID/zones/SOURCE_ZONE/disks/SOURCE_DISK_NAME
  "snapshotType": SNAPSHOT_TYPE
}
```
Substitua o seguinte:
- DESTINATION_PROJECT_ID: o ID do projeto no qual quer criar a captura de ecrã.
- SNAPSHOT_NAME: um nome para o resumo.
- SOURCE_PROJECT_ID: o ID do projeto do disco de origem.
- SOURCE_ZONE: a zona do disco de origem.
- SOURCE_DISK_NAME: o nome do Persistent Disk a partir do qual quer criar um instantâneo.
- SNAPSHOT_TYPE: o tipo de instantâneo, STANDARD ou ARCHIVE. Se não for especificado um tipo de instantâneo, é criado um instantâneo STANDARD.
Em alternativa, para substituir as definições de instantâneo e criar um instantâneo numa localização de armazenamento personalizada, faça um pedido POST ao método snapshots.insert e inclua a propriedade storageLocations no seu pedido:
```
POST https://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/global/snapshots

{
  "name": SNAPSHOT_NAME
  "sourceDisk": "projects/SOURCE_PROJECT_ID/zones/SOURCE_ZONE/disks/SOURCE_DISK_NAME
  "snapshotType": SNAPSHOT_TYPE
  "storageLocations": STORAGE_LOCATION
}
```
Substitua o seguinte:
- DESTINATION_PROJECT_ID: o ID do projeto no qual quer criar a captura de ecrã.
- SNAPSHOT_NAME: um nome para o resumo.
- SOURCE_PROJECT_ID: o ID do projeto do disco de origem.
- SOURCE_ZONE: a zona do disco de origem.
- SOURCE_DISK_NAME: o nome do Persistent Disk a partir do qual quer criar um instantâneo.
- SNAPSHOT_TYPE: o tipo de instantâneo, STANDARD ou ARCHIVE. Se não for especificado um tipo de instantâneo, é criado um instantâneo STANDARD.
- STORAGE_LOCATION: a multirregião do Cloud Storage ou a região do Cloud Storage onde quer armazenar a sua captura instantânea. Pode especificar apenas uma localização de armazenamento.
  
  Use o parâmetro storageLocations apenas quando quiser substituir a localização de armazenamento predefinida ou personalizada configurada nas definições de instantâneo.

snapshots.insertdisks.createSnapshot

Go

Antes de experimentar este exemplo, siga as instruções de configuração no guia de início rápido do Compute Engine com bibliotecas cliente.

Para se autenticar no Compute Engine, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

import (
	"context"
	"fmt"
	"io"

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

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

	ctx := context.Background()

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

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

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

	if diskProjectID == "" {
		diskProjectID = projectID
	}

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

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

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

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

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

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

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

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

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

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

	return nil
}

Java

Antes de experimentar este exemplo, siga as instruções de configuração no guia de início rápido do Compute Engine com bibliotecas cliente.

Para se autenticar no Compute Engine, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.


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

public class CreateSnapshot {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    }
  }
}

Node.js

Antes de experimentar este exemplo, siga as instruções de configuração no guia de início rápido do Compute Engine com bibliotecas cliente.

Para se autenticar no Compute Engine, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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

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

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

  let disk;

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

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

  if (!diskProjectId) {
    diskProjectId = projectId;
  }

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

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

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

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

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

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

createSnapshot();

Python

Antes de experimentar este exemplo, siga as instruções de configuração no guia de início rápido do Compute Engine com bibliotecas cliente.

Para se autenticar no Compute Engine, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

    Args:
        project_id: project ID or project number of the Cloud project you want
            to use to store the snapshot.
        disk_name: name of the disk you want to snapshot.
        snapshot_name: name of the snapshot to be created.
        zone: name of the zone in which is the disk you want to snapshot (for zonal disks).
        region: name of the region in which is the disk you want to snapshot (for regional disks).
        location: The Cloud Storage multi-region or the Cloud Storage region where you
            want to store your snapshot.
            You can specify only one storage location. Available locations:
            https://cloud.google.com/storage/docs/locations#available-locations
        disk_project_id: project ID or project number of the Cloud project that
            hosts the disk you want to snapshot. If not provided, will look for
            the disk in the `project_id` project.

    Returns:
        The new snapshot instance.
    """
    if zone is None and region is None:
        raise RuntimeError(
            "You need to specify `zone` or `region` for this function to work."
        )
    if zone is not None and region is not None:
        raise RuntimeError("You can't set both `zone` and `region` parameters.")

    if disk_project_id is None:
        disk_project_id = project_id

    if zone is not None:
        disk_client = compute_v1.DisksClient()
        disk = disk_client.get(project=disk_project_id, zone=zone, disk=disk_name)
    else:
        regio_disk_client = compute_v1.RegionDisksClient()
        disk = regio_disk_client.get(
            project=disk_project_id, region=region, disk=disk_name
        )

    snapshot = compute_v1.Snapshot()
    snapshot.source_disk = disk.self_link
    snapshot.name = snapshot_name
    if location:
        snapshot.storage_locations = [location]

    snapshot_client = compute_v1.SnapshotsClient()
    operation = snapshot_client.insert(project=project_id, snapshot_resource=snapshot)

    wait_for_extended_operation(operation, "snapshot creation")

    return snapshot_client.get(project=project_id, snapshot=snapshot_name)

Agende uma cópia de segurança recorrente

Quando cria um agendamento de instantâneos, cria uma política de recursos que pode aplicar a um ou mais discos persistentes. Pode criar agendamentos de instantâneos das seguintes formas:

Uma programação de instantâneos inclui as seguintes propriedades:

Nome da agenda
Descrição da programação
Frequência de instantâneos (de hora em hora, diariamente, semanalmente)
Hora de início do resumo
Região onde a programação de instantâneos está disponível
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

Restrições

Um disco persistente pode ter, no máximo, 10 programações de instantâneos anexadas em simultâneo.
Não pode criar instantâneos de arquivo através de um agendamento de instantâneos.
Pode criar um máximo de 1000 programações de instantâneos em utilização por região.
As programações de instantâneos aplicam-se apenas no projeto em que foram criadas. Não é possível usar programações de instantâneos noutros projetos ou organizações.
Pode ter de pedir um aumento da quota de recursos através da consola se precisar de recursos adicionais na sua região.
Não pode eliminar um agendamento de instantâneos se estiver anexado a um disco. Tem de desassociar o horário de todos os discos e, em seguida, eliminar o horário.
Pode atualizar uma agenda de instantâneos existente para alterar a descrição, a agenda e as etiquetas. Para atualizar outros valores de um horário de instantâneos, tem de eliminar o horário de instantâneos e criar um novo.
Para discos persistentes que usam uma chave de encriptação fornecida pelo cliente (CSEK), não pode criar agendamentos de instantâneos.
Para discos persistentes que usam uma chave de encriptação gerida pelo cliente (CMEK), todas as capturas de ecrã criadas com um agendamento de capturas de ecrã são encriptadas automaticamente com a mesma chave.

Crie um horário

Autorizações necessárias para esta tarefa

Para realizar esta tarefa, tem de ter as seguintes autorizações:

compute.resourcePolicies.create no projeto ou na organização

Crie uma programação de instantâneos para os seus discos persistentes através da Google Cloud consola, da CLI Google Cloud ou da API Compute Engine. Tem de criar a sua agenda de instantâneos na mesma região onde reside o disco persistente. Por exemplo, se o disco persistente estiver na zona us-west1-a, a programação de instantâneos tem de estar na região us-west1. Para mais informações, consulte o artigo Escolha uma localização de armazenamento.

Consola

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

gcloud

Para criar um horário de instantâneos para discos persistentes, use o comando compute resource-policies create snapshot-schedule gcloud. 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] \
      --weekly-schedule-from-file [FILE_NAME] \
      --on-source-disk-delete [DELETION_OPTION]

where:

[SCHEDULE_NAME] é o nome da nova agenda de instantâneos.
"[SCHEDULE_DESCRIPTION]" é uma descrição do agendamento de resumos. Use aspas à volta da descrição.
[MAX_RETENTION_DAYS] é o número de dias para reter a captura de ecrã. Por exemplo, definir 3 significa que os instantâneos são retidos durante 3 dias antes de serem eliminados. Tem de definir uma política de retenção de, pelo menos, 1 dia.
[START_TIME] é a hora de início em 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.
[SNAPSHOT_INTERVAL] define o intervalo no qual quer que a captura de imagens ocorra. Defina a programação horária com um número inteiro entre 1 e 23. Escolha um número de horas que seja divisível por 24. Por exemplo, definir --hourly-schedule como 12 significa que a captura de ecrã é gerada a cada 12 horas. Para um horário semanal, defina os dias em que quer que a captura de instantâneos ocorra. Tem de escrever os dias da semana por extenso. Estes não são sensíveis a maiúsculas e minúsculas. Os indicadores de frequência de instantâneos hourly-schedule, daily-schedule e weekly-schedule são mutuamente exclusivos. Tem de escolher uma para o agendamento de instantâneos.

Nota: se quiser especificar um horário semanal com diferentes dias da semana e com diferentes horas de início, use --weekly-schedule-from-file.
[FILE_NAME] é o nome do ficheiro que contém o horário de instantâneos semanais, se optar por fornecer o horário neste formato. Tenha em atenção que pode especificar horários semanais em diferentes dias da semana e a horas diferentes através de um ficheiro (mas não pode especificar vários horários semanais diretamente na linha de comandos). Por exemplo, o ficheiro pode especificar uma programação de instantâneos na segunda-feira e na quarta-feira: [{"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 a norma de tempo UTC.
[DELETION_OPTION] determina o que acontece às suas imagens instantâneas se o disco de origem for eliminado. Escolha a predefinição keep-auto-snapshots omitindo esta flag ou use apply-retention-policy para aplicar uma política de retenção.

Seguem-se exemplos adicionais para configurar um agendamento de instantâneos. Em todos os seguintes exemplos:

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 como US, pelo que todos os instantâneos gerados são armazenados 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.

Horário de hora em hora: neste exemplo, o horário de instantâneos começa às 22:00 UTC e ocorre a cada 4 horas.

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

Horário diário: neste exemplo, o horário de instantâneos começa às 22:00 UTC e ocorre todos os dias à mesma hora. O sinalizador --daily-schedule tem de estar presente, mas não pode ter nenhum valor definido.

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

Horário semanal: neste exemplo, o horário de instantâneos começa às 22:00 UTC e ocorre todas as semanas às terças e quintas-feiras.

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

API

Na API, crie um pedido POST para resourcePolicies.insert para criar um agendamento de instantâneos. No mínimo, tem de incluir o nome da agenda de instantâneos, a localização regional do armazenamento de instantâneos e a frequência dos instantâneos.

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

O exemplo seguinte define um agendamento de instantâneos diário que começa às 12:00 UTC e repete-se 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.

Também pode incluir opções de localização de capturas rápidas e etiquetas de capturas rápidas no seu pedido para garantir que as capturas rápidas são armazenadas na localização da sua escolha.

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

{
 "name": "[SCHEDULE_NAME]",
 "description": "[SCHEDULE_DESCRIPTION]",
 "snapshotSchedulePolicy": {
   "schedule": {
     "dailySchedule": {
       "startTime": "12:00",
       "daysInCycle": "1"
     }
   },
   "retentionPolicy": {
     "maxRetentionDays": "5"
   },
   "snapshotProperties": {
     "guestFlush": "False",
     "labels": {
       "env": "dev",
       "media": "images"
     },
     "storageLocations": ["US"]
   }
 }
}

where:

[PROJECT_ID] é o nome do projeto.
[REGION] é a localização da política de recursos de agendamento de instantâneos.
[SCHEDULE_DESCRIPTION] é a descrição do agendamento de resumos.
[SCHEDULE_NAME] é o nome da programação de instantâneos.

Da mesma forma, pode criar um horário semanal ou mensal. Reveja a referência da API para ver detalhes específicos sobre a definição de uma programação semanal ou mensal.

Por exemplo, o seguinte pedido cria uma programação semanal que é executada às terças e quintas-feiras, às 09:00 e às 14:00, respetivamente.

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

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

Anexe um agendamento de instantâneos a um disco

Autorizações necessárias para esta tarefa

Para realizar esta tarefa, tem de ter as seguintes autorizações:

compute.disks.addResourcePolicies no disco
compute.resourcePolicies.use na política de recursos a usar

Depois de ter um agendamento, anexe-o a um disco existente. Use a consola, o gcloudcomando ou o método da API Compute Engine.

Consola

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

Na Google Cloud consola, aceda à página Discos.
Aceda à página Discos
Selecione o nome do disco ao qual quer anexar uma programação de instantâneos. É apresentada a página Gerir disco.
Na página Gerir disco, passe o cursor do rato sobre o menu Mais ações e selecione Editar.
Use o menu pendente Horário da captura instantânea para adicionar o horário ao disco. Em alternativa, crie um novo horário.
Se criou um novo horário, clique em Criar.
Clique em Guardar para concluir a tarefa.

gcloud

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

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

where:

[DISK_NAME] é o nome do disco existente.
[SCHEDULE_NAME] é o nome da programação de instantâneos.
[ZONE] é a localização do seu disco.

API

Na API, crie um pedido POST para disks.addResourcePolicies para anexar uma programação 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]"
  ]
}

where:

[PROJECT_ID] é o nome do projeto.
[ZONE] é a localização do disco.
[REGION] é a localização da agenda de instantâneos.
[DISK_NAME] é o nome do disco.
[SCHEDULE_NAME] é o nome da programação de instantâneos nessa região que está a aplicar a este disco.

Restaure dados a partir de uma captura instantânea

Se fez uma cópia de segurança de um disco de arranque ou não de arranque com uma imagem instantânea, pode criar um novo disco com base na imagem instantânea.

Restrições

O novo disco tem de ter, pelo menos, o mesmo tamanho que o disco de origem original do instantâneo. Se criar um disco maior do que o disco de origem original para o instantâneo, tem de redimensionar o sistema de ficheiros nesse disco persistente para incluir o espaço em disco adicional. Consoante o seu sistema operativo e o tipo de sistema de ficheiros, pode ter de usar uma ferramenta de redimensionamento do sistema de ficheiros diferente. Para mais informações, consulte a documentação do sistema operativo.

Crie um disco a partir de um instantâneo e anexe-o a uma VM

Autorizações necessárias para esta tarefa

Para realizar esta tarefa, tem de ter as seguintes autorizações:

compute.disks.create no projeto para criar um novo disco
compute.instances.attachDisk na instância de VM
compute.disks.use no disco para anexar

Consola

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

Aceder a Resumos
Encontre o nome da captura instantânea que quer restaurar.
Aceda à página Discos.

Aceda à página Discos
Clique em Criar novo disco.
Especifique os seguintes parâmetros de configuração:
- Um nome para o disco.
- Um tipo para o disco.
- Opcionalmente, pode substituir a seleção predefinida de região e zona. Pode selecionar qualquer região e zona, independentemente da localização de armazenamento do instantâneo de origem.
Em Tipo de origem, clique em Snapshot.
Selecione o nome da captura de ecrã a restaurar.
Selecione o tamanho do novo disco, em gigabytes. Este número tem de ser igual ou superior ao disco de origem original do instantâneo.
Clique em Criar para criar o disco.

Em seguida, pode anexar o novo disco a uma instância existente.

Aceda à página Instâncias de VM.
Aceda à página de instâncias de VM
Clique no nome da instância onde quer restaurar o disco não de arranque.
Na parte superior da página de detalhes da instância, clique em Editar.
Em Discos adicionais, clique em Anexar disco existente.
Selecione o nome do novo disco criado a partir da sua imagem instantânea.
Clique em Concluído para anexar o disco.
Na parte inferior da página de detalhes da instância, clique em Guardar para aplicar as alterações à instância.

gcloud

Use o comando gcloud compute snapshots list para encontrar o nome da captura de ecrã que quer restaurar:
```
gcloud compute snapshots list
```
Use o comando gcloud compute snapshots describe para encontrar o tamanho da captura instantânea que quer restaurar:
```
gcloud compute snapshots describe SNAPSHOT_NAME
```
Substitua SNAPSHOT_NAME pelo nome do instantâneo que está a ser restaurado.
Use o comando gcloud compute disks create para criar um novo disco regional ou zonal a partir da sua captura de ecrã. Se precisar de um disco persistente SSD para débito adicional ou IOPS, inclua a flag --type e especifique pd-ssd.
```
gcloud compute disks create DISK_NAME \
    --size=DISK_SIZE \
    --source-snapshot=SNAPSHOT_NAME \
    --type=DISK_TYPE
```
Substitua o seguinte:
- DISK_NAME: o nome do novo disco.
- DISK_SIZE: o tamanho do novo disco, em gigabytes. Este número tem de ser igual ou superior ao disco de origem original para a imagem instantânea.
- SNAPSHOT_NAME: o nome do instantâneo que está a ser restaurado.
- DISK_TYPE: URL completo ou parcial para o tipo do disco. Por exemplo, https://www.googleapis.com/compute/v1/projects/PROJECT_ID /zones/ZONE/diskTypes/pd-ssd.
Anexe o novo disco a uma instância existente através do comando gcloud compute instances attach-disk:
```
gcloud compute instances attach-disk INSTANCE_NAME \
    --disk DISK_NAME
```
Substitua o seguinte:
- INSTANCE_NAME é o nome da instância.
- DISK_NAME é o nome do disco criado a partir do seu instantâneo.

API

Construa um pedido GET para snapshots.list para apresentar a lista de instantâneos no seu projeto.

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

Substitua PROJECT_ID pelo ID do seu projeto.
Construa um pedido POST para criar um disco zonal através do método disks.insert. Inclua as propriedades name, sizeGb e type. Para restaurar um disco através de uma captura de ecrã, tem de incluir a propriedade sourceSnapshot.
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/disks

{
 "name": "DISK_NAME",
 "sizeGb": "DISK_SIZE",
 "type": "zones/ZONE/diskTypes/DISK_TYPE"
 "sourceSnapshot": "SNAPSHOT_NAME"
}
```
Substitua o seguinte:
- PROJECT_ID: o ID do seu projeto.
- ZONE a zona onde a sua instância e o novo disco estão localizados.
- DISK_NAME: o nome do novo disco.
- DISK_SIZE: o tamanho do novo disco, em gigabytes. Este número tem de ser igual ou superior ao disco de origem original para a imagem instantânea.
- DISK_TYPE: URL completo ou parcial para o tipo do disco. Por exemplo, https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ ZONE/diskTypes/pd-ssd.
- SNAPSHOT_NAME: o instantâneo de origem do disco que está a restaurar.
Em seguida, pode anexar o novo disco a uma instância existente criando um pedido POST para o método instances.attachDisk e incluindo o URL do disco zonal que acabou de criar a partir da sua cópia instantânea.
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/attachDisk

{
 "source": "/compute/v1/projects/PROJECT_ID/zones/ZONE/disks/DISK_NAME"
}
```
Substitua o seguinte:
- PROJECT_ID é o ID do seu projeto.
- ZONE é a zona onde a sua instância e o novo disco estão localizados.
- INSTANCE_NAME é o nome da instância onde está a adicionar o novo disco.
- DISK_NAME é o nome do novo disco.

Go

Antes de experimentar este exemplo, siga as Goinstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Go Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

import (
	"context"
	"fmt"
	"io"

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

// createDiskFromSnapshot creates a new disk in a project in given zone.
func createDiskFromSnapshot(
	w io.Writer,
	projectID, zone, diskName, diskType, snapshotLink string,
	diskSizeGb int64,
) error {
	// projectID := "your_project_id"
	// zone := "us-west3-b" // should match diskType below
	// diskName := "your_disk_name"
	// diskType := "zones/us-west3-b/diskTypes/pd-ssd"
	// snapshotLink := "projects/your_project_id/global/snapshots/snapshot_name"
	// diskSizeGb := 120

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

	req := &computepb.InsertDiskRequest{
		Project: projectID,
		Zone:    zone,
		DiskResource: &computepb.Disk{
			Name:           proto.String(diskName),
			Zone:           proto.String(zone),
			Type:           proto.String(diskType),
			SourceSnapshot: proto.String(snapshotLink),
			SizeGb:         proto.Int64(diskSizeGb),
		},
	}

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

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

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

	return nil
}

Java

Antes de experimentar este exemplo, siga as Javainstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Java Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.


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

public class CreateDiskFromSnapshot {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.

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

    // Name of the zone in which you want to create the disk.
    String zone = "europe-central2-b";

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

    // The type of disk you want to create. This value uses the following format:
    // "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
    // For example: "zones/us-west3-b/diskTypes/pd-ssd"
    String diskType = String.format("zones/%s/diskTypes/pd-ssd", zone);

    // Size of the new disk in gigabytes.
    long diskSizeGb = 10;

    // The full path and name of the snapshot that you want to use as the source for the new disk.
    // This value uses the following format:
    // "projects/{projectName}/global/snapshots/{snapshotName}"
    String snapshotLink = String.format("projects/%s/global/snapshots/%s", projectId,
        "SNAPSHOT_NAME");

    createDiskFromSnapshot(projectId, zone, diskName, diskType, diskSizeGb, snapshotLink);
  }

  // Creates a new disk in a project in given zone, using a snapshot.
  public static void createDiskFromSnapshot(String projectId, String zone, String diskName,
      String diskType, long diskSizeGb, String snapshotLink)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {

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

      // Set the disk properties and the source snapshot.
      Disk disk = Disk.newBuilder()
          .setName(diskName)
          .setZone(zone)
          .setSizeGb(diskSizeGb)
          .setType(diskType)
          .setSourceSnapshot(snapshotLink)
          .build();

      // Create the insert disk request.
      InsertDiskRequest insertDiskRequest = InsertDiskRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setDiskResource(disk)
          .build();

      // Wait for the create disk operation to complete.
      Operation response = disksClient.insertAsync(insertDiskRequest)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Disk creation failed!" + response);
        return;
      }
      System.out.println("Disk created. Operation Status: " + response.getStatus());
    }
  }
}

Node.js

Antes de experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Node.js Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const diskName = 'YOUR_DISK_NAME';
// const diskType = 'zones/us-west3-b/diskTypes/pd-ssd';
// const diskSizeGb = 10;
// const snapshotLink = 'projects/project_name/global/snapshots/snapshot_name';

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

async function createDiskFromSnapshot() {
  const disksClient = new compute.DisksClient();

  const [response] = await disksClient.insert({
    project: projectId,
    zone,
    diskResource: {
      sizeGb: diskSizeGb,
      name: diskName,
      zone,
      type: diskType,
      sourceSnapshot: snapshotLink,
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

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

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

createDiskFromSnapshot();

Python

Para saber como instalar ou atualizar o SDK Vertex AI para Python, consulte o artigo Instale o SDK Vertex AI para Python. Para mais informações, consulte a Python documentação de referência da API.

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


def create_disk_from_snapshot(
    project_id: str,
    zone: str,
    disk_name: str,
    disk_type: str,
    disk_size_gb: int,
    snapshot_link: str,
) -> compute_v1.Disk:
    """
    Creates a new disk in a project in given zone.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone in which you want to create the disk.
        disk_name: name of the disk you want to create.
        disk_type: the type of disk you want to create. This value uses the following format:
            "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "zones/us-west3-b/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        snapshot_link: a link to the snapshot you want to use as a source for the new disk.
            This value uses the following format: "projects/{project_name}/global/snapshots/{snapshot_name}"

    Returns:
        An unattached Disk instance.
    """
    disk_client = compute_v1.DisksClient()
    disk = compute_v1.Disk()
    disk.zone = zone
    disk.size_gb = disk_size_gb
    disk.source_snapshot = snapshot_link
    disk.type_ = disk_type
    disk.name = disk_name
    operation = disk_client.insert(project=project_id, zone=zone, disk_resource=disk)

    wait_for_extended_operation(operation, "disk creation")

    return disk_client.get(project=project_id, zone=zone, disk=disk_name)

Monte o disco

No terminal, use o comando lsblk para listar os discos anexados à sua instância e encontrar o disco que quer montar.

$ sudo lsblk

NAME   MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda      8:0    0   10G  0 disk
└─sda1   8:1    0   10G  0 part /
sdb      8:16   0  250G  0 disk

Neste exemplo, sdb é o nome do dispositivo para o novo disco persistente em branco.

Use a ferramenta de montagem para montar o disco na instância e ative a opção discard:
```
$ sudo mount -o discard,defaults /dev/DEVICE_NAME /home/jupyter
```
Substitua o seguinte:
- DEVICE_NAME: o nome do dispositivo do disco a montar.
Configure as autorizações de leitura e escrita no disco. Para este exemplo, conceda acesso de escrita ao disco a todos os utilizadores.
```
$ sudo chmod a+w /home/jupyter
```

O que se segue?

Saiba como guardar um bloco de notas no GitHub
Saiba mais acerca da criação de instantâneos.
Saiba mais acerca da programação de resumos.