Esta página foi traduzida pela API Cloud Translation.

Crie instantâneos de disco padrão e de arquivo

Crie cópias instantâneas padrão para fazer cópias de segurança periódicas dos dados dos volumes de discos persistentes zonais e regionais e do Google Cloud Hyperdisk.

Pode criar instantâneos a partir de discos, mesmo quando estão anexados a instâncias em execução. Por predefinição, as capturas de ecrã são recursos globais, pelo que pode usá-las para restaurar dados num novo disco ou VM no mesmo projeto. Para proteção de dados adicional e gestão de custos, pode controlar onde pode usar os seus instantâneos para criar novos discos. Para restringir as regiões onde pode restaurar dados de instantâneos, pode criar um instantâneo com âmbito regional e definir localizações de acesso permitidas (pré-visualização). Também pode partilhar instantâneos entre projetos.

Antes de começar

(Pré-visualização) Para criar instantâneos com âmbito regional, defina as localizações de criação e restauro de instantâneos predefinidas antes de concluir os passos nesta página.
Se ainda não o tiver feito, configure a autenticação. A autenticação valida a sua identidade para aceder a Google Cloud serviços e APIs. Para executar código ou exemplos a partir de um ambiente de desenvolvimento local, pode autenticar-se no Compute Engine selecionando uma das seguintes opções:
Select the tab for how you plan to use the samples on this page:
Console

When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.
gcloud
1. Instale a CLI Google Cloud. Após a instalação, inicialize a CLI gcloud executando o seguinte comando:
  gcloud init
  Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.
  
  Nota: se instalou a CLI gcloud anteriormente, certifique-se de que tem a versão mais recente executando gcloud components update.
2. Set a default region and zone.
Terraform

Para usar os exemplos do Terraform nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as credenciais predefinidas da aplicação com as suas credenciais de utilizador.
Para mais informações, consulte Set up authentication for a local development environment.
Go

Para usar os Go exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.
Para mais informações, consulte Set up authentication for a local development environment.
Java

Para usar os Java exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.
Para mais informações, consulte Set up authentication for a local development environment.
Node.js

Para usar os Node.js exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.
Para mais informações, consulte Set up authentication for a local development environment.
Python

Para usar os Python exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.
Para mais informações, consulte Set up authentication for a local development environment.
REST

Para usar os exemplos da API REST nesta página num ambiente de desenvolvimento local, usa as credenciais que fornece à CLI gcloud.
Para mais informações, consulte o artigo Autenticar para usar REST na Google Cloud documentação de autenticação.

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

Para receber as autorizações de que precisa para criar uma captura de ecrã padrão, peça ao seu administrador para lhe conceder as seguintes funções de IAM no projeto:

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

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

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

Autorizações necessárias

São necessárias as seguintes autorizações para criar uma captura de ecrã padrão:

