Fazer backup dos seus dados usando um snapshot

Nesta página, mostramos como fazer backup de dados armazenados na instância de notebooks gerenciados pelo usuário do Vertex AI Workbench criando um snapshot.

Os dados da instância são armazenados em um disco permanente zonal. É possível criar e usar snapshots desse disco para fazer backup de dados, criar uma programação de backup recorrente e restaurar dados para uma nova instância.

Criar um snapshot

É possível criar snapshots com base em discos, mesmo quando estão anexados a instâncias em execução. Os snapshots são recursos globais. Por isso, podem ser usados para restaurar dados em um novo disco ou instância no mesmo projeto. Também é possível compartilhar snapshots entre projetos.

Permissões exigidas para a tarefa

Para executar essa tarefa, é necessário ter permissões:

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

Console

No console do Google Cloud, acesse a página Instâncias de VMs.

Acessar instâncias de VM
As etapas restantes serão exibidas automaticamente no console do Google Cloud.
Selecione o projeto que contém suas instâncias de VM.
Na coluna Nome, clique no nome da VM que tem o disco permanente para fazer backup.
Em Armazenamento:
- Para fazer backup do disco de inicialização, na seção Disco de inicialização, clique no Nome do disco.
- Para fazer backup de um disco permanente anexado, em Discos extras, clique no Nome do disco permanente anexado.
Clique em Criar snapshot.
Em Nome, insira um nome exclusivo para ajudar a identificar o propósito do snapshot, por exemplo:
- boot-disk-snapshot
- attached-persistent-disk-snapshot
Em Tipo, o padrão é um snapshot regular, que é melhor para backup a longo prazo e recuperação de desastres.
Escolha Snapshot do arquivo para uma retenção de dados mais econômica.
Na seção Local, escolha o local de armazenamento dos snapshots. O local padrão predefinido ou personalizado definido nas configurações de snapshot é selecionado automaticamente. Se preferir, modifique as configurações dos snapshots e os armazene em um local de armazenamento personalizado da seguinte forma:
1. Escolha o tipo de local de armazenamento que você quer para os snapshots.
  - Escolha Multirregional para maior disponibilidade a um custo mais alto.
  - Escolha Snapshots regionais para maior controle sobre a localização física dos dados a um custo menor.
2. No campo Selecionar local, escolha a região ou a multirregião específica que você quer usar. Para usar a região ou multirregião mais próxima do disco de origem, selecione Com base no local do disco.
Para criar um snapshot manual, 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 snapshot usando a política de local de armazenamento definida nas configurações de snapshot ou usando um local de armazenamento alternativo de sua escolha. Para mais informações, consulte Escolher o local de armazenamento dos snapshots. É necessário especificar um nome de snapshot. O nome precisa ter de um a 63 caracteres e estar de acordo com o RFC 1035.
- Para criar um snapshot de um volume de disco permanente no local padrão predefinido ou personalizado definido nas configurações de snapshot, 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
```
- Como alternativa, para substituir as configurações de snapshot e criar um snapshot em um local de armazenamento personalizado, inclua a flag --storage-location a fim de indicar onde ele deve ser armazenado:
```
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:
  - SNAPSHOT_NAME: um nome para o snapshot.
  - SOURCE_DISK: o nome do volume de disco permanente zonal com base no qual você quer criar um snapshot.
  - SNAPSHOT_TYPE: o tipo de snapshot que pode ser STANDARD ou ARCHIVE. Se um tipo de snapshot não for especificado, um snapshot STANDARD será criado. Escolha "Arquivo' para uma retenção de dados mais econômica.
  - SOURCE_DISK_ZONE: a zona do volume de disco permanente zonal com base na qual você quer criar um snapshot.
  - STORAGE_LOCATION: para locais de armazenamento personalizados, é a multirregião do Cloud Storage ou a região do Cloud Storage em que você quer armazenar snapshots. É possível especificar apenas um local de armazenamento.
  Use a flag --storage-location apenas quando quiser substituir o local de armazenamento padrão predefinido ou personalizado que está definido nas configurações de snapshot.
