Snapshots

Een momentopname is een punt-in-time-opname van de hoofdvertakking van een project, inclusief het schema en alle gegevens. Lakebase maakt direct momentopnamen met minimale invloed op de prestaties. Gebruik ze als back-up- of herstelpunt.

Je kunt snapshots maken, herstellen en beheren in de Lakebase App, of er programmatisch mee werken via de snapshots API van de Python SDK, Java SDK, Databricks CLI of curl. Terraform kan herstellen vanuit een snapshot door een tak te maken. Wanneer een bewerking op meer dan één manier beschikbaar is, worden de instructies samen weergegeven als tabbladen.

Note

Vanaf 1 juni 2026 is snapshot-opslag declareerbaar voor Lakebase. Zie de opslagkosten voor momentopnamen.

Wanneer gebruikt u momentopnamen?

Momentopnamen zijn handig voor regelmatige back-ups of voordat schemawijzigingen of andere mogelijk destructieve bewerkingen worden aangebracht. Ze bieden een snelle manier om herstelpunten te maken waaruit u indien nodig kunt herstellen.

Handmatig momentopnamen maken

Momentopnamen leggen de status van uw tak vast op een bepaald moment. U kunt alleen handmatig momentopnamen maken in root branches. Handmatige momentopnamen zijn beperkt tot 10 per project (zie Projectlimieten). U kunt herstellen naar deze momentopnamen vanuit elke tak in uw project.

Een momentopname maken

Momentopnamen worden direct gemaakt en zijn handig voordat u belangrijke wijzigingen aanbrengt in uw schema of gegevens.

UI (Gebruikersinterface)

Ga naar je project in de Lakebase-app en kies Backup & Restore in de branch-navigatie. Klik op Momentopname maken om de huidige status van uw gegevens vast te leggen.

SQL-editor met vooraf geladen SQL-voorbeeld

Python SDK

create_snapshot keert terug naar een langlopende operatie. Bel .wait() om te blokkeren totdat de snapshot beschikbaar is. Het resultaat is de Snapshot. source_branch is vereist, en dus een expiratie: stel precies één van ttl, expire_time, of no_expiry. Optioneel kan je een tijdstip vastzetten met source_branch_lsn of 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 (Command Line Interface)

De snapshot_id is een positioneel argument na het project. De specificatie komt overeen met de --json body:

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

curl

Het maken van een snapshot is een langdurige operatie. De aanvraag retourneert een bewerking waarvan u de status blijft controleren totdat deze is voltooid. De voltooide operatie is uitgepakt naar de Snapshot resource. In de praktijk wordt de momentopname snel AVAILABLE.

De snapshot-specificatie vereist een source_branch. Configureer het tijdstip en de vervaldatum als volgt:

Tijdstip (optioneel): stel ofwel source_branch_lsn of source_branch_time in (wederzijds uitsluitend). Laat beide weg om de huidige hoofd van de afdeling te fotograferen.
Vervaldatum (vereist): stel precies één van expire_time in (een RFC 3339-tijdstempel die in de toekomst moet zijn), ttl (een duur in seconden, zoals "604800s"), of no_expiry: true.

snapshot_id is verplicht, wordt door u gekozen en kan na het aanmaken niet meer worden gewijzigd.

Stuur het aanmaakverzoek. De snapshot_id gaat in de querystring en de specificatie wordt gekoppeld aan de hoofdtekst van het verzoek:

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

De reactie is een langlopende operatie:

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

Controleer de bewerking totdat donetrue is:

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

Wanneer dit is voltooid, wordt de response van de bewerking uitgepakt in de 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"
    }
  }
}

Groottevelden zijn int64 waarden die als strings worden geserialiseerd.

Bevestig dat de snapshot beschikbaar is door deze direct op te halen.

Voor meer informatie over langdurige operaties, zie Langlopende operaties.

Een back-upschema maken

Plan geautomatiseerde momentopnamen om regelmatig (dagelijks, wekelijks of maandelijks) uit te voeren om consistente back-ups te garanderen zonder handmatige tussenkomst. Back-upschema's worden per vertakking geconfigureerd en zijn alleen van toepassing op hoofdbranches. De limiet voor handmatige momentopnamen (zie Projectlimieten) is niet van toepassing op geplande momentopnamen.