Para criar um instantâneo de um disco zonal:
- compute.snapshots.create
- compute.disks.createSnapshot
Para criar um instantâneo de um disco regional com os dados no disco:
- compute.snapshots.create
- compute.instances.useReadOnly
- compute.disks.createSnapshot
Para criar um instantâneo de um disco regional a partir de um ponto de verificação de recuperação de réplica:
- compute.snapshots.create
- compute.disks.createSnapshot
Para criar um instantâneo com âmbito regional (//cloud.google.com/products/#product-launch-stages">Preview)

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

Prepare-se para criar instantâneos

Para se preparar para criar instantâneos de volumes de discos persistentes ou Hyperdisk, faça o seguinte:

Reveja as práticas recomendadas para instantâneos de discos do Compute Engine para preparar o disco para a criação de instantâneos.
Se quiser personalizar a localização de armazenamento predefinida para todas as novas imagens instantâneas com âmbito global, atualize as definições de imagens instantâneas do seu projeto. Google Cloud mantém um valor de localização de armazenamento predefinido até atualizar as definições de imagens instantâneas pela primeira vez. Esta localização predefinida é a multirregião mais próxima do disco de origem.
Leia o artigo Crie programações para instantâneos de discos para saber como criar uma programação de instantâneos e anexá-la aos seus discos. Fazer cópias de segurança dos discos regularmente com capturas de ecrã agendadas pode reduzir o risco de perda de dados inesperada.

Crie um instantâneo do volume do Persistent Disk ou do Hyperdisk

Os passos para criar um instantâneo de um disco dependem de estar a criar um instantâneo de um disco zonal ou de um disco regional.

Crie um instantâneo de um disco zonal

Consola

Aceda à página Criar uma captura instantânea na Google Cloud consola.
Aceda à página Crie um instantâneo
Introduza um Nome para o instantâneo.
Selecione um Tipo de instantâneo. A predefinição é uma cópia instantânea STANDARD, que é a melhor opção para cópias de segurança a longo prazo e recuperação de desastres.

Escolha Arquivo de instantâneo para uma retenção de dados mais rentável.
Opcional: introduza uma descrição do instantâneo.
Em Disco de origem, selecione o disco existente do qual quer criar uma captura instantânea.
Na secção Localização, escolha a localização de armazenamento das suas fotos instantâneas.

A localização predefinida ou personalizada definida nas definições de instantâneo é selecionada automaticamente. Opcionalmente, pode substituir as definições de instantâneo e armazenar os instantâneos numa localização de armazenamento personalizada da seguinte forma:
1. Escolha o tipo de localização de armazenamento que quer para a sua captura instantânea.
  - Escolha Multirregional para uma maior disponibilidade a um custo mais elevado.
  - Escolha Capturas instantâneas regionais para ter mais controlo sobre a localização física dos seus dados a um custo mais baixo.
2. No campo Selecionar localização, selecione a região específica ou multirregião que quer usar. Para usar a região ou a multirregião mais próxima do disco de origem, selecione Com base na localização do disco.
Clique em Criar para criar a captura de ecrã.

gcloud

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

Para criar uma captura de ecrã na localização predefinida ou personalizada configurada nas definições de captura de ecrã, 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
```
Em alternativa, para substituir as definições de imagens instantâneas e criar uma imagem instantânea numa localização de armazenamento personalizada, inclua a flag --storage-location para indicar onde armazenar a imagem instantânea.
```
gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-zone=SOURCE_ZONE \
    --source-disk=SOURCE_DISK_NAME \
    --snapshot-type=SNAPSHOT_TYPE \
    --storage-location=STORAGE_LOCATION
```

(Pré-visualização) Para criar um instantâneo com âmbito regional numa região permitida, inclua a flag --region para indicar onde criar o instantâneo.

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

Substitua o seguinte:

SNAPSHOT_NAME: um nome para o resumo.
SOURCE_ZONE: a zona do disco de origem.
SOURCE_DISK_NAME: o nome do volume do Persistent Disk a partir do qual quer criar um instantâneo.
SNAPSHOT_TYPE: o tipo de instantâneo, STANDARD ou ARCHIVE. Se não for especificado um tipo de instantâneo, é criado um instantâneo STANDARD.
STORAGE_LOCATION: Opcional: para instantâneos com âmbito global, a multirregião do Cloud Storage ou a região do Cloud Storage onde quer armazenar o instantâneo. Só pode especificar uma localização de armazenamento.

Use o parâmetro --storage-location apenas quando quiser substituir a localização de armazenamento predefinida ou personalizada configurada nas definições de instantâneo.
SNAPSHOT_SCOPE_REGION: opcional: para resumos com âmbito regional, a região à qual o resumo se destina. Se incluir este parâmetro, não pode usar o parâmetro --storage-location. O STORAGE_LOCATION é automaticamente definido como SNAPSHOT_SCOPE_REGION.

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

Terraform

Para criar uma captura de ecrã do volume do disco persistente zonal, use o recurso google_compute_snapshot.

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

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

Go

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

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

import (
	"context"
	"fmt"
	"io"

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

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

	ctx := context.Background()

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

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

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

	if diskProjectID == "" {
		diskProjectID = projectID
	}

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

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

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

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

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

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

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

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

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

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

	return nil
}

Java

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

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


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

public class CreateSnapshot {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    }
  }
}

Node.js

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

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

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

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

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

  let disk;

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

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

  if (!diskProjectId) {
    diskProjectId = projectId;
  }

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

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

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

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

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

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

createSnapshot();

Python

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

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

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

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

    if disk_project_id is None:
        disk_project_id = project_id

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

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

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

    wait_for_extended_operation(operation, "snapshot creation")

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

REST

Para criar um instantâneo na localização predefinida ou personalizada configurada nas definições de instantâneos, faça um pedido POST ao método snapshots.insert:

POST https://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/global/snapshots
{
    "name": "SNAPSHOT_NAME",
    "sourceDisk": "projects/SOURCE_PROJECT_ID/zones/SOURCE_ZONE/disks/SOURCE_DISK_NAME",
    "snapshotType": "SNAPSHOT_TYPE"
}

Em alternativa, para substituir as definições de instantâneo e criar um instantâneo numa localização de armazenamento personalizada, faça um pedido ao método POST e inclua a propriedade snapshots.insert no seu pedido: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"
    ],
}

(Pré-visualização) Para criar uma imagem instantânea com âmbito regional numa região permitida, faça um pedido POST ao método snapshots.insert e defina a região de criação:

POST https://compute.googleapis.com/compute/beta/projects/DESTINATION_PROJECT_ID/regions/SNAPSHOT_SCOPE_REGION/snapshots
{
    "name": "SNAPSHOT_NAME",
    "sourceDisk": "projects/SOURCE_PROJECT_ID/zones/SOURCE_ZONE/disks/SOURCE_DISK_NAME",
    "snapshotType": "SNAPSHOT_TYPE"
}

Substitua o seguinte:

DESTINATION_PROJECT_ID: o ID do projeto no qual quer criar a captura de ecrã.
SNAPSHOT_NAME: um nome para o resumo.
SOURCE_PROJECT_ID: o ID do projeto do disco de origem.
SOURCE_ZONE: a zona do disco de origem.
SOURCE_DISK_NAME: o nome do volume do Persistent Disk a partir do qual quer criar um instantâneo.
SNAPSHOT_TYPE: o tipo de instantâneo, STANDARD ou ARCHIVE. Se não for especificado um tipo de instantâneo, é criado um instantâneo STANDARD.
STORAGE_LOCATION: Opcional: para instantâneos com âmbito global, a multirregião do Cloud Storage ou a região do Cloud Storage onde quer armazenar o instantâneo. Só pode especificar uma localização de armazenamento.

Use o parâmetro storageLocations apenas quando quiser substituir a localização de armazenamento predefinida ou personalizada configurada nas definições de instantâneo.
SNAPSHOT_SCOPE_REGION: Opcional: para resumos com âmbito regional, a região à qual o resumo se destina. Se incluir este parâmetro, não pode usar o parâmetro storageLocations. O STORAGE_LOCATION é automaticamente definido como SNAPSHOT_SCOPE_REGION.

Nota: a Google recomenda a utilização do método snapshots.insert em vez do método disks.createSnapshot porque suporta mais funcionalidades, como a criação de instantâneos num projeto diferente do projeto do disco de origem.

Crie um instantâneo de um disco regional

Pode criar instantâneos do seu disco regional de uma das seguintes formas:

Usando os dados no disco de origem. Para usar este método de criação de instantâneos, tem de ter uma réplica zonal sincronizada disponível.
Usando o ponto de verificação de recuperação de réplicas de um disco degradado. Só pode criar cópias instantâneas a partir de um ponto de verificação através da Google Cloud CLI ou da REST.

Depois de preparar o disco, pode criar uma captura instantânea. Quando cria um instantâneo de um disco regional, tem de indicar a região onde o disco de origem está localizado.

Consola

Aceda à página Criar uma captura instantânea na Google Cloud consola.
Aceda à página Crie um instantâneo
Introduza um Nome para o instantâneo.
Selecione um Tipo de instantâneo. A predefinição é uma cópia instantânea STANDARD, que é a melhor opção para cópias de segurança a longo prazo e recuperação de desastres.

Escolha Arquivo de instantâneo para uma retenção de dados mais rentável.
Opcional: introduza uma descrição do instantâneo.
Em Disco de origem, selecione o disco existente do qual quer criar uma captura instantânea.
Na secção Localização, escolha a localização de armazenamento das suas fotos instantâneas.

A localização predefinida ou personalizada definida nas definições de instantâneo é selecionada automaticamente. Opcionalmente, pode substituir as definições de instantâneo e armazenar os instantâneos numa localização de armazenamento personalizada da seguinte forma:
1. Escolha o tipo de localização de armazenamento que quer para a sua captura instantânea.
  - Escolha Multirregional para uma maior disponibilidade a um custo mais elevado.
  - Escolha Capturas instantâneas regionais para ter mais controlo sobre a localização física dos seus dados a um custo mais baixo.
2. No campo Selecionar localização, selecione a região específica ou multirregião que quer usar. Para usar a região ou a multirregião mais próxima do disco de origem, selecione Com base na localização do disco.
Clique em Criar para criar a captura de ecrã.

gcloud

Pode criar um instantâneo usando os dados do disco de origem ou o respetivo ponto de verificação de recuperação da réplica.

A partir de dados do disco

Pode criar um instantâneo a partir dos dados do disco através da política de localização de armazenamento definida nas definições de instantâneo ou através de uma localização de armazenamento alternativa à sua escolha. Para mais informações, consulte o artigo Escolha a localização de armazenamento das capturas de ecrã.

Para criar uma captura de ecrã na localização predefinida ou personalizada configurada nas definições de captura de ecrã, 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
```
Em alternativa, para substituir as definições de imagens instantâneas e criar uma imagem instantânea numa localização de armazenamento personalizada, inclua a flag --storage-location para indicar onde armazenar a imagem instantânea.
```
gcloud compute snapshots create SNAPSHOT_NAME \
    --source-disk-region=SOURCE_REGION \
    --source-disk=SOURCE_DISK_NAME \
    --snapshot-type=SNAPSHOT_TYPE \
    --storage-location=STORAGE_LOCATION
```

(Pré-visualização) Para criar um instantâneo com âmbito regional numa região permitida, inclua a flag --region para indicar onde criar o instantâneo.

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

Substitua o seguinte:

SNAPSHOT_NAME: um nome para o resumo.
SOURCE_REGION: a região do disco de origem.
SOURCE_DISK_NAME: o nome do disco persistente regional ou do volume de alta disponibilidade equilibrado do Hyperdisk a partir do qual quer criar uma cópia instantânea.
SNAPSHOT_TYPE: o tipo de instantâneo, STANDARD ou ARCHIVE. Se não for especificado um tipo de instantâneo, é criado um instantâneo STANDARD.
STORAGE_LOCATION: Opcional: para instantâneos com âmbito global, a multirregião do Cloud Storage ou a região do Cloud Storage onde quer armazenar o instantâneo. Só pode especificar uma localização de armazenamento.

Use o parâmetro --storage-location apenas quando quiser substituir a localização de armazenamento predefinida ou personalizada configurada nas definições de instantâneo.
SNAPSHOT_SCOPE_REGION: opcional: para resumos com âmbito regional, a região à qual o resumo se destina. Se incluir este parâmetro, não pode usar o parâmetro --storage-location. O STORAGE_LOCATION é automaticamente definido como SNAPSHOT_SCOPE_REGION.

A partir do posto de controlo

Pode criar o seu resumo através do ponto de verificação de recuperação de réplicas de um disco degradado. A criação da cópia instantânea é feita desde que a réplica incompleta esteja disponível.

Para criar um resumo usando o ponto de verificação de recuperação da réplica, use o comando gcloud compute snapshots create . Inclua a flag --source-disk-for-recovery-checkpoint para especificar que quer criar a imagem instantânea com um ponto de verificação 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 o seguinte:

DESTINATION_PROJECT_ID: o ID do projeto no qual quer criar a imagem instantânea.
SNAPSHOT_NAME: um nome para o resumo.
SOURCE_PROJECT_ID: o ID do projeto do disco de origem cujo ponto de verificação quer usar para criar a captura de ecrã.
SOURCE_REGION: a região do disco de origem cujo ponto de verificação quer usar para criar o instantâneo.
SOURCE_DISK_NAME: o nome do disco de origem cujo ponto de verificação quer usar para criar a captura de ecrã.
STORAGE_LOCATION: Opcional: A multirregião do Cloud Storage ou a região do Cloud Storage onde quer armazenar a sua captura de ecrã. Só pode especificar uma localização de armazenamento.
Use o elemento apenas se quiser substituir a localização de armazenamento predefinida ou personalizada configurada nas definições de instantâneo.
SNAPSHOT_TYPE: o tipo de instantâneo, STANDARD ou ARCHIVE. Se não for especificado um tipo de instantâneo, é criado um instantâneo STANDARD.

Pode usar o ponto de verificação de recuperação de réplicas para criar um resumo apenas em discos degradados. Se tentar criar uma imagem instantânea a partir de um ponto de verificação de recuperação de réplica quando o dispositivo estiver totalmente replicado, é apresentada a seguinte mensagem de erro:

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 a operação devolva um estado de READY, FAILED ou atinja o limite de tempo máximo e devolve os últimos detalhes conhecidos da cópia instantânea.

Terraform

O fornecedor do Terraform para o Google Cloud não suporta a criação de uma imagem instantânea de um disco regional. Para acompanhar esta limitação, consulte o problema no GitHub.

Go

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

import (
	"context"
	"fmt"
	"io"

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

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

	ctx := context.Background()

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

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

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

	if diskProjectID == "" {
		diskProjectID = projectID
	}

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

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

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

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

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

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

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

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

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

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

	return nil
}

Java

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


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

public class CreateSnapshot {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    }
  }
}

