Snapshot

Un snapshot è un'acquisizione puntuale del ramo radice di un progetto, includendo lo schema e tutti i dati. Lakebase crea snapshot istantaneamente con un impatto minimo sulle prestazioni. Usarli come punto di backup o ripristino.

Puoi creare, ripristinare e gestire snapshot nell'app Lakebase, oppure lavorarci in modo programmativo usando l'API snapshot del Python SDK, Java SDK, Databricks CLI o curl. Terraform può ripristinare da un'istantanea creando un ramo. Quando un'operazione è disponibile in più di un modo, le istruzioni vengono visualizzate insieme sotto forma di schede.

Note

A partire dal 1° giugno 2026, l'archiviazione delle istantanee viene addebitata per Lakebase. Vedere Costi di archiviazione degli snapshot.

Quando usare gli snapshot

Gli snapshot sono utili per i backup regolari o prima di apportare modifiche allo schema o altre operazioni potenzialmente distruttive. Offrono un modo rapido per creare punti di ripristino da cui è possibile eseguire il ripristino, se necessario.

Creare snapshot manualmente

Le istantanee acquisiscono lo stato del ramo in un momento specifico. È possibile creare snapshot manualmente solo nei rami principali. Gli snapshot manuali sono limitati a 10 per ogni progetto (vedere Limiti del progetto). È possibile eseguire il ripristino in questi snapshot da qualsiasi ramo del progetto.

Creare un'istantanea

Gli snapshot vengono creati immediatamente e sono utili prima di apportare modifiche significative allo schema o ai dati.

Interfaccia utente

Vai al tuo progetto nell'app Lakebase e seleziona Backup & Restore nella navigazione delle filiali. Fare clic su Crea snapshot per acquisire lo stato corrente dei dati.

Editor SQL con esempi di SQL precaricati

PYTHON SDK

create_snapshot riporta un'operazione di lunga durata. Chiama .wait(); la chiamata si blocca finché lo snapshot non è disponibile. Il risultato è il Snapshot. source_branch è obbligatorio, e anche una scadenza: impostare uno solo tra ttl, expire_time o no_expiry. Opzionalmente, fissa un momento nel tempo con source_branch_lsn o 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}")

Java SDK

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

Il snapshot_id è un argomento posizionale successivo al progetto. La specifica corrisponde al corpo --json:

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

curva

Creare uno snapshot è un'operazione di lunga durata. La richiesta restituisce un'operazione da interrogare periodicamente fino al completamento. L'operazione completata viene decompattata nella risorsa Snapshot. In pratica, l'istantanea diventa AVAILABLE rapidamente.

La specifica snapshot richiede un source_branch. Configura il momento nel tempo e la scadenza come segue:

Punto nel tempo (opzionale): impostare o source_branch_lsn o source_branch_time (mutuamente esclusivo). Ometti entrambi per fare snapshot dell'attuale capo del ramo.
Scadenza (obbligatoria): impostare esattamente uno di expire_time (un timestamp RFC 3339 che deve essere nel futuro), ttl (una durata in secondi, come "604800s"), oppure no_expiry: true.

snapshot_id è obbligatorio, viene scelto da te e non può essere modificato dopo la creazione.

Invia la richiesta di creazione. snapshot_id viene inserito nella stringa di query e la specifica corrisponde al corpo della richiesta:

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

La risposta è un'operazione di lunga durata:

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

Verifica l'operazione finché done non è true:

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

Una volta completata, l'operazione response si svuota su :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"
    }
  }
}

I campi di dimensione sono int64 valori serializzati come stringhe.

Conferma che lo snapshot sia disponibile ottenendolo direttamente.

Per maggiori informazioni sulle operazioni di lunga durata, vedi Operazioni di lunga durata.

Creare una pianificazione del backup

