Instantâneos

Um instantâneo é a captura num ponto temporal do ramo raiz de um projeto, incluindo o esquema e todos os dados. O Lakebase cria cópias instantâneas de imediato, com impacto mínimo no desempenho. Usa-os como ponto de backup ou restauro.

Pode criar, restaurar e gerir snapshots na aplicação Lakebase, ou trabalhar com eles programaticamente usando a API de snapshots do Python SDK, Java SDK, Databricks CLI ou curl. O Terraform pode restaurar a partir de um snapshot criando uma ramificação. Quando uma operação está disponível em mais do que um sentido, as instruções são mostradas em conjunto como tabulações.

Note

A partir de 1 de junho de 2026, o armazenamento de instantâneos passa a ser faturado no Lakebase. Veja Custos de armazenamento de snapshots.

Quando usar capturas instantâneas

Os snapshots são úteis para backups regulares ou antes de efetuar alterações de esquema ou outras operações potencialmente destrutivas. Eles fornecem uma forma rápida de criar pontos de restauro dos quais pode restaurar se necessário.

Crie snapshots manualmente

Os snapshots captam o estado do seu ramo num dado momento. Podes criar snapshots manualmente apenas nos ramos raiz. Os snapshots manuais são limitados a 10 por projeto (ver limites do projeto). Podes restaurar estes snapshots a partir de qualquer branch do teu projeto.

Crie um snapshot

Os snapshots são criados instantaneamente e são úteis antes de fazer alterações significativas ao seu esquema ou dados.

IU

Vá ao seu projeto na aplicação Lakebase e selecione Backup & Restore na navegação da ramificação. Clique em Criar instantâneo para capturar o estado atual dos seus dados.

Editor SQL com SQL de exemplo pré-carregado

Python SDK

create_snapshot retorna uma operação de longa duração. Chamada .wait() para bloquear até que o snapshot esteja disponível. O resultado é o Snapshot. source_branch é necessário, e também é necessária uma data de expiração: defina exatamente um de ttl, expire_time ou no_expiry. Opcionalmente, identifica um ponto no tempo com source_branch_lsn ou source_branch_time.

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Snapshot, SnapshotSpec, Duration

w = WorkspaceClient()

snapshot = Snapshot(
    spec=SnapshotSpec(
        source_branch="projects/my-project/branches/main",
        ttl=Duration(seconds=604800),  # 7 days
    )
)

result = w.postgres.create_snapshot(
    parent="projects/my-project",
    snapshot=snapshot,
    snapshot_id="my-snapshot",
).wait()

print(f"Snapshot created: {result.name}")

SDK de Java

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;
import com.google.protobuf.Duration;

WorkspaceClient w = new WorkspaceClient();

SnapshotSpec spec = new SnapshotSpec()
    .setSourceBranch("projects/my-project/branches/main")
    .setTtl(Duration.newBuilder().setSeconds(604800L).build());  // 7 days

Snapshot snapshot = new Snapshot().setSpec(spec);

Snapshot result = w.postgres().createSnapshot(
    new CreateSnapshotRequest()
        .setParent("projects/my-project")
        .setSnapshot(snapshot)
        .setSnapshotId("my-snapshot")
).waitForCompletion();

System.out.println("Snapshot created: " + result.getName());

CLI

O snapshot_id é um argumento posicional depois do projeto. A especificação corresponde ao corpo --json:

databricks postgres create-snapshot projects/my-project my-snapshot \
  --json '{
    "spec": {
      "source_branch": "projects/my-project/branches/main",
      "ttl": "604800s"
    }
  }'

curl

Criar um snapshot é uma operação de longa duração. O pedido devolve uma operação que consultas até ser concluída. A operação concluída descompacta no recurso Snapshot. Na prática, a captura instantânea torna-se AVAILABLE rapidamente.

A especificação snapshot requer um source_branch. Configure o ponto no tempo e a expiração da seguinte forma:

Momento temporal (opcional): defina source_branch_lsn ou source_branch_time (mutuamente exclusivos). Omita ambos para fazer snapshot da cabeça atual do ramo.
Expiração (obrigatória): defina exatamente um dos seguintes: expire_time (uma marca temporal RFC 3339 que tem de estar no futuro), ttl (uma duração em segundos, como "604800s"), ou no_expiry: true.

O snapshot_id é obrigatório, é escolhido por si e não pode ser alterado após a criação.

Envia o pedido de criação. O snapshot_id é incluído na string de consulta, e a especificação corresponde ao corpo do pedido:

curl -X POST "$WORKSPACE/api/2.0/postgres/projects/my-project/snapshots?snapshot_id=my-snapshot" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "spec": {
      "source_branch": "projects/my-project/branches/main",
      "source_branch_lsn": "16/B374D848",
      "ttl": "604800s"
    }
  }'

A resposta é uma operação de longa duração:

{
  "name": "projects/my-project/operations/<operation-id>",
  "done": false
}

Sondar a operação até que done esteja true:

curl "$WORKSPACE/api/2.0/postgres/projects/my-project/operations/<operation-id>" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq

Quando estiver concluída, a operação response é descompactada para Snapshot:

{
  "name": "projects/my-project/operations/<operation-id>",
  "done": true,
  "response": {
    "@type": "type.googleapis.com/databricks.postgres.v1.Snapshot",
    "name": "projects/my-project/snapshots/my-snapshot",
    "status": {
      "full_size_bytes": "10485760",
      "diff_size_bytes": "524288"
    }
  }
}

Os campos de tamanho são valores int64 serializados como cadeias de caracteres.

Confirma que o snapshot está disponível obtendo-o diretamente.

Para mais informações sobre operações de longa duração, veja Operações de longa duração.

Crie um cronograma de backup

Programe snapshots automáticos para serem executados a intervalos regulares (diários, semanais ou mensais) para garantir cópias de segurança consistentes sem intervenção manual. Os cronogramas de backup são configurados por branch e aplicam-se apenas aos ramos raiz. O limite para snapshots manuais (ver limites do projeto) não se aplica a snapshots agendados.

Cada ramo raiz tem um único cronograma de backup que contém uma lista de cadências. Lês o horário e colocas as cadências no lugar. Não existe uma operação separada de criar ou eliminar, e definir uma lista vazia desativa snapshots automáticos. Configure o agendamento na app Lakebase ou, programaticamente, com a API de agendamento de cópias de segurança a partir do SDK de Python, do SDK de Java, da Databricks CLI, do Terraform, do Databricks Asset Bundles ou do curl.

Note

O acesso programático aos agendamentos de backup está em Beta e disponível para todos os espaços de trabalho Lakebase.

IU

Para criar ou modificar um cronograma de backup:

Na página de Backup & Restore do seu projeto, clique em Editar o horário para abrir o diálogo de configuração do cronograma de backup.
Selecione uma frequência de horário entre as seguintes opções:
- Sem agendamento – Desativa snapshots automáticos (por padrão)
- Diário – Cria um instantâneo todos os dias a uma hora determinada
- Semanal – Cria um snapshot num dia específico da semana
- Mensal – Cria um snapshot num dia específico do mês
Configure os detalhes do horário com base na frequência selecionada. Especifique com que frequência quer criar snapshots e quanto tempo deve mantê-los.

Uma vez configurados, os snapshots criados pelo calendário aparecem na página de Backup & Restore com um rótulo a indicar que foram criados automaticamente.

Python SDK

Leia o horário com get_snapshot_schedule, e defina as suas cadências com update_snapshot_schedule. update_snapshot_schedule adota o nome do recurso da tabela como name argumento e substitui todo o conjunto de cadências. Para definir uma cadência semanal que mantenha cada snapshot durante 7 dias, execute o seguinte:

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import (
    SnapshotSchedule,
    ScheduleCadence,
    WeeklySchedule,
    DayOfWeek,
    Duration,
    FieldMask,
)

w = WorkspaceClient()

schedule = SnapshotSchedule(
    name="projects/my-project/branches/main/snapshot-schedule",
    schedule=[
        ScheduleCadence(
            weekly_schedule=WeeklySchedule(day_of_week=DayOfWeek.MONDAY, hour=3),
            retention=Duration(seconds=604800),  # 7 days
        )
    ],
)

w.postgres.update_snapshot_schedule(
    name="projects/my-project/branches/main/snapshot-schedule",
    snapshot_schedule=schedule,
    update_mask=FieldMask(field_mask=["schedule"]),
)

print("Schedule updated.")

Para ler o calendário atual, execute o seguinte:

schedule = w.postgres.get_snapshot_schedule(
    name="projects/my-project/branches/main/snapshot-schedule"
)

for cadence in schedule.schedule:
    print(cadence)

SDK de Java

Para definir uma cadência semanal que mantenha cada snapshot durante 7 dias, execute o seguinte:

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;
import com.google.protobuf.Duration;
import java.util.List;