O CLI gcloud aguarda até que um status READY ou FAILED seja retornado pela operação ou até o tempo limite ser atingido e os últimos detalhes conhecidos do instantâneo serem retornados.
Observação: o Google recomenda o uso do comando gcloud compute snapshots create em vez do comando gcloud compute disks snapshot porque ele é compatível com mais recursos, como a criação de snapshots em um projeto diferente do projeto do disco de origem.

Terraform

Para criar um snapshot do disco permanente 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 Comandos básicos do Terraform.

API

Crie o snapshot na política de local de armazenamento definida pelas configurações de snapshot ou use um local de armazenamento alternativo de sua escolha. Para mais informações, consulte Escolher o local de armazenamento dos snapshots.

Para criar o snapshot no local padrão predefinido ou personalizado configurado nas configurações de snapshot, faça uma solicitação POST para o 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:
- DESTINATION_PROJECT_ID: o ID do projeto em que você quer criar o snapshot.
- SNAPSHOT_NAME: um nome para o snapshot.
- SOURCE_PROJECT_ID: o ID do projeto de disco de origem.
- SOURCE_ZONE: a zona do disco de origem.
- SOURCE_DISK_NAME: o nome do disco permanente do qual você quer criar um snapshot.
- SNAPSHOT_TYPE: o tipo de snapshot, que é PADRÃO ou ARCHIVE. Se um tipo de snapshot não for especificado, um snapshot PADRÃO será criado.
Como alternativa, para substituir as configurações de snapshot e criar um snapshot em um local de armazenamento personalizado, faça uma solicitação POST para o método snapshots.insert e inclua nela a propriedade storageLocations:
```
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:
- DESTINATION_PROJECT_ID: o ID do projeto em que você quer criar o snapshot.
- SNAPSHOT_NAME: um nome para o snapshot.
- SOURCE_PROJECT_ID: o ID do projeto de disco de origem.
- SOURCE_ZONE: a zona do disco de origem.
- SOURCE_DISK_NAME: o nome do disco permanente do qual você quer criar um snapshot.
- SNAPSHOT_TYPE: o tipo de snapshot, que é PADRÃO ou ARCHIVE. Se um tipo de snapshot não for especificado, um snapshot STANDARD será criado.
- STORAGE_LOCATION: a multirregião do Cloud Storage ou a região do Cloud Storage em que você quer armazenar o snapshot. É possível especificar apenas um local de armazenamento.
  
  Use o parâmetro storageLocations somente quando quiser substituir o local de armazenamento padrão predefinido ou personalizado que está definido nas configurações de snapshot.

Go

Antes de testar a amostra, siga as instruções de configuração no Guia de início rápido do Compute Engine: como usar bibliotecas de cliente.

Para autenticar-se no Compute Engine, configure o Application Default Credentials. Para mais informações, consulte Configurar 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 testar a amostra, siga as instruções de configuração no Guia de início rápido do Compute Engine: como usar bibliotecas de cliente.

Para autenticar-se no Compute Engine, configure o Application Default Credentials. Para mais informações, consulte Configurar 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 testar a amostra, siga as instruções de configuração no Guia de início rápido do Compute Engine: como usar bibliotecas de cliente.

Para autenticar-se no Compute Engine, configure o Application Default Credentials. Para mais informações, consulte Configurar 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 testar a amostra, siga as instruções de configuração no Guia de início rápido do Compute Engine: como usar bibliotecas de cliente.

Para autenticar-se no Compute Engine, configure o Application Default Credentials. Para mais informações, consulte Configurar 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)

Programar um backup recorrente

Ao criar uma programação de snapshot, é possível criar uma política de recursos que pode ser aplicada a um ou mais discos permanentes. É possível criar programações de snapshots das seguintes maneiras:

Uma programação de snapshot inclui as seguintes propriedades:

Nome da programação
Descrição da programação
Frequência de snapshots (por hora, dia, semana)
Horário de início do snapshot
Região em que a programação de snapshot está disponível
Política de exclusão de disco de origem para processar snapshots gerados automaticamente se o disco de origem for excluído
Política de retenção para definir por quanto tempo os snapshots gerados com base na programação serão mantidos.

Restrições

Um disco permanente pode ter no máximo 10 programações de snapshots anexadas por vez.
Não é possível criar snapshots do arquivo usando uma programação de snapshot.
É possível criar no máximo 1.000 programações de snapshots em uso por região.
As programações de snapshot se aplicam somente ao projeto em que foram criadas. As programações de snapshot não podem ser usadas em outros projetos ou organizações.
Talvez seja necessário solicitar um aumento na cota de recursos por meio do Console, se você precisar de mais recursos em sua região.
Não é possível excluir uma programação de snapshot anexada a um disco. Primeiro, desanexe a programação de todos os discos e, em seguida, a exclua.
É possível atualizar uma programação de snapshot atual para alterar a descrição, a programação e os rótulos. Para atualizar outros valores de uma programação de snapshot, é preciso excluir a programação de snapshot e criar uma nova.
Para discos permanentes que usam uma chave de criptografia fornecida pelo cliente (CSEK), não é possível criar programações de snapshot.
Para discos permanentes que usam uma chave de criptografia gerenciada pelo cliente (CMEK), todos os snapshots criados com uma programação são criptografados automaticamente com a mesma chave.

Criar uma programação

Permissões exigidas para a tarefa

Para executar esta tarefa, é necessário ter as seguintes permissões:

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

Crie uma programação de snapshots para seus discos permanentes usando o Console do Google Cloud, a Google Cloud CLI ou a API do Compute Engine. Crie a programação de snapshot na mesma região do disco permanente. Por exemplo, se o disco permanente estiver na zona us-west1-a, a programação de snapshot precisará estar na região us-west1. Para mais informações, consulte Escolher um local de armazenamento.

Console

No console do Google Cloud, acesse a página Instâncias de VMs.

Acessar instâncias de VM
As etapas restantes serão exibidas automaticamente no console do Google Cloud.
Selecione o projeto que contém suas instâncias de VM.
Na coluna Nome, clique no nome da VM que tem o disco permanente para criar uma programação de snapshot para ele.
Em Armazenamento, clique no nome do Disco de inicialização ou do Disco extra para criar uma programação de snapshot para ele.
Clique em Editar. Talvez seja necessário clicar no menu Mais ações e em Editar.
Em Programação de snapshot, escolha Criar uma programação.
Em Nome, insira um dos seguintes nomes para a programação de snapshot:
- boot-disk-snapshot-schedule
- attached-persistent-disk-snapshot-schedule
Na seção Local, escolha o local de armazenamento dos snapshots. O local padrão predefinido ou personalizado que está definido nas configurações de snapshot é selecionado automaticamente. Se preferir, substitua as configurações dos snapshots e os armazene em um local de armazenamento personalizado da seguinte forma:
1. Escolha o tipo de local de armazenamento que você quer para os snapshots.
  - Escolha Multirregional para maior disponibilidade a um custo mais alto.
  - Escolha Snapshots regionais para maior controle sobre a localização física dos dados a um custo menor.
2. No campo Selecionar local, escolha a região ou multirregião específica que você quer usar. Para usar a região ou multirregião mais próxima do disco de origem, selecione Com base no local do disco.
Para concluir a criação da programação de snapshot, clique em Criar.
Para anexar essa programação de snapshot ao disco permanente, clique em Salvar.

gcloud

Para criar uma programação de snapshot para discos permanentes, use o comando compute resource-policies create snapshot-schedule da gcloud. Defina a frequência da programação por hora, dia ou semana.

  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]

em que:

[SCHEDULE_NAME] é o nome da nova programação de snapshot;
"[SCHEDULE_DESCRIPTION]" é uma descrição da programação do snapshot. Coloque a descrição entre aspas;
[MAX_RETENTION_DAYS] é o número de dias de retenção do snapshot. Por exemplo, a configuração de 3 significa que os snapshots serão mantidos por três dias antes de serem excluídos. Defina uma política de retenção de pelo menos um dia.
[START_TIME] é o horário de início em UTC. O horário precisa ser uma hora redonda. Por exemplo:
- 14h PST é 22:00.
- Se você definir o horário de início como 22:13, receberá um erro.
[SNAPSHOT_INTERVAL] define o intervalo da captura de instantâneo. Defina a programação por hora usando um número inteiro entre 1 e 23. Escolha um número de hora que seja divisor de 24. Por exemplo, defina --hourly-schedule como 12 para que o snapshot seja gerado a cada 12 horas. Para uma programação por semana, defina em que dias você quer que ocorra a captura de snapshot. Escreva os dias da semana por extenso. Eles não diferenciam entre letras maiúsculas e minúsculas. As sinalizações de frequência do snapshot hourly-schedule, daily-schedule e weekly-schedule são mutuamente exclusivas. É necessário escolher uma para a programação de snapshot.

Observação: para especificar uma programação semanal com dias diferentes da semana e horários de início diferentes, use --weekly-schedule-from-file.
[FILE_NAME] é o nome de arquivo que contém a programação de snapshot semanal, caso você especifique a programação nesse formato. É possível especificar programações semanais em dias diferentes da semana e em horários distintos usando um arquivo, mas não é possível especificar várias programações semanais diretamente na linha de comando. Por exemplo, seu arquivo pode especificar uma programação de snapshot às segundas e quartas-feiras: [{"day": "MONDAY", "startTime": "04:00"}, {"day": "WEDNESDAY", "startTime": "02:00"}]. Se você incluir um horário de início no arquivo, não será necessário definir a sinalização --start-time. A programação usa o padrão de hora UTC.
[DELETION_OPTION] determina o que acontecerá com os snapshots se o disco de origem for excluído. Omita essa sinalização para escolher o padrão keep-auto-snapshots ou use apply-retention-policy para aplicar uma política de retenção.

Veja a seguir mais exemplos de configuração de uma programação de snapshot. Veja o que há em comum em todos os exemplos abaixo:

A regra de exclusão de disco está incluída. A sinalização --on-source-disk-delete está definida como o padrão keep-auto-snapshots para manter permanentemente todos os snapshots gerados automaticamente. A alternativa é definir essa sinalização como apply-retention-policy para usar sua política de retenção de snapshots.
O local de armazenamento está definido como US para que todos os snapshots gerados sejam armazenados na multirregião US.
Os rótulos env=dev e media=images estão aplicados a todos os snapshots gerados.
A política de retenção está definida como 10 dias.

Programação por hora: neste exemplo, a programação de snapshot começa às 22h UTC e ocorre a cada quatro 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

Programação diária: neste exemplo, a programação de snapshot começa às 22h UTC e ocorre todos os dias na mesma hora. A sinalização --daily-schedule precisa estar presente, mas sem nada 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

Programação por semana: neste exemplo, a programação de snapshot começa às 22h UTC e ocorre toda semana à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 uma solicitação POST para resourcePolicies.insert para criar uma programação de snapshot. No mínimo, inclua o nome da programação, o local regional do armazenamento e a frequência do snapshot.

Por padrão, o parâmetro onSourceDiskDelete está definido como keepAutoSnapshots. Isso significa que, se o disco de origem for excluído, o respectivo snapshot gerado automaticamente será mantido por tempo indefinido. Como alternativa, defina a sinalização como applyRetentionPolicy para aplicar sua política de retenção.

No exemplo a seguir, uma programação de snapshot diária que começa às 12h UTC e se repete todos os dias está definida. No exemplo, uma política de retenção de cinco dias também está definida. Após esse período, os snapshots serão removidos automaticamente.

Também é possível incluir opções de localidade de snapshot e rótulos de snapshot na solicitação para garantir que eles sejam armazenados no local que você escolheu.

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

em que:

[PROJECT_ID] é o nome do projeto;
[REGION] é o local da política de recursos de programação de snapshot.
[SCHEDULE_DESCRIPTION] é a descrição da programação de snapshot;
[SCHEDULE_NAME] é o nome da programação de snapshot.

É possível criar uma programação por semana ou por mês do mesmo modo. Consulte a referência da API para detalhes específicos sobre como definir uma programação semanal ou mensal.

Por exemplo, na solicitação a seguir, uma programação semanal é criada e executada às terças e quintas, às 9h e às 2h, respectivamente.

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

Anexar uma programação de snapshot a um disco

Permissões exigidas para a tarefa

Para executar essa tarefa, é necessário ter as permissões a seguir:

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

Após a criação da programação, anexe-a a um disco atual. Use o console, o comando gcloud ou o método da API Compute Engine.

Console

Anexe uma programação de snapshot a um disco atual.

No Console do Google Cloud, acesse a página Discos.
Acesse a página Discos
Selecione o nome do disco ao qual você quer anexar uma programação de snapshot. Isso abre a página Gerenciar disco.
Na página Gerenciar disco passe o cursor e clique no menu Mais ações e selecione Editar.
Use o menu suspenso Programação de instantâneo para adicionar a programação ao disco. Se preferir, crie uma nova programação.
Se você criou uma nova programação, clique em Criar.
Clique em Salvar para concluir a tarefa.

gcloud

Para anexar uma programação de snapshot a um disco, use o comando disks add-resource-policies da gcloud.

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

onde:

[DISK_NAME] é o nome do disco atual;
[SCHEDULE_NAME] é o nome da programação de snapshot;
[ZONE] é o local do disco.

API

Na API, crie uma solicitação POST para disks.addResourcePolicies para anexar uma programação de snapshot a um disco atual.

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

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

onde:

[PROJECT_ID] é o nome do projeto;
[ZONE] é o local do disco;
[REGION] é o local da programação de snapshot;
[DISK_NAME] é o nome do disco;
[SCHEDULE_NAME] é o nome da programação de snapshot na região que você está aplicando a esse disco.

Restaurar dados de um snapshot

Se você fez backup de um disco de inicialização ou não com um snapshot, é possível criar um novo disco com base no snapshot.

Restrições

O novo disco permanente precisa ter pelo menos o mesmo tamanho do disco de origem para aceitar o snapshot. Se você criar um disco permanente maior que o disco de origem do snapshot, será preciso redimensionar o sistema de arquivos nesse disco permanente para incluir o espaço em disco adicional. Dependendo do sistema operacional e do tipo de sistema de arquivos, talvez seja preciso usar uma ferramenta de redimensionamento de sistema de arquivos diferente. Para mais informações, consulte a documentação do sistema operacional.

Criar um disco com base em um snapshot e anexá-lo a uma VM

Permissões exigidas para a tarefa

Para executar essa tarefa, é necessário ter as permissões a seguir:

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

Console

No console do Google Cloud, acesse a página Snapshots.

Acesse Snapshots
Encontre o nome do snapshot que você quer restaurar.
Acessar a página Discos.

Acessar a 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, é possível modificar a seleção de região e zona padrão. É possível selecionar qualquer região e zona, independentemente do local de armazenamento do snapshot de origem.
Em Tipo de origem, clique em Snapshot.
Selecione o nome do snapshot que será restaurado.
Selecione o tamanho do novo disco em gigabytes. Esse número precisa ser igual ou maior que o disco de origem do snapshot.
Clique em Criar para criar o disco.

Anexe o novo disco a uma instância atual.

Acesse a página Instâncias da VM.
Acessar a página "Instâncias de VM"
Clique no nome da instância em que você quer restaurar o disco não inicializável.
No início da página, clique em Editar.
Em Discos extras, clique em Anexar disco atual.
Selecione o nome do novo disco criado a partir do snapshot.
Clique em Concluído para anexar o disco.
Na parte inferior da página de detalhes da instância, clique em Salvar para aplicar as alterações à instância.

gcloud

Use o comando gcloud compute snapshots list para encontrar o nome do snapshot que você quer restaurar:
```
gcloud compute snapshots list
```
Use o comando gcloud compute snapshots describe para encontrar o tamanho do snapshot que você quer restaurar:
```
gcloud compute snapshots describe SNAPSHOT_NAME
```
Substitua SNAPSHOT_NAME pelo nome do snapshot que está sendo restaurado.
Use o comando gcloud compute disks create para criar um novo disco regional ou zonal a partir do snapshot. Se você precisar de um disco permanente SSD para aumentar a capacidade ou IOPS, inclua a sinalização --type e especifique pd-ssd.
```
gcloud compute disks create DISK_NAME \
    --size=DISK_SIZE \
    --source-snapshot=SNAPSHOT_NAME \
    --type=DISK_TYPE