Node.js

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

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

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

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

  let disk;

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

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

  if (!diskProjectId) {
    diskProjectId = projectId;
  }

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

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

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

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

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

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

createSnapshot();

Python

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

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

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

    if disk_project_id is None:
        disk_project_id = project_id

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

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

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

    wait_for_extended_operation(operation, "snapshot creation")

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

REST

Pode criar um instantâneo usando os dados do disco de origem ou o respetivo ponto de verificação de recuperação da réplica.

A partir de dados do disco

Para criar um instantâneo na localização predefinida ou personalizada configurada nas definições de instantâneos, faça um pedido POST ao método snapshots.insert:

POST https://compute.googleapis.com/compute/v1/projects/DESTINATION_PROJECT_ID/global/snapshots
{
  "name": "SNAPSHOT_NAME",
  "sourceDisk": "projects/SOURCE_PROJECT_ID/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"
  ],
}

(Pré-visualização) Para criar uma imagem instantânea com âmbito regional numa região permitida, faça um pedido POST ao método snapshots.insert e defina a região de criação:

POST https://compute.googleapis.com/compute/beta/projects/DESTINATION_PROJECT_ID/regions/SNAPSHOT_SCOPE_REGION/snapshots
{
  "name": "SNAPSHOT_NAME",
  "sourceDisk": "projects/SOURCE_PROJECT_ID/regions/SOURCE_REGION/disks/SOURCE_DISK_NAME",
  "snapshotType": "SNAPSHOT_TYPE",
}