Pianificare l'esecuzione di snapshot automatizzati a intervalli regolari (giornalieri, settimanali o mensili) per garantire backup coerenti senza intervento manuale. Le pianificazioni di backup sono configurate per ogni ramo e si applicano solo ai rami radice. Il limite per gli snapshot manuali (vedere Limiti del progetto) non si applica agli snapshot pianificati.

Ogni ramo radice ha un unico programma di backup che contiene un elenco di cadenze. Leggi la pianificazione e sostituisci direttamente le relative cadenze. Non esiste un'operazione separata di creazione o cancellazione, e impostare una lista vuota disabilita gli snapshot automatici. Configura la pianificazione nell’app Lakebase oppure, a livello di codice, con l’API di pianificazione dei backup dall’SDK per Python, dall’SDK per Java, dalla Databricks CLI, da Terraform, da Databricks Asset Bundles o da curl.

Note

L'accesso programmatico ai programmi di backup è in Beta ed è disponibile per tutti gli spazi di lavoro di Lakebase.

Interfaccia utente

Per creare o modificare una pianificazione del backup:

Nella pagina Backup e ripristino del progetto fare clic su Modifica pianificazione per aprire la finestra di dialogo di configurazione della pianificazione del backup.
Selezionare una frequenza di pianificazione dalle opzioni seguenti:
- Nessuna pianificazione : disabilita gli snapshot automatizzati (impostazione predefinita)
- Giornaliero : crea uno snapshot ogni giorno a un'ora specificata
- Settimanale : crea uno snapshot in un giorno specifico della settimana
- Mensile : crea uno snapshot in un giorno specifico del mese
Configurare i dettagli della pianificazione in base alla frequenza selezionata. Specificare la frequenza con cui si desidera creare snapshot e per quanto tempo mantenerli.

Dopo la configurazione, gli snapshot creati dalla pianificazione vengono visualizzati nella pagina Backup e ripristino con un'etichetta che indica che sono stati creati automaticamente.

PYTHON SDK

Leggi il programma con get_snapshot_schedule, e imposta le sue cadenze con update_snapshot_schedule. update_snapshot_schedule accetta il nome della risorsa della pianificazione come argomento name e sostituisce l'intero set di cadenze. Per impostare una cadenza settimanale che conservi ogni snapshot per 7 giorni, esegui quanto segue:

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.")

Per leggere il programma attuale, esegui quanto segue:

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

for cadence in schedule.schedule:
    print(cadence)

Java SDK

Per impostare una cadenza settimanale che conservi ogni snapshot per 7 giorni, esegui quanto segue:

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

Richiede la CLI di Databricks versione 1.16.0 o successiva. Leggi la pianificazione con get-snapshot-schedule e impostala con update-snapshot-schedule. Il secondo argomento è la maschera di aggiornamento, che deve essere schedule. Impostare il programma sostituisce l'intero insieme di cadenze ed è un'operazione di lunga durata, quindi il comando aspetta che si completi a meno che tu non superi --no-wait.

Per leggere il programma attuale, esegui quanto segue:

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

Per impostare una cadenza settimanale che conservi ogni snapshot per 7 giorni, esegui quanto segue:

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

Per disabilitare gli snapshot automatici, imposta un programma vuoto:

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

Terraform

Gestisci il programma con una databricks_postgres_snapshot_schedule risorsa. Imposta parent sul nome della risorsa del ramo; il valore name della pianificazione viene ricavato da esso. L'attributo schedule è un elenco di cadenze, e applicando la risorsa si sostituisce l'insieme di cadenze del ramo:

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

Pacchetti di Asset di Databricks

Definisci la pianificazione nella chiave postgres_snapshot_schedules della configurazione del bundle. Imposta branch sul nome della risorsa del ramo. La distribuzione del bundle sostituisce il set di cadenza del branch:

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

curva

Leggi la pianificazione con GET e impostala con PATCH. L'aggiornamento sostituisce l'intero insieme di cadenze, quindi includi tutte le cadenze che vuoi mantenere e passa update_mask=schedule.

Per leggere il programma attuale, esegui quanto segue:

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