Elke worteltak heeft één back-upschema dat een lijst met cadensen bevat. Je leest het schema en vervangt de cadensen op zijn plaats. Er is geen aparte aanmaak- of verwijderoperatie, en het instellen van een lege lijst schakelt automatische snapshots uit. Configureer de planning in de Lakebase App, of programmatisch met de API voor back-upplanning vanuit de Python SDK, Java SDK, Databricks CLI, Terraform, Databricks Asset Bundles of curl.

Note

Programmatische toegang tot back-upschema's is in Beta en beschikbaar voor alle Lakebase-werkruimtes.

UI (Gebruikersinterface)

Een back-upschema maken of wijzigen:

Klik op de pagina Back-up en herstel in uw project op Schema bewerken om het configuratiedialoogvenster voor back-upplanning te openen.
Selecteer een planningsfrequentie uit de volgende opties:
- Geen planning : automatische momentopnamen uitschakelen (standaard)
- Dagelijks : maakt elke dag een momentopname op een bepaald tijdstip
- Wekelijks : maakt een momentopname op een specifieke dag van de week
- Maandelijks : maakt een momentopname op een specifieke dag van de maand
Configureer de planningsgegevens op basis van de geselecteerde frequentie. Geef op hoe vaak u momentopnamen wilt maken en hoe lang u deze wilt bewaren.

Zodra deze zijn geconfigureerd, worden momentopnamen die door het schema zijn gemaakt, weergegeven op de pagina Back-up en herstel met een label dat aangeeft dat ze automatisch zijn gemaakt.

Python SDK

Lees het schema met get_snapshot_schedule, en stel de cadensen in met update_snapshot_schedule. update_snapshot_schedule neemt de resourcenaam van het schema als argument name en vervangt de volledige set cadansen. Om een wekelijkse cadans in te stellen die elke snapshot 7 dagen behoudt, voer je het volgende uit:

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

Om het huidige schema te lezen, voer het volgende uit:

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

for cadence in schedule.schedule:
    print(cadence)

Java SDK

Om een wekelijkse cadans in te stellen die elke snapshot 7 dagen behoudt, voer je het volgende uit:

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 (Command Line Interface)

Vereist Databricks CLI 1.16.0 en hoger. Lees het schema met get-snapshot-schedule, en stel het in met update-snapshot-schedule. Het tweede argument is het updatemasker, dat moet zijn schedule. Het instellen van het schema vervangt de volledige set intervallen en is een langlopende bewerking, dus het commando wacht totdat die is voltooid, tenzij je --no-wait opgeeft.

Om het huidige schema te lezen, voer het volgende uit:

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

Om een wekelijkse cadans in te stellen die elke snapshot 7 dagen behoudt, voer je het volgende uit:

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

Om geautomatiseerde snapshots uit te schakelen, stel je een leeg schema in:

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

Terraform

Beheer het schema met een databricks_postgres_snapshot_schedule hulpmiddel. Zet parent op de naam van de branch resource; de naam name van het schema is daarvan afgeleid. Het schedule-attribuut is een lijst met cadences, en door de resource toe te passen wordt de cadence-set van de branch vervangen:

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

Databricks Asset Pakketten

Definieer het schema onder de postgres_snapshot_schedules sleutel in je bundelconfiguratie. Stel branch in op de naam van de branchresource. Het inzetten van de bundel vervangt de cadensset van de tak:

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

Lees het schema met GET, en stel het in met PATCH. De update vervangt de volledige cadansenset, dus neem elke cadans die je wilt behouden op en geef update_mask=schedule door.

Om het huidige schema te lezen, voer het volgende uit:

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

Het bijwerken van het schema is een langdurige operatie. Om een wekelijkse cadans in te stellen die elke snapshot 7 dagen behoudt, voer je het volgende uit:

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