Substitua o seguinte:

DESTINATION_PROJECT_ID: o ID do projeto no qual quer criar a captura de ecrã.
SNAPSHOT_NAME: um nome para o resumo.
SOURCE_PROJECT_ID: o ID do projeto do disco de origem.
SOURCE_REGION: a região do disco de origem.
SOURCE_DISK_NAME: o nome do disco persistente regional ou do volume de alta disponibilidade equilibrado do Hyperdisk a partir do qual quer criar uma captura de ecrã.
SNAPSHOT_TYPE: o tipo de instantâneo, STANDARD ou ARCHIVE. Se não for especificado um tipo de instantâneo, é criado um instantâneo STANDARD.
STORAGE_LOCATION: Opcional: para instantâneos com âmbito global, a multirregião do Cloud Storage ou a região do Cloud Storage onde quer armazenar o instantâneo. Só pode especificar uma localização de armazenamento.

Use o parâmetro storageLocations apenas quando quiser substituir a localização de armazenamento predefinida ou personalizada configurada nas definições de instantâneo.
SNAPSHOT_SCOPE_REGION: Opcional: para resumos com âmbito regional, a região à qual o resumo se destina. Se incluir este parâmetro, não pode usar o parâmetro storageLocations. O STORAGE_LOCATION é automaticamente definido como SNAPSHOT_SCOPE_REGION.