Aggiornare il programma è un'operazione di lunga durata. Per impostare una cadenza settimanale che conservi ogni snapshot per 7 giorni, esegui quanto segue:

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

Interroga ripetutamente l'operazione restituita finché done non è true. Vedere Operazioni a esecuzione prolungata. Il response dell'operazione completata viene decompresso in SnapshotSchedule.

Per disabilitare gli snapshot automatici, imposta un programma vuoto:

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": [] } }'

Informazioni di riferimento su frequenza e conservazione

Ogni cadenza in un programma è esattamente una delle seguenti ricorrenze, presa a un'intera ora in UTC. I minuti e i secondi non sono supportati.

Giornaliero: imposta hour (0–23).
Settimanale: set day_of_week (MONDAY fino a SUNDAY) e hour (0–23).
Mensile: imposta day (1–31, limitato all'ultimo giorno dei mesi con meno giorni) e hour (0–23).

Ogni cadenza stabilisce anche una retention durata, dopo la quale i suoi snapshot scadono:

La ritenzione deve durare almeno 1 ora e al massimo 35 giorni.
Il criterio di conservazione si applica quando viene creata un'istantanea e non ha effetto retroattivo. Gli snapshot esistenti mantengono la loro scadenza originale. Solo le snapshot create dopo la modifica usano il nuovo criterio di conservazione.
Se nella medesima finestra è prevista più di una cadenza, Lakebase crea un singolo snapshot e lo conserva per il periodo di conservazione più lungo tra le cadenze corrispondenti.

Per leggere e aggiornare la pianificazione è necessaria l'autorizzazione CAN_USE nel progetto.

Conservazione degli snapshot

Gli snapshot vengono eliminati automaticamente dopo la scadenza del periodo di conservazione. È possibile modificare le impostazioni di conservazione in qualsiasi momento modificando la pianificazione. Tenere presente quanto segue:

I periodi di conservazione più brevi consentono di gestire il numero di snapshot pianificati conservati.
Non è possibile recuperare gli snapshot eliminati
Gli snapshot manuali non sono soggetti alle impostazioni di conservazione della pianificazione del backup.

Recupera ed elenca istantanee

Visualizza le tue istantanee nella pagina Backup & Restore dell'app Lakebase, oppure recuperali in modo programmativo con l'API.

Elencare gli snapshot

Interfaccia utente

Nella pagina Backup & Restore dell'app Lakebase, i tuoi snapshot sono elencati per data, mostrando la data e la dimensione di ciascuno. Gli snapshot programmati appaiono nello stesso elenco con un'etichetta che indica che sono stati creati 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}")

Java SDK

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

curva

Elenca gli snapshot di un progetto. Usa page_size e page_token scorre i risultati. Un vuoto next_page_token indica l'ultima pagina:

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

Ottieni una singola istantanea