Controleer de geretourneerde bewerking periodiek totdat done gelijk is aan true. Zie Langlopende bewerkingen. De response van de voltooide bewerking wordt uitgepakt naar de SnapshotSchedule.

Om geautomatiseerde snapshots uit te schakelen, stel je een leeg schema in:

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

Referentie voor frequentie en retentie

Elke frequentie in een planning is exact een van de volgende herhalingspatronen, die op een heel uur in UTC plaatsvinden. Minuten en seconden worden niet ondersteund.

Dagelijks: instellen op hour (0–23).
Wekelijks: instellen day_of_week (MONDAY tot en met SUNDAY) en hour (0–23).
Maandelijks: stel day in (1–31, begrensd tot de laatste dag van kortere maanden) en hour (0–23).

Elke cadans stelt ook een retention duur vast, waarna de snapshots verlopen:

De retentie moet minimaal 1 uur zijn en maximaal 35 dagen.
De bewaartermijn is van toepassing op het moment dat een snapshot wordt gemaakt en werkt niet met terugwerkende kracht. Bestaande snapshots behouden hun oorspronkelijke vervaldatum. Alleen snapshots die na de wijziging zijn gemaakt, gebruiken de nieuwe retentie.
Als meer dan één interval binnen hetzelfde venster gepland is, maakt Lakebase één snapshot en bewaart deze gedurende de langste bewaartermijn van de overeenkomende intervallen.

Het lezen en bijwerken van de planning vereisen beide de toestemming CAN_USE voor het project.

Retentie van momentopnamen

Momentopnamen worden automatisch verwijderd nadat de bewaarperiode is verlopen. U kunt de bewaarinstellingen op elk gewenst moment aanpassen door het schema te bewerken. Houd rekening met het volgende:

Kortere bewaarperioden helpen bij het beheren van het aantal geplande momentopnamen.
Verwijderde momentopnamen kunnen niet worden hersteld
Handmatige momentopnamen worden niet beïnvloed door bewaarinstellingen voor back-upschema's

Snapshots ophalen en weergeven

Bekijk je snapshots op de Backup & Restore-pagina in de Lakebase App, of haal ze programmatisch op met de API.

Momentopnamen weergeven

UI (Gebruikersinterface)

Op de pagina Backup & Restore in de Lakebase App worden je snapshots op datum weergegeven, waarbij de datum en grootte van elke snapshot worden getoond. Geplande snapshots verschijnen in dezelfde lijst met een label dat aangeeft dat ze automatisch zijn aangemaakt.

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 (Command Line Interface)

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

curl

Vermeld de snapshots in een project. Gebruik page_size en page_token blader door resultaten. Een leeg next_page_token punt geeft de laatste pagina aan:

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

Maak één enkele snapshot

Haal de gegevens van één snapshot op via zijn ID. In tegenstelling tot create en delete, retourneert get de Snapshot resource direct (het is geen langlopende operatie). Bij reads wordt de vervaldatum gerapporteerd als ofwel expire_time of 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 (Command Line Interface)

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

Herstellen vanuit een momentopname

Om een snapshot te gebruiken, herstel je deze door er een nieuwe tak van te maken. Er is geen in-place herstel: je huidige branch blijft ongewijzigd en er wordt een nieuwe root branch aangemaakt met de snapshot-data.

UI (Gebruikersinterface)

Op de pagina Back-up en herstel in de Lakebase-app worden momentopnamen weergegeven op datum. Zoek de momentopname die u wilt herstellen en klik op Herstellen. Er wordt een bevestigingsvenster weergegeven waarin wordt uitgelegd wat er gebeurt: de herstelbewerking vindt direct plaats, uw huidige vertakking blijft ongewijzigd en er wordt een nieuwe vertakking gemaakt met een naam, zoals branch_from_snapshot_ gevolgd door de datum en tijd van de momentopname. Bevestig dat u de bewerking wilt uitvoeren door op Herstellen te klikken. Er wordt een nieuwe hoofdbranch gemaakt met de momentopnamegegevens. Uw huidige branch blijft ongewijzigd.

