Esta página foi traduzida pela API Cloud Translation.

Criar snapshots de arquivo e de disco padrão

Crie snapshots padrão para fazer backup periódico dos dados desses tipos de discos:

É 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 VM no mesmo projeto. Também é possível compartilhar snapshots entre projetos.

Antes de começar

Configure a autenticação, caso ainda não tenha feito isso. A autenticação é o processo de verificação da sua identidade para acesso a serviços e APIs do Google Cloud. Para executar códigos ou amostras de um ambiente de desenvolvimento local, autentique-se no Compute Engine selecionando uma das seguintes opções:

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

When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.
gcloud
1. Install the Google Cloud CLI, then initialize it by running the following command:
  gcloud init
  Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
2. Set a default region and zone.

Papéis e permissões necessárias

Para receber as permissões necessárias para criar um snapshot padrão, peça ao administrador para conceder a você os seguintes papéis do IAM no projeto:

Administrador da instância da computação (v1) (roles/compute.instanceAdmin.v1)
Para se conectar a uma VM que pode ser executada como uma conta de serviço: Usuário da conta de serviço (v1) (roles/iam.serviceAccountUser)

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esses papéis predefinidos contêm as permissões necessárias para criar um snapshot padrão. Para conferir as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As seguintes permissões são necessárias para criar um snapshot padrão:

Para criar um snapshot de um disco zonal:
- compute.snapshots.create no projeto
- compute.disks.createSnapshot no disco
Para criar um snapshot de um disco regional usando os dados dele:
- compute.snapshots.create no projeto
- compute.instances.useReadOnly na VM de origem
- compute.disks.createSnapshot no disco
Para criar um snapshot de um disco regional usando um checkpoint de recuperação de réplica:
- compute.snapshots.create no projeto
- compute.disks.createSnapshot no disco

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

Preparar para a criação de snapshots

Para se preparar para criar snapshots do Persistent Disk ou Hyperdisk, faça o seguinte:

Consulte as Práticas recomendadas para snapshots de discos do Compute Engine para preparar o disco para a criação do snapshot.
Para personalizar o local de armazenamento padrão de todos os novos snapshots, atualize as configurações de snapshot do projeto (pré-lançamento). O Google Cloud mantém um valor de local de armazenamento padrão predefinido até que você atualize as configurações de snapshot pela primeira vez. Esse local predefinido é a multirregião mais próxima do disco de origem.
Leia Criar programações para snapshots de disco para saber como criar uma programação de snapshot e anexá-la aos discos. Fazer backup dos discos regularmente com snapshots programados pode reduzir o risco de perda inesperada de dados.
Não é possível criar um snapshot de um volume do Hyperdisk que esteja no modo de vários gravadores. Desative o modo de vários gravadores para o disco e crie o snapshot.

Criar um snapshot do volume do Persistent Disk

As instruções para criar snapshots de volumes do Persistent Disk são diferentes se você estiver criando um snapshot do Persistent Disk zonal ou regional.

Crie um snapshot de um volume do Persistent Disk zonal

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 que passará pelo 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 de dados anexado, em Discos adicionais, clique no Nome do disco.
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-data-disk-snapshot
Em Tipo, o padrão é um snapshot padrão. Os snapshots padrão são ideal para backup de longo prazo e recuperação de desastres.
Escolha Snapshot de arquivamento para criar um backup mais econômico que os snapshots padrão, mas com um tempo de recuperação de dados maior.

Para mais informações, consulte Comparação entre os tipos de snapshots.
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 seu disco de origem, escolha um local na seção Com base no local do disco.
Para criar um snapshot, clique em Criar.

gcloud

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

Para criar um snapshot no local padrão predefinido ou personalizado definido nas configurações do snapshot, use o comando gcloud compute snapshots create.

gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-zone=SOURCE_ZONE \
    --source-disk=SOURCE_DISK_NAME \
    --snapshot-type=SNAPSHOT_TYPE