Recupera i dati di uno snapshot tramite il suo ID. A differenza di create and delete, get restituisce direttamente la Snapshot risorsa (non è un'operazione di lunga durata). In lettura, la scadenza viene riportata come expire_time o 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")

Java SDK

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

curva

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

Eseguire il ripristino da uno snapshot

Per usare un'istantanea, ripristinala creando un nuovo ramo a partire da essa. Non c'è un ripristino in situ: il tuo ramo attuale rimane invariato e viene creato un nuovo ramo radice con i dati dello snapshot.

Interfaccia utente

Nella pagina Backup e ripristino nell'app Lakebase gli snapshot sono elencati per data. Trovare lo snapshot da ripristinare e fare clic su Ripristina. Viene visualizzata una finestra di dialogo di conferma che spiega cosa accadrà: il ripristino viene eseguito immediatamente, il ramo corrente rimane invariato e verrà creato un nuovo ramo con un nome simile branch_from_snapshot_ a quello seguito dalla data e dall'ora dello snapshot. Verificare di voler eseguire l'operazione facendo clic su Ripristina. Viene creato un nuovo ramo radice con i dati dello snapshot. Il ramo corrente rimane invariato.

Al termine del ripristino, viene visualizzato un messaggio di operazione riuscita e la pagina di panoramica del ramo per il nuovo ramo. La sezione intitolata Connetti al nuovo ramo per visualizzare in anteprima i dati ripristinati spiega che è possibile connettersi dall'applicazione o dal client per verificare i dati ripristinati.

Panoramica del branch dopo il ripristino da uno snapshot

Fare clic su Recupera dettagli connessione per aprire una finestra di dialogo con le informazioni di connessione del nuovo ramo: ramo, calcolo, database, ruolo e una stringa di connessione che è possibile copiare. Il calcolo del ramo può essere visualizzato come "In sospeso" all'avvio. Quando è attiva, è possibile usare la stringa di connessione per connettersi.

Altre operazioni che è possibile eseguire con il nuovo ramo:

Visualizzare in anteprima i dati. Usare i dettagli di connessione del nuovo ramo per controllare i dati e confermare il ripristino prima di modificare la configurazione dell'applicazione. Vedere Connettersi al database.
Rinominare il ramo. Dai un nome più chiaro al ramo dalla panoramica dei rami o dall'elenco dei rami. Vedere Aggiornare le impostazioni del ramo.
Impostare come predefinito. Se si è soddisfatti dei dati ripristinati, è possibile impostare questo ramo come ramo predefinito del progetto. Vedere Impostare come predefinito.
Punta l'applicazione verso la nuova branch. Dopo aver verificato che i dati siano corretti, aggiornare le impostazioni di connessione dell'applicazione per usare i dettagli di connessione di questo ramo.
Rimuovere o mantenere il ramo precedente. È possibile eliminare il ramo usato prima se non è più necessario o mantenerlo come backup. Vedere Eliminare un ramo.

È possibile gestire il nuovo ramo e tutti i rami di progetto dalla pagina Rami del progetto, in cui il ramo ripristinato viene visualizzato come ramo radice insieme agli altri rami.

PYTHON SDK

Non esiste un'operazione di ripristino autonoma. Crea un ramo con source_snapshot impostato sul nome della risorsa dello snapshot. Questo fa passare la creazione del ramo attraverso il percorso di ripristino, generando un nuovo ramo radice con i dati dello snapshot. source_snapshot è mutuamente esclusivo con source_branch, source_branch_lsn, e source_branch_time, e il ramo richiede comunque una scadenza (no_expiry, ttl, o expire_time). Impostare replace_existing: true insieme a source_snapshot aggiorna o inserisce una branch di destinazione esistente, consentendo un ripristino 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}")

Java SDK

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

Ripristinare da un'istantanea dichiarando un databricks_postgres_branch con source_snapshot impostato nel relativo spec. Il supporto di Terraform per gli snapshot è limitato a questo percorso di ripristino — non esiste una risorsa Terraform per creare, elencare o eliminare snapshot.

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

curva

Non esiste un'operazione di ripristino autonoma. Per ripristinare uno snapshot, crea un nuovo branch e imposta source_snapshot la specifica del branch sul nome della risorsa dello snapshot. Questo fa passare la creazione del ramo attraverso la procedura di ripristino, generando un nuovo ramo radice che contiene i dati dello snapshot. Le tue filiali esistenti sono rimaste invariate.

source_snapshot è mutuamente esclusivo con source_branch, source_branch_lsn, e source_branch_time. Impostare replace_existing: true insieme a source_snapshot aggiorna o inserisce una branch di destinazione esistente, consentendo un ripristino idempotente. L'istantanea di riferimento deve essere AVAILABLE e appartenere allo stesso progetto del nuovo ramo.

Crea il ramo dallo snapshot. branch_id va inserito nella stringa di query:

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

Interroga ripetutamente l'operazione restituita finché done non è true. L'operazione completata viene decompattata nel nuovo Branch.
Connettiti al nuovo ramo per verificare i dati ripristinati prima di indirizzare la tua applicazione verso di esso. Consulta Crea un ramo e Collegati al tuo database.

Elimina snapshot

Gli snapshot cancellati non possono essere recuperati.

Interfaccia utente

Nella pagina Backup & Restore nell'app Lakebase, trova lo snapshot nella lista, apri l'icona del menu Kebab. menu kebab, e seleziona Elimina snapshot.

PYTHON SDK

Eliminare uno snapshot è un'operazione di lunga durata. Chiama .wait() per bloccare l'esecuzione fino al completamento.

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

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

print("Snapshot deleted")

Java SDK

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

curva

Eliminare uno snapshot è un'operazione di lunga durata. La richiesta restituisce un'operazione. La risposta dell'operazione completata è vuota.

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

Interroga ripetutamente l'operazione restituita finché done non è true.

Costi di archiviazione delle snapshot

A partire dal 1° giugno 2026, l'archiviazione delle istantanee viene addebitata per Lakebase.

La fatturazione si basa sul tipo di snapshot:

Gli snapshot manuali vengono addebitati come snapshot completi.
Gli snapshot pianificati vengono addebitati come snapshot completi per il primo snapshot di una pianificazione e successivamente come archiviazione incrementale (delta) per gli snapshot pianificati successivi.

Le dimensioni di ogni snapshot vengono visualizzate nella pagina Backup e ripristino . Per informazioni dettagliate sui prezzi, vedere la pagina dei prezzi di Lakebase.

Limitations

L'API snapshots presenta le seguenti limitazioni:

Gli snapshot non sono modificabili. Non c'è alcuna operazione di aggiornamento. Il branch di origine, il selettore del punto nel tempo e la scadenza vengono definiti al momento della creazione e non possono essere modificati.
Nessun ripristino in loco. È possibile ripristinare un'istantanea solo creando un nuovo ramo a partire da essa.
Stesso progetto, istantanea disponibile. L'istantanea di origine deve trovarsi nello stato AVAILABLE e deve appartenere allo stesso progetto del nuovo ramo.
Campi di ripristino mutuamente esclusivi. Nella richiesta create-branch, source_snapshot non può essere combinato con source_branch, un LSN del branch o un timestamp del branch. Può essere combinato con replace_existing per creare o aggiornare un ramo di destinazione esistente.
Terraform. Il provider supporta solo il ripristino da uno snapshot, tramite l'argomento source_snapshot su databricks_postgres_branch. Non esiste una risorsa Terraform per creare, elencare o cancellare snapshot.
Disponibilità beta. L'API snapshot è in Beta ed è disponibile per tutti gli spazi di lavoro di Lakebase.

Ramificazioni — Come funziona la ramificazione a Lakebase
Guida API di Lakebase — Autenticazione, denominazione delle risorse e operazioni di lunga durata

Commenti e suggerimenti

Questa pagina è stata utile?

Ultimo aggiornamento: 2026-09-30

Snapshot

Quando usare gli snapshot

Creare snapshot manualmente

Creare un'istantanea

Interfaccia utente

PYTHON SDK

Java SDK

CLI

curva

Creare una pianificazione del backup

Interfaccia utente

PYTHON SDK

Java SDK

CLI

Terraform

Pacchetti di Asset di Databricks

curva

Informazioni di riferimento su frequenza e conservazione

Conservazione degli snapshot

Recupera ed elenca istantanee

Elencare gli snapshot

Interfaccia utente

PYTHON SDK

Java SDK

CLI

curva

Ottieni una singola istantanea

PYTHON SDK

Java SDK

CLI

curva

Eseguire il ripristino da uno snapshot

Interfaccia utente

PYTHON SDK

Java SDK

CLI

Terraform

curva

Elimina snapshot

Interfaccia utente

PYTHON SDK

Java SDK

CLI

curva

Costi di archiviazione delle snapshot

Limitations

Related

Commenti e suggerimenti

Risorse aggiuntive