WorkspaceClient w = new WorkspaceClient();

ScheduleCadence cadence = new ScheduleCadence()
    .setWeeklySchedule(new WeeklySchedule().setDayOfWeek(DayOfWeek.MONDAY).setHour(3))
    .setRetention(Duration.newBuilder().setSeconds(604800L).build());  // 7 days

SnapshotSchedule schedule = new SnapshotSchedule()
    .setName("projects/my-project/branches/main/snapshot-schedule")
    .setSchedule(List.of(cadence));

SnapshotSchedule result = w.postgres().updateSnapshotSchedule(
    new UpdateSnapshotScheduleRequest()
        .setName("projects/my-project/branches/main/snapshot-schedule")
        .setSnapshotSchedule(schedule)
        .setUpdateMask("schedule")
).waitForCompletion();

System.out.println("Schedule updated: " + result.getName());

CLI

Requer a Databricks CLI 1.16.0 ou superior. Leia o horário com get-snapshot-schedule, e defina-o com update-snapshot-schedule. O segundo argumento é a máscara de atualização, que deve ser schedule. Definir o horário substitui todo o conjunto de cadências e é uma operação de longa duração, por isso o comando espera que seja concluído a menos que passe --no-wait.

Para ler o calendário atual, execute o seguinte:

databricks postgres get-snapshot-schedule \
  projects/my-project/branches/main/snapshot-schedule

Para definir uma cadência semanal que mantenha cada snapshot durante 7 dias, execute o seguinte:

databricks postgres update-snapshot-schedule \
  projects/my-project/branches/main/snapshot-schedule \
  schedule \
  --json '{
    "schedule": [
      { "weekly_schedule": { "day_of_week": "MONDAY", "hour": 3 }, "retention": "604800s" }
    ]
  }'

Para desativar snapshots automáticos, defina um cronograma vazio:

databricks postgres update-snapshot-schedule \
  projects/my-project/branches/main/snapshot-schedule \
  schedule \
  --json '{ "schedule": [] }'

Terraform

Gere o horário com um databricks_postgres_snapshot_schedule recurso. Defina parent como o nome do recurso do ramo; o próprio name do agendamento é derivado dele. O atributo schedule é uma lista de cadências, e, ao aplicar o recurso, o conjunto de cadências da ramificação é substituído:

resource "databricks_postgres_snapshot_schedule" "this" {
  parent = "projects/my-project/branches/main"

  schedule = [{
    weekly_schedule = {
      day_of_week = "MONDAY"
      hour        = 3
    }
    retention = "604800s" # 7 days
  }]
}

Pacotes de Ativos da Databricks

Defina o agendamento na chave postgres_snapshot_schedules na configuração do pacote. Defina branch como nome do recurso da ramificação. A implementação do pacote substitui a cadência definida da ramificação:

resources:
  postgres_snapshot_schedules:
    main_schedule:
      branch: projects/my-project/branches/main
      schedule:
        - weekly_schedule:
            day_of_week: MONDAY
            hour: 3
          retention: 604800s # 7 days

curl

Leia o horário com GET, e defina-o com PATCH. A atualização substitui todo o conjunto de cadências, por isso inclui todas as cadências que queres manter e passa update_mask=schedule.

Para ler o calendário atual, execute o seguinte:

curl "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/main/snapshot-schedule" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq

Atualizar o calendário é uma operação de longa duração. Para definir uma cadência semanal que mantenha cada snapshot durante 7 dias, execute o seguinte:

curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/main/snapshot-schedule?update_mask=schedule" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "schedule": [
      { "weekly_schedule": { "day_of_week": "MONDAY", "hour": 3 }, "retention": "604800s" }
    ]
  }'

Consulte a operação devolvida até que done seja true. Ver Operações de longa duração. A operação concluída response é descompactada para SnapshotSchedule.

Para desativar snapshots automáticos, defina um cronograma vazio:

curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/main/snapshot-schedule?update_mask=schedule" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{ "snapshot_schedule": { "schedule": [] } }'

Referência de cadência e retenção

Cada cadência num agendamento corresponde exatamente a uma das seguintes recorrências, ocorrendo à hora certa em UTC. Minutos e segundos não são suportados.

Diário: defina hour (0–23).
Semanalmente: defina day_of_week (MONDAY a SUNDAY) e hour (0–23).
Mensal: defina day (1–31, limitado ao último dia dos meses com menos dias) e hour (0–23).

Cada cadência também define uma duração de retention, ao fim da qual as suas capturas instantâneas expiram:

A retenção deve durar pelo menos 1 hora e, no máximo, 35 dias.
A retenção aplica-se quando uma snapshot é tirada e não é retroativa. Os snapshots existentes mantêm a sua expiração original. Só os snapshots tirados após a alteração utilizam a nova retenção.
Se estiver prevista mais do que uma cadência na mesma janela, o Lakebase cria um único instantâneo e mantém-no pelo período de retenção mais longo entre as cadências coincidentes.

Tanto ler como atualizar o agendamento requerem a permissão CAN_USE no projeto.

Retenção de snapshots

Os snapshots são automaticamente eliminados após o término do seu período de retenção. Pode ajustar as definições de retenção a qualquer momento, editando o calendário. Lembre-se:

Períodos mais curtos de retenção ajudam a gerir o número de instantâneos agendados que são mantidos.
Os snapshots eliminados não podem ser recuperados.
Snapshots manuais não são afetados pelas definições de retenção do cronograma de backup

Obtenha e liste capturas instantâneas

Veja os seus snapshots na página de Backup & Restore na aplicação Lakebase, ou recupere-os programaticamente com a API.

Listar instantâneos

IU

Na página de Backup & Restore da aplicação Lakebase, os seus snapshots estão listados por data, mostrando a data e o tamanho de cada snapshot. As capturas instantâneas programadas aparecem na mesma lista com um rótulo que indica que foram criadas automaticamente.

Python SDK

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

for snapshot in w.postgres.list_snapshots(parent="projects/my-project"):
    print(f"Snapshot: {snapshot.name}")

SDK de Java

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.Snapshot;

WorkspaceClient w = new WorkspaceClient();

for (Snapshot snapshot : w.postgres().listSnapshots("projects/my-project")) {
    System.out.println("Snapshot: " + snapshot.getName());
}

CLI

databricks postgres list-snapshots projects/my-project --output json | jq

curl

Liste os snapshots num projeto. Utilize page_size e page_token para percorrer os resultados. Um vazio next_page_token indica a última página:

curl "$WORKSPACE/api/2.0/postgres/projects/my-project/snapshots?page_size=20" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq

{
  "snapshots": [{ "name": "projects/my-project/snapshots/my-snapshot" }],
  "next_page_token": ""
}

Obter uma captura única

Obter os detalhes de um snapshot pelo respetivo ID. Ao contrário de criar e eliminar, get devolve o Snapshot recurso diretamente (não é uma operação de longa duração). Ao ler, a expiração é indicada como expire_time ou no_expiry.

Python SDK

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

snapshot = w.postgres.get_snapshot(name="projects/my-project/snapshots/my-snapshot")

print(f"Snapshot: {snapshot.name}")
print(f"Source branch: {snapshot.status.source_branch}")
print(f"Full size: {snapshot.status.full_size_bytes} bytes")

SDK de Java

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.Snapshot;

WorkspaceClient w = new WorkspaceClient();

Snapshot snapshot = w.postgres().getSnapshot("projects/my-project/snapshots/my-snapshot");

System.out.println("Snapshot: " + snapshot.getName());
System.out.println("Full size: " + snapshot.getStatus().getFullSizeBytes() + " bytes");

CLI

databricks postgres get-snapshot projects/my-project/snapshots/my-snapshot --output json | jq

curl

curl "$WORKSPACE/api/2.0/postgres/projects/my-project/snapshots/my-snapshot" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq

Restaurar a partir de um snapshot

Para usar um snapshot, restaure-o criando um novo ramo a partir dele. Não existe restauro no local: a sua ramificação atual permanece inalterada e é criada uma nova ramificação raiz com os dados da captura instantânea.

IU

Na página de Backup & Restore da aplicação Lakebase, os snapshots estão listados por data. Encontre o instantâneo que quer restaurar e clique em Restaurar. Aparece um diálogo de confirmação a explicar o que vai acontecer: a restauração ocorre instantaneamente, o seu ramo atual permanece inalterado e um novo ramo será criado com um nome como branch_from_snapshot_ seguido da data e hora do instantâneo. Confirme que quer realizar a operação clicando em Restaurar. Um novo ramo raiz é criado com os dados do snapshot. A sua filial atual mantém-se inalterada.

Depois de o restauro terminar, vê uma mensagem de êxito e a página Visão Geral do Ramo para o novo ramo. A secção intitulada Conectar-se à nova ramificação para pré-visualizar os dados restaurados explica que pode ligar-se a partir da sua aplicação ou cliente para verificar os dados restaurados.