Como alternativa, para substituir as configurações de snapshot e criar um snapshot em um local de armazenamento personalizado, inclua a flag --storage-location para indicar onde ele deve ser armazenado:
```
gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-zone=SOURCE_ZONE \
    --source-disk=SOURCE_DISK_NAME \
    --snapshot-type=SNAPSHOT_TYPE \
    --storage-location=STORAGE_LOCATION
```
Substitua:
- SNAPSHOT_NAME: um nome para o snapshot.
- SOURCE_ZONE: a zona do disco de origem.
- SOURCE_DISK_NAME: o nome do volume do Persistent Disk que será a base para a criação do snapshot.
- SNAPSHOT_TYPE: o tipo de snapshot, que é STANDARD ou ARCHIVE. Se um tipo de snapshot não for especificado, um snapshot STANDARD será criado.
- STORAGE_LOCATION (opcional): a multirregião do Cloud Storage ou a região do Cloud Storage onde você quer armazenar o snapshot. É possível especificar apenas um local de armazenamento.
  
  Use o parâmetro --storage-location somente quando quiser substituir o local de armazenamento padrão predefinido ou personalizado que está definido nas configurações de snapshot.
Observação: o Google recomenda usar o comando gcloud compute snapshots create no lugar 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 Persistent Disk 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.

Go

Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido do Compute Engine: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Go do Compute Engine.

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 esta amostra, siga as instruções de configuração do Java no Guia de início rápido do Compute Engine: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Java do Compute Engine.

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 esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido do Compute Engine: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Node.js do Compute Engine.

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 esta amostra, siga as instruções de configuração do Python no Guia de início rápido do Compute Engine: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Python do Compute Engine.

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)

REST

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

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 ao 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 volume do Persistent Disk que será a base para a criação do snapshot.
SNAPSHOT_TYPE: o tipo de snapshot, que é STANDARD ou ARCHIVE. Se um tipo de snapshot não for especificado, um snapshot STANDARD será criado.
STORAGE_LOCATION (opcional): a multirregião do Cloud Storage ou a região do Cloud Storage onde 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.

Observação: o Google recomenda usar o método snapshots.insert em vez do método disks.createSnapshot porque ele é compatível com mais recursos, como a criação de snapshots em um projeto diferente do projeto do disco de origem.

Crie um snapshot de um volume do Persistent Disk regional

É possível criar snapshots do volume do Persistent Disk regional de uma das seguintes maneiras:

Usando os dados que estão no disco de origem. Para usar esse método de criação de snapshot, é necessário ter uma réplica zonal sincronizada disponível.
Usando o checkpoint de recuperação de réplica de um disco degradado. Só é possível criar snapshots de um checkpoint usando a CLI do Google Cloud ou REST.

Depois de preparar o disco, é possível criar um snapshot. Ao criar um snapshot de um Persistent Disk regional, você precisa indicar a região onde o disco está localizado.

Console

Acesse a página Criar um snapshot no console do Google Cloud.
Acessar a página "Criar um snapshot"
Digite um Nome de snapshot.
Selecione um Tipo de snapshot. O snapshot padrão é STANDARD, que é a melhor opção para backup de longo prazo e recuperação de desastres.

Escolha Snapshot do arquivo para uma retenção de dados mais econômica.
Opcional: insira uma Descrição sobre o snapshot.
Em Disco de origem, selecione o disco do qual você quer criar um snapshot.
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 por um custo mais alto.
  - Escolha Snapshots regionais para ter mais controle sobre a localização física dos dados por 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.
Clique em Criar para criar o snapshot.

gcloud

Crie um snapshot usando os dados do disco de origem ou o checkpoint de recuperação da réplica.

Com dados do disco

Crie um snapshot com base nos dados do disco 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.

Para criar um snapshot no local padrão predefinido ou personalizado definido nas configurações do snapshot, use o comando gcloud compute snapshots create.

gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-region=SOURCE_REGION \
    --source-disk=SOURCE_DISK_NAME \
    --snapshot-type=SNAPSHOT_TYPE