A partir do posto de controlo

Em alternativa, pode criar o seu resumo através do ponto de verificação de recuperação da réplica de um disco degradado. O resumo é criado desde que a réplica incompleta esteja disponível.

Para criar um resumo através do ponto de verificação de recuperação da réplica, faça um pedido POST ao método snapshots.insert. Exclua o parâmetro sourceDisk e, em alternativa, inclua o parâmetro sourceDiskForRecoveryCheckpoint para especificar que quer criar a imagem instantânea com o ponto de verificação.

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 o seguinte:

DESTINATION_PROJECT_ID: o ID do projeto no qual quer criar a imagem instantânea.
SNAPSHOT_NAME: um nome para o resumo.
SOURCE_PROJECT_ID: o ID do projeto do disco de origem cujo ponto de verificação quer usar para criar a captura de ecrã.
SOURCE_REGION: a região do disco de origem cujo ponto de verificação quer usar para criar o instantâneo.
SOURCE_DISK_NAME: o nome do disco de origem cujo ponto de verificação quer usar para criar a captura de ecrã.
STORAGE_LOCATION: Opcional: A multirregião do Cloud Storage ou a região do Cloud Storage onde quer armazenar a sua captura de ecrã. Só pode especificar uma localização de armazenamento.
Use o parâmetro storageLocations apenas se quiser substituir a localização de armazenamento predefinida ou personalizada configurada nas definições de instantâneo.
SNAPSHOT_TYPE: o tipo de instantâneo, STANDARD ou ARCHIVE. Se não for especificado um tipo de instantâneo, é criado um instantâneo STANDARD.

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

O que se segue?

Saiba como criar instantâneos programados para discos.
Saiba como ver, eliminar e partilhar capturas instantâneas de discos.
Saiba como criar uma imagem de disco a partir do seu instantâneo.

Crie instantâneos de disco padrão e de arquivo Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Antes de começar

Console

gcloud

Terraform

Go

Java

Node.js

Python

REST

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

Autorizações necessárias

Prepare-se para criar instantâneos

Crie um instantâneo do volume do Persistent Disk ou do Hyperdisk

Crie um instantâneo de um disco zonal

Consola

gcloud

Terraform

Go

Go

Java

Java

Node.js

Node.js

Python

Python

REST

Crie um instantâneo de um disco regional

Consola

gcloud

A partir de dados do disco

A partir do posto de controlo

Terraform

Go

Go

Java

Java

Node.js

Node.js

Python

Python

REST

A partir de dados do disco

A partir do posto de controlo

O que se segue?

Crie instantâneos de disco padrão e de arquivo