Visão geral do ramo após restaurar a partir de um snapshot

Clique em Obter detalhes de ligação para abrir um diálogo com a informação de ligação do novo ramo: ramo, computação, base de dados, função e uma cadeia de ligação que pode copiar. O cálculo da ramificação pode aparecer como "Pendente" durante o início. Uma vez ativado, podes usar a cadeia de ligação para ligar.

Outras coisas que pode fazer com a sua nova filial:

Pré-visualize os dados. Use os detalhes de ligação da nova agência para verificar os dados e confirmar a restauração antes de alterar a configuração da sua aplicação. Ver Ligar à sua base de dados.
Renomeia o ramo. Dê ao ramo um nome mais claro a partir da visão geral ou da lista de filiais. Consulte Configurações de Atualização da Ramificação.
Definir como padrão. Se estiver satisfeito com os dados restaurados, pode fazer deste ramo o ramo predefinido do projeto. Veja Definir como padrão.
Aponte a sua candidatura para a nova filial. Quando tiver a certeza de que os dados estão corretos, atualize as definições de conexão da sua aplicação para utilizar os detalhes da conexão deste ramo.
Remover ou manter o ramo anterior. Podes apagar a ramificação que usavas antes se já não precisares dela, ou mantê-la como backup. Ver Eliminar um ramo.

Pode gerir o novo ramo e todos os ramos do projeto a partir da página de Ramos do projeto, onde o ramo restaurado aparece como ramo raiz ao lado dos outros ramos.

Python SDK

Não existe uma operação de restauro autónoma. Crie uma ramificação com source_snapshot definido para o nome do recurso do snapshot. Isto encaminha a criação de ramos através do caminho de restauração, produzindo um novo ramo raiz com os dados do instantâneo. source_snapshot é mutuamente exclusivo de source_branch, source_branch_lsn e source_branch_time, e a ramificação continua a exigir uma expiração (no_expiry, ttl ou expire_time). Ao definir replace_existing: true em conjunto com source_snapshot, cria-se ou atualiza-se um ramo de destino existente, num restauro idempotente.

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Branch, BranchSpec

w = WorkspaceClient()

branch = Branch(
    spec=BranchSpec(
        source_snapshot="projects/my-project/snapshots/my-snapshot",
        no_expiry=True,
    )
)

result = w.postgres.create_branch(
    parent="projects/my-project",
    branch=branch,
    branch_id="restored-branch",
).wait()

print(f"Branch created: {result.name}")

SDK de Java

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;

WorkspaceClient w = new WorkspaceClient();

BranchSpec spec = new BranchSpec()
    .setSourceSnapshot("projects/my-project/snapshots/my-snapshot")
    .setNoExpiry(true);

Branch branch = new Branch().setSpec(spec);

Branch result = w.postgres().createBranch(
    new CreateBranchRequest()
        .setParent("projects/my-project")
        .setBranch(branch)
        .setBranchId("restored-branch")
).waitForCompletion();

System.out.println("Branch created: " + result.getName());

CLI

databricks postgres create-branch projects/my-project restored-branch \
  --json '{
    "spec": {
      "source_snapshot": "projects/my-project/snapshots/my-snapshot",
      "no_expiry": true
    }
  }'

Terraform

Restaure a partir de um instantâneo ao declarar um databricks_postgres_branch com source_snapshot definido no respetivo spec. O suporte do Terraform para snapshots está limitado a este caminho de restauro — não existe um recurso Terraform para criar, listar ou eliminar snapshots.

resource "databricks_postgres_branch" "restored" {
  branch_id = "restored-branch"
  parent    = "projects/my-project"
  spec = {
    source_snapshot = "projects/my-project/snapshots/my-snapshot"
    no_expiry       = true
  }
}

curl

Não existe uma operação de restauro autónoma. Para restaurar um snapshot, crie um novo branch e defina source_snapshot na especificação de branch o nome do recurso do snapshot. Isto encaminha a criação do ramo através do caminho de restauro, produzindo um novo ramo raiz que contém os dados do instantâneo. As suas ramificações existentes permanecem inalteradas.

source_snapshot é mutuamente exclusivo com source_branch, source_branch_lsn, e source_branch_time. Ao definir replace_existing: true em conjunto com source_snapshot, cria-se ou atualiza-se um ramo de destino existente, num restauro idempotente. O instantâneo referenciado deve ser AVAILABLE e pertencer ao mesmo projeto que a nova ramificação.