Nadat het herstellen is voltooid, ziet u een succesbericht en de Branch-overzichtspagina voor de nieuwe branch. In de sectie 'Verbinding maken met de nieuwe vertakking om een voorbeeld van herstelde gegevens te bekijken ' wordt uitgelegd dat u verbinding kunt maken vanuit uw toepassing of client om de herstelde gegevens te controleren.

Overzicht van vertakkingen na het herstellen van een momentopname

Klik op Verbindingsgegevens ophalen om een dialoogvenster te openen met de verbindingsgegevens van de nieuwe vertakking: vertakking, berekening, database, rol en een verbindingsreeks die u kunt kopiëren. De berekening van de vertakking kan worden weergegeven als 'In behandeling' terwijl deze wordt gestart. Zodra deze actief is, kunt u de verbindingsreeks gebruiken om verbinding te maken.

Andere dingen die je kunt doen met je nieuwe branch:

Bekijk een voorbeeld van de gegevens. Gebruik de verbindingsgegevens van de nieuwe vertakking om de gegevens te controleren en de herstelbewerking te bevestigen voordat u de configuratie van uw toepassing wijzigt. Zie Verbinding maken met uw database.
Wijzig de naam van de vertakking. Geef de vertakking een duidelijkere naam in het vertakkingsoverzicht of de vertakkinglijst. Zie Branch-instellingen bijwerken.
Als standaard instellen. Als u tevreden bent met de herstelde gegevens, kunt u deze branch de standaardbranch van het project maken. Zie Als standaard instellen.
Verwijs uw applicatie naar de nieuwe branch. Zodra u zeker weet dat de gegevens juist zijn, werkt u de verbindingsinstellingen van uw toepassing bij om de verbindingsgegevens van deze vertakking te gebruiken.
Verwijder of behoud de vorige vertakking. U kunt de tak die u eerder gebruikte, verwijderen als u deze niet meer nodig hebt of hem als back-up bewaren. Zie Een vertakking verwijderen.

U kunt de nieuwe vertakking en alle projecttakken beheren vanaf de pagina Branches van het project, waarbij de herstelde vertakking wordt weergegeven als een hoofdbranch naast uw andere vertakkingen.

Python SDK

Er is geen zelfstandige hersteloperatie. Maak een branch aan met source_snapshot ingesteld op de resourcenaam van de snapshot. Hierdoor verloopt het aanmaken van branches via het herstelpad, waardoor een nieuwe hoofdbranch ontstaat met de gegevens van de snapshot. source_snapshotis wederzijds exclusief met source_branch, , en source_branch_time, en de tak vereist nog steeds een vervaldatum (no_expiry, ttl, of expire_timesource_branch_lsn). Als u source_snapshot samen met replace_existing: true instelt, wordt een bestaande doeltak bijgewerkt of aangemaakt: een idempotent herstel.

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 (Command Line Interface)

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

Terraform

Herstel vanuit een snapshot door een databricks_postgres_branch te declareren met source_snapshot ingesteld in de spec ervan. Terraform-ondersteuning voor snapshots is beperkt tot dit herstelpad — er is geen Terraform-bron voor het aanmaken, vermelden of verwijderen van 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

Er is geen zelfstandige hersteloperatie. Om een snapshot te herstellen, maak je een nieuwe branch aan en stel je in de branchspecificatie source_snapshot in op de resourcenaam van de snapshot. Dit leidt de branchcreatie via het herstelpad, waardoor een nieuwe root branch ontstaat die de data van de snapshot bevat. Je bestaande takken zijn ongewijzigd.

source_snapshot is wederzijds exclusief met source_branch, source_branch_lsn, en source_branch_time. Als u source_snapshot samen met replace_existing: true instelt, wordt een bestaande doeltak bijgewerkt of aangemaakt: een idempotent herstel. De gerefereerde snapshot moet bij hetzelfde project horen AVAILABLE als de nieuwe branch.

Maak de branch aan vanuit de snapshot. De branch_id komt in de querystring:

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