Como alternativa, para substituir as configurações de snapshot e criar um snapshot em um local de armazenamento personalizado, inclua a flag --storage-location para indicar onde ele deve ser armazenado:
```
gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-region=SOURCE_REGION \
    --source-disk=SOURCE_DISK_NAME \
    --snapshot-type=SNAPSHOT_TYPE \
    --storage-location=STORAGE_LOCATION
```
Substitua:
- SNAPSHOT_NAME: um nome para o snapshot.
- SOURCE_REGION: a região do disco de origem.
- SOURCE_DISK_NAME: o nome do disco permanente regional ou do volume do Hyperdisk Balanced High Availability a partir do qual você quer criar um snapshot.
- SNAPSHOT_TYPE: o tipo de snapshot, que é STANDARD ou ARCHIVE. Se um tipo de snapshot não for especificado, um snapshot STANDARD será criado.
- STORAGE_LOCATION (opcional): a multirregião do Cloud Storage ou a região do Cloud Storage onde você quer armazenar o snapshot. É possível especificar apenas um local de armazenamento.
  
  Use o parâmetro --storage-location somente quando quiser substituir o local de armazenamento padrão predefinido ou personalizado que está definido nas configurações de snapshot.
Observação: o Google recomenda usar o comando gcloud compute snapshots create no lugar 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.

Com o checkpoint

É possível criar o snapshot usando o checkpoint de recuperação de réplica (pré-lançamento) de um disco degradado. O snapshot será criado se a réplica incompleta estiver disponível.

Para criar um snapshot usando o checkpoint de recuperação de réplica, use o comando gcloud compute snapshots create . Inclua a flag --source-disk-for-recovery-checkpoint para especificar que você quer criar o snapshot usando um checkpoint de recuperação de réplica. Exclua os parâmetros --source-disk e --source-disk-region.

gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-for-recovery-checkpoint=SOURCE_DISK \
    --source-disk-for-recovery-checkpoint-region=SOURCE_REGION \
    --storage-location=STORAGE_LOCATION \
    --snapshot-type=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 do disco de origem com o checkpoint que você quer usar para criar o snapshot.
SOURCE_REGION: a região do disco de origem que tem o checkpoint que você quer usar para criar o snapshot.
SOURCE_DISK_NAME: o nome do disco de origem que tem o checkpoint que você quer usar para criar o snapshot.
STORAGE_LOCATION (opcional): 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 a flag apenas quando quiser substituir o local de armazenamento padrão predefinido ou personalizado que está definido nas configurações de 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.

Somente no caso de discos degradados é possível usar o checkpoint de recuperação da réplica para criar um snapshot. Se você tentar criar um snapshot com base em um checkpoint de recuperação de réplica quando o dispositivo estiver totalmente replicado, a seguinte mensagem de erro será exibida:

The device is fully replicated and should not create snapshots out of a recovery checkpoint. Please
create regular snapshots instead.

A CLI do Google Cloud aguarda até que um status READY ou FAILED seja retornado ou retorna os últimos detalhes conhecidos do snapshot após o tempo limite máximo ter se esgotado.

Terraform

O provedor do Terraform para o Google Cloud não é compatível com a criação de um snapshot de um Persistent Disk regional. Para acompanhar essa limitação, consulte o problema no GitHub.

Go

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

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

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

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)

REST

Crie um snapshot usando os dados do disco de origem ou o checkpoint de recuperação da réplica.

Com dados do disco

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/regions/SOURCE_REGION/disks/SOURCE_DISK_NAME",
  "snapshotType": "SNAPSHOT_TYPE"
}