Crie o ramo a partir do snapshot. O branch_id é incluído na query string:

curl -X POST "$WORKSPACE/api/2.0/postgres/projects/my-project/branches?branch_id=restored-branch" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "spec": {
      "source_snapshot": "projects/my-project/snapshots/my-snapshot",
      "no_expiry": true
    }
  }'

Consulte a operação devolvida até que done seja true. A operação concluída é descompactada para o novo Branch.
Ligue-se à nova ramificação para verificar os dados restaurados antes de direcionar a sua aplicação para a mesma. Veja Criar um ramo e Ligar-se à sua base de dados.

Apagar um snapshot

Os instantâneos apagados não podem ser recuperados.

IU

Na página de Backup & Restore na aplicação Lakebase, encontre o snapshot na lista, abra o ícone do menu Kebab. menu kebab, e selecione Eliminar snapshot.

Python SDK

Eliminar um snapshot é uma operação de longa duração. Chame .wait() para bloquear até que conclua.

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

w.postgres.delete_snapshot(name="projects/my-project/snapshots/my-snapshot").wait()

print("Snapshot deleted")

SDK de Java

import com.databricks.sdk.WorkspaceClient;

WorkspaceClient w = new WorkspaceClient();

w.postgres().deleteSnapshot("projects/my-project/snapshots/my-snapshot")
    .waitForCompletion();

System.out.println("Snapshot deleted");

CLI

databricks postgres delete-snapshot projects/my-project/snapshots/my-snapshot

curl

Eliminar um snapshot é uma operação de longa duração. O pedido devolve uma operação. A resposta da operação concluída é vazia.

curl -X DELETE "$WORKSPACE/api/2.0/postgres/projects/my-project/snapshots/my-snapshot" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq

Consulte a operação devolvida até que done seja true.

Custos de armazenamento instantâneo

A partir de 1 de junho de 2026, o armazenamento de instantâneos passa a ser faturado no Lakebase.

A faturação baseia-se no tipo de snapshot:

Os snapshots manuais são carregados como snapshots completos.
Os snapshots agendados são cobrados como snapshots completos no caso do primeiro snapshot de um agendamento e, posteriormente, como armazenamento incremental (delta) para os snapshots subsequentes.

O tamanho de cada snapshot é mostrado na página de Backup & Resto . Para detalhes sobre preços, consulte a página de preços da Lakebase.

Limitations

A API de snapshots tem as seguintes limitações:

Os instantâneos são imutáveis. Não existe qualquer operação de atualização. A ramificação de origem, o seletor temporal e a expiração ficam definidos aquando da criação e não podem ser alterados.
Não há restauro no local. Só se restaura um snapshot criando um novo branch a partir dele.
Mesmo projeto, captura de estado disponível. O instantâneo de origem tem de estar no estado AVAILABLE e tem de pertencer ao mesmo projeto que a nova ramificação.
Campos de restauro mutuamente exclusivos. No pedido de criação de branch, source_snapshot não pode ser combinado com source_branch, um LSN de branch ou um timestamp de branch. Pode ser combinado com replace_existing para criar ou atualizar uma ramificação de destino existente.
Terraforme. O fornecedor suporta apenas o restauro a partir de um snapshot, através do argumento source_snapshot em databricks_postgres_branch. Não existe um recurso Terraform para criar, listar ou eliminar instantâneos.
Disponibilidade beta. A API de snapshots está em Beta e disponível para todos os workspaces do Lakebase.

Ramificações — Como funcionam as ramificações no Lakebase
Guia da API Lakebase — Autenticação, nomeação de recursos e operações de longa duração

Comentários

Esta página foi útil?

Última atualização a 2026-09-30

Instantâneos

Quando usar capturas instantâneas

Crie snapshots manualmente

Crie um snapshot

IU

Python SDK

SDK de Java

CLI

curl

Crie um cronograma de backup

IU

Python SDK

SDK de Java

CLI

Terraform

Pacotes de Ativos da Databricks

curl

Referência de cadência e retenção

Retenção de snapshots

Obtenha e liste capturas instantâneas

Listar instantâneos

IU

Python SDK

SDK de Java

CLI

curl

Obter uma captura única

Python SDK

SDK de Java

CLI

curl

Restaurar a partir de um snapshot

IU

Python SDK

SDK de Java

CLI

Terraform

curl

Apagar um snapshot

IU

Python SDK

SDK de Java

CLI

curl

Custos de armazenamento instantâneo

Limitations

Related

Comentários

Recursos adicionais