Controleer de geretourneerde bewerking periodiek totdat done gelijk is aan true. De voltooide bewerking wordt uitgepakt in de nieuwe Branch.
Maak verbinding met de nieuwe branch om de herstelde data te verifiëren voordat je je applicatie erop richt. Zie Een branch aanmaken en Verbinding maken met je database.

Verwijder een snapshot

Verwijderde snapshots kunnen niet worden hersteld.

UI (Gebruikersinterface)

Op de pagina Backup & Herstel in de Lakebase-app vind je de snapshot in de lijst, open het Kebab-menupictogram Kebab , en selecteer snapshot verwijderen.

Python SDK

Het verwijderen van een snapshot is een langdurige operatie. Bel .wait() om te blokkeren totdat het voltooid is.

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 (Command Line Interface)

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

curl

Het verwijderen van een snapshot is een langdurige operatie. De aanvraag retourneert een bewerking. Het antwoord op de voltooide bewerking is leeg.

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

Controleer de geretourneerde bewerking periodiek totdat done gelijk is aan true.

Opslagkosten voor momentopnamen

Vanaf 1 juni 2026 is snapshot-opslag declareerbaar voor Lakebase.

Facturering is gebaseerd op het type momentopname:

Handmatige momentopnamen worden in rekening gebracht als volledige momentopnamen.
Geplande momentopnamen worden in rekening gebracht als volledige momentopnamen voor de eerste momentopname in een schema, en vervolgens als incrementele opslag (delta) voor volgende geplande momentopnamen.

De grootte van elke momentopname wordt weergegeven op de pagina Back-up en herstel . Zie de pagina met prijzen van Lakebase voor meer informatie.

Limitations

De snapshots API heeft de volgende beperkingen:

Momentopnamen kunnen onveranderbaar zijn. Er is geen update-operatie. De bronvertakking, de point-in-time selector en de vervaldatum zijn vastgelegd bij het aanmaken en kunnen niet worden gewijzigd.
Geen herstel ter plaatse. Je herstelt een snapshot alleen door er een nieuwe tak van te maken.
Hetzelfde project, beschikbare momentopname. De bronsnapshot moet in de AVAILABLE staat zijn en moet bij hetzelfde project horen als de nieuwe branch.
Wederzijds exclusieve herstelvelden. In het create-branch-verzoek kan source_snapshot niet worden gecombineerd met source_branch, een branch-LSN of een branch-tijdstempel. Het kan worden gecombineerd met replace_existing om een bestaande doeltak te upserteren.
Terraform. De provider ondersteunt alleen herstellen vanaf een snapshot, via het source_snapshot argument op databricks_postgres_branch. Er is geen Terraform-bron voor het maken, vermelden of verwijderen van snapshots.
Beta beschikbaarheid. De snapshots API is in Beta en beschikbaar voor alle Lakebase-werkruimtes.

Filialen — Hoe branching werkt in Lakebase
Lakebase API-handleiding — Authenticatie, resourcenamen en langlopende bewerkingen

Feedback

Is deze pagina nuttig?

Laatst bijgewerkt om 2026-09-30

Snapshots

Wanneer gebruikt u momentopnamen?

Handmatig momentopnamen maken

Een momentopname maken

UI (Gebruikersinterface)

Python SDK

Java SDK

CLI (Command Line Interface)

curl

Een back-upschema maken

UI (Gebruikersinterface)

Python SDK

Java SDK

CLI (Command Line Interface)

Terraform

Databricks Asset Pakketten

curl

Referentie voor frequentie en retentie

Retentie van momentopnamen

Snapshots ophalen en weergeven

Momentopnamen weergeven

UI (Gebruikersinterface)

Python SDK

Java SDK

CLI (Command Line Interface)

curl

Maak één enkele snapshot

Python SDK

Java SDK

CLI (Command Line Interface)

curl

Herstellen vanuit een momentopname

UI (Gebruikersinterface)

Python SDK

Java SDK

CLI (Command Line Interface)

Terraform

curl

Verwijder een snapshot

UI (Gebruikersinterface)

Python SDK

Java SDK

CLI (Command Line Interface)

curl

Opslagkosten voor momentopnamen

Limitations

Related

Feedback

Aanvullende resources