```
Substitua:
- DISK_NAME: o nome do novo disco.
- DISK_SIZE: o tamanho do novo disco em gigabytes. Esse número precisa ser igual ou maior que o disco de origem do snapshot.
- SNAPSHOT_NAME: o nome do snapshot que está sendo restaurado.
- DISK_TYPE: URL completo ou parcial do tipo do disco permanente. Por exemplo, https://www.googleapis.com/compute/v1/projects/PROJECT_ID /zones/ZONE/diskTypes/pd-ssd.
Anexe o novo disco a uma instância atual usando o comando gcloud compute instances attach-disk:
```
gcloud compute instances attach-disk INSTANCE_NAME \
    --disk DISK_NAME
```
Substitua:
- INSTANCE_NAME é o nome da instância.
- DISK_NAME é o nome do disco criado a partir do snapshot.

API

Crie uma solicitação GET para snapshots.list para exibir a lista de snapshots no projeto.

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

Substitua PROJECT_ID pela ID do seu projeto.
Elabore uma solicitação POST para criar um disco zonal usando o método disks.insert. Inclua as propriedades name, sizeGb e type. Para restaurar um disco usando um snapshot, é preciso 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:
- PROJECT_ID: o ID do projeto.
- ZONE a zona em que a 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. Esse número precisa ser igual ou maior que o disco de origem do snapshot.
- DISK_TYPE: URL completo ou parcial do tipo do disco permanente. Exemplo:https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ ZONE/diskTypes/pd-ssd.
- SNAPSHOT_NAME: o snapshot de origem do disco que você está restaurando.
Também é possível anexar o novo disco a uma instância atual criando uma solicitação POST para o método instances.attachDisk e incluindo o URL para o disco zonal que você acabou de criar com base no snapshot.
```
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:
- PROJECT_ID é o ID do projeto.
- ZONE é a zona em que a instância e o novo disco estão localizados;
- INSTANCE_NAME é o nome da instância em que você está adicionando o novo disco;
- DISK_NAME é o nome do novo disco.

Go

Antes de testar esse exemplo, siga as instruções de configuração para Go no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Go.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar 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 testar esse exemplo, siga as instruções de configuração para Java no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Java.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar 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 testar esse exemplo, siga as instruções de configuração para Node.js no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Node.js.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar 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 o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Para mais informações, consulte a documentação de referência da API Python.

from __future__ import annotations

import sys
from typing import Any

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

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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result

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

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

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

    wait_for_extended_operation(operation, "disk creation")

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

Montar o disco

No terminal, use o comando lsblk para listar os discos anexados à instância e localizar aquele que você quer formatar e 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 permanente em branco.
Use a ferramenta mount para montar o disco na instância e ative a opção discard:
```
$ sudo mount -o discard,defaults /dev/DEVICE_NAME /home/jupyter
```
Substitua:
- DEVICE_NAME: o nome do dispositivo do disco a ser montado.
Configure as permissões de leitura e gravação no disco. Neste exemplo, conceda acesso de gravação no dispositivo a todos os usuários:
```
$ sudo chmod a+w /home/jupyter
```

A seguir

Saiba como salvar um notebook no GitHub
Saiba mais sobre criar snapshots.
Saiba mais sobre programar snapshots.