POST https://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/global/snapshots
{
  "name": "SNAPSHOT_NAME",
  "sourceDisk": "projects/SOURCE_PROJECT_ID/regions/SOURCE_REGION/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_REGION: a região do disco de origem.
SOURCE_DISK_NAME: o nome do disco permanente regional ou do volume do Hyperdisk Balanced High Availability a partir do qual você quer criar um snapshot.
SNAPSHOT_TYPE: o tipo de snapshot, que é STANDARD ou ARCHIVE. Se um tipo de snapshot não for especificado, um snapshot STANDARD será criado.
STORAGE_LOCATION (opcional): a multirregião do Cloud Storage ou a região do Cloud Storage onde 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.

Com o checkpoint

Como alternativa, é possível criar o snapshot usando o checkpoint de recuperação de réplica de um disco degradado. O snapshot será criado se a réplica incompleta estiver disponível.

Para criar um snapshot usando o checkpoint de recuperação da réplica, faça uma solicitação POST para o método snapshots.insert. Exclua o parâmetro sourceDisk e inclua o parâmetro sourceDiskForRecoveryCheckpoint para especificar que você quer criar o snapshot com base no checkpoint.

POST https://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/global/snapshots

{
  "name": "SNAPSHOT_NAME",
  "sourceDiskForRecoveryCheckpoint": "projects/SOURCE_PROJECT_ID/regions/SOURCE_REGION/disks/SOURCE_DISK_NAME",
  "storageLocations": "STORAGE_LOCATION",
  "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 do disco de origem com o checkpoint que você quer usar para criar o snapshot.
SOURCE_REGION: a região do disco de origem que tem o checkpoint que você quer usar para criar o snapshot.
SOURCE_DISK_NAME: o nome do disco de origem que tem o checkpoint que você quer usar para criar o snapshot.
STORAGE_LOCATION (opcional): 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.
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.

The device is fully replicated and should not create snapshots out of a recovery checkpoint. Please
create regular snapshots instead.

Criar um snapshot de um hiperdisco

Console

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

Acessar instâncias de VM
Selecione o projeto que contém suas instâncias de VM.
Na coluna Nome, clique no nome da VM que tem o Hyperdisk para fazer backup.
Em Armazenamento, em Discos adicionais, clique no Nome do Hyperdisk anexado.
Clique em Criar snapshot.
Em Nome, insira um nome exclusivo para ajudar a identificar o propósito do snapshot, por exemplo hyperdisk-data-snapshot.
Em Tipo, o padrão é um snapshot regular, que é melhor para backup a longo prazo e recuperação de desastres.
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 ter mais controle sobre a localização física dos dados por 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.
Clique em Criar.

gcloud

É 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 no local padrão predefinido ou personalizado definido nas configurações do snapshot, use o comando gcloud compute snapshots create.

gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-zone=SOURCE_ZONE \
    --source-disk=SOURCE_DISK_NAME \
    --snapshot-type=SNAPSHOT_TYPE

Como alternativa, para substituir as configurações de snapshot e criar um snapshot em um local de armazenamento personalizado, inclua a flag --storage-location para indicar onde ele deve ser armazenado:
```
gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-zone=SOURCE_ZONE \
    --source-disk=SOURCE_DISK_NAME \
    --snapshot-type=SNAPSHOT_TYPE \
    --storage-location=STORAGE_LOCATION
```
Substitua:
- SNAPSHOT_NAME: um nome para o snapshot.
- SOURCE_ZONE: a zona do disco de origem.
- SOURCE_DISK_NAME: o nome do volume de Hyperdisk a partir do qual você quer criar um snapshot.
- SNAPSHOT_TYPE: o tipo de snapshot, que é STANDARD ou ARCHIVE. Se um tipo de snapshot não for especificado, um snapshot STANDARD será criado.
- STORAGE_LOCATION (opcional): a multirregião do Cloud Storage ou a região do Cloud Storage onde você quer armazenar o snapshot. É possível especificar apenas um local de armazenamento.
  
  Use o parâmetro --storage-location somente quando quiser substituir o local de armazenamento padrão predefinido ou personalizado que está definido nas configurações de snapshot.
Observação: o Google recomenda usar o comando gcloud compute snapshots create no lugar 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.

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.

REST

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

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 volume de Hyperdisk a partir do qual você quer criar um snapshot.
SNAPSHOT_TYPE: o tipo de snapshot, que é STANDARD ou ARCHIVE. Se um tipo de snapshot não for especificado, um snapshot STANDARD será criado.
STORAGE_LOCATION (opcional): a multirregião do Cloud Storage ou a região do Cloud Storage onde 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.

A seguir

Saiba como criar snapshots programados para discos.
Saiba como visualizar, excluir e compartilhar snapshots de disco.
Saiba como criar uma imagem de disco com base no snapshot.