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.

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.

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. L'impostazione di replace_existing: true insieme a source_snapshot aggiorna o inserisce un branch di destinazione esistente, ossia 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 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 snapshots è disponibile in Beta. Per richiedere l'accesso, contatta il team dell'account Databricks.

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?

Last updated on 2026-09-14

Snapshot

Quando usare gli snapshot

Creare snapshot manualmente

Creare un'istantanea

Interfaccia utente

PYTHON SDK

Java SDK

CLI

curva

Creare una pianificazione del backup

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