Schnappschüsse

Eine Momentaufnahme ist eine zeitpunktbezogene Erfassung der Stammverzweigung eines Projekts, einschließlich des Schemas und aller Daten. Lakebase erstellt Momentaufnahmen sofort mit minimalen Leistungsauswirkungen. Verwenden Sie sie als Sicherungs- oder Wiederherstellungspunkt.

Sie können Snapshots in der Lakebase-App erstellen, wiederherstellen und verwalten oder programmatisch mit ihnen über die Snapshots-API aus dem Python SDK, dem Java SDK, der Databricks CLI oder Curl arbeiten. Terraform kann aus einem Snapshot wiederhergestellt werden, indem ein Branch erstellt wird. Wenn eine Operation auf mehr als eine Weise verfügbar ist, werden die Anweisungen zusammen als Tabs angezeigt.

Note

Ab dem 1. Juni 2026 ist der Snapshot-Speicher für Lakebase kostenpflichtig. Siehe Snapshot-Speicherkosten.

Gründe für die Verwendung von Momentaufnahmen

Momentaufnahmen sind nützlich für regelmäßige Sicherungen oder vor dem Vornehmen von Schemaänderungen oder anderen potenziell destruktiven Vorgängen. Sie bieten eine schnelle Möglichkeit zum Erstellen von Wiederherstellungspunkten, von denen Sie bei Bedarf wiederherstellen können.

Manuelles Erstellen von Momentaufnahmen

Momentaufnahmen erfassen den Zustand Ihres Branches zu einem bestimmten Zeitpunkt. Sie können Momentaufnahmen nur manuell in Stammzweigen erstellen. Manuelle Momentaufnahmen sind auf 10 pro Projekt beschränkt (siehe Project-Grenzwerte). Sie können diese Momentaufnahmen von jeder Verzweigung in Ihrem Projekt wiederherstellen.

Erstellen einer Momentaufnahme

Momentaufnahmen werden sofort erstellt und sind nützlich, bevor Sie erhebliche Änderungen an Ihrem Schema oder Ihren Daten vornehmen.

Benutzeroberfläche

Gehe in der Lakebase-App zu deinem Projekt und wähle in der Zweig-Navigation Backup & Wiederherstellung . Klicken Sie auf "Momentaufnahme erstellen", um den aktuellen Status Ihrer Daten zu erfassen.

SQL-Editor mit vorinstallierter Beispiel-SQL

Python SDK

create_snapshot gibt einen lang andauernden Vorgang zurück. Rufen Sie .wait() an, um zu blockieren, bis der Snapshot verfügbar ist. Das Ergebnis ist das Snapshot. source_branch ist erforderlich, und ebenso eine Expiration: setze genau eins von ttl, expire_time, oder no_expiry. Optional kann man einen Zeitpunkt mit source_branch_lsn oder source_branch_timefestlegen.

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

Das snapshot_id ist ein Positionsargument nach dem Projekt. Die Spezifikation wird dem --json-Textkörper zugeordnet:

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

cURL

Das Erstellen eines Schnappschusses ist eine langwierige Operation. Die Anfrage gibt einen Vorgang zurück, dessen Status Sie abfragen, bis er abgeschlossen ist. Die abgeschlossene Operation wird in die Snapshot-Ressource entpackt. In der Praxis wird der Schnappschuss umgehend zu AVAILABLE.

Die Snapshot-Spezifikation erfordert ein source_branch. Konfigurieren Sie den Zeitpunkt und das Verfallsdatum wie folgt:

Zeitpunkt ( optional): Setze entweder source_branch_lsn oder source_branch_time (gegenseitig ausschließend). Lassen Sie beides weg, um eine Momentaufnahme des aktuellen Heads des Verzweigung zu erstellen.
Ablaufzeit (erforderlich): Legen Sie genau einen der folgenden Werte fest: expire_time (ein RFC-3339-Zeitstempel, der in der Zukunft liegen muss), ttl (eine Dauer in Sekunden, z. B. "604800s") oder no_expiry: true.

snapshot_id ist erforderlich, wird von dir ausgewählt und kann nach dem Erstellen nicht mehr geändert werden.

Senden Sie die Erstellungsanforderung. Das snapshot_id kommt in den Query-String, und die Spezifikation wird dem Request-Body zugeordnet:

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

Die Antwort ist ein länger andauernder Vorgang:

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

Fragen Sie den Vorgang ab, bis donetrue ist:

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

Nach Abschluss wird das response des Vorgangs in das Snapshot entpackt:

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

Größenfelder sind int64 Werte, die als Zeichenketten serialisiert werden.

Bestätigen Sie, dass der Schnappschuss verfügbar ist, indem Sie ihn direkt abholen.

Für weitere Informationen zu langlaufenden Betrieben siehe Langlaufende Betriebe.

Erstellen eines Sicherungszeitplans

Planen Sie automatisierte Momentaufnahmen, die in regelmäßigen Abständen (täglich, wöchentlich oder monatlich) ausgeführt werden, um konsistente Sicherungen ohne manuelle Eingriffe sicherzustellen. Sicherungszeitpläne sind pro Verzweigung konfiguriert und gelten nur für Stammzweige. Der Grenzwert für manuelle Momentaufnahmen (siehe Project-Grenzwerte) gilt nicht für geplante Momentaufnahmen.

Jeder Wurzelzweig hat einen einzigen Backup-Plan, der eine Liste von Kadenzen enthält. Sie lesen den Zeitplan und ersetzen dessen Rhythmen an Ort und Stelle. Es gibt keine separate Erstellungs- oder Löschoperation, und das Setzen einer leeren Liste deaktiviert automatisierte Snapshots. Konfigurieren Sie den Zeitplan in der Lakebase-App oder programmatisch mit der Backup-Schedule-API vom Python SDK, Java SDK, Databricks CLI, Terraform, Databricks Asset Bundles oder Curl.

Note

Programmatischer Zugriff auf Backup-Zeitpläne befindet sich in Beta und steht allen Lakebase-Arbeitsbereichen zur Verfügung.

Benutzeroberfläche

So erstellen oder ändern Sie einen Sicherungszeitplan:

Klicken Sie auf der Seite " Sicherung und Wiederherstellung " in Ihrem Projekt auf " Zeitplan bearbeiten ", um das Konfigurationsdialogfeld für den Sicherungszeitplan zu öffnen.
Wählen Sie eine Zeitplanhäufigkeit aus den folgenden Optionen aus:
- Kein Zeitplan – Deaktiviert automatisierte Momentaufnahmen (Standard)
- Täglich – Erstellt täglich eine Momentaufnahme zu einem bestimmten Zeitpunkt.
- Wöchentlich – Erstellt eine Momentaufnahme an einem bestimmten Wochentag
- Monatlich – Erstellt eine Momentaufnahme an einem bestimmten Tag des Monats.
Konfigurieren Sie die Zeitplandetails basierend auf Ihrer ausgewählten Häufigkeit. Geben Sie an, wie oft Momentaufnahmen erstellt werden sollen und wie lange sie beibehalten werden sollen.

Nach der Konfiguration werden vom Zeitplan erstellte Momentaufnahmen auf der Seite " Sicherung und Wiederherstellung " mit einer Bezeichnung angezeigt, die angibt, dass sie automatisch erstellt wurden.

Python SDK

Lies den Zeitplan mit get_snapshot_scheduleund stell seine Rhythmen mit update_snapshot_scheduleein. update_snapshot_schedule nimmt den Ressourcennamen des Zeitplans als Argument name und ersetzt den gesamten Satz der Kadenzen. Um einen wöchentlichen Rhythmus festzulegen, der jeden Schnappschuss für 7 Tage hält, führen Sie Folgendes aus:

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

Um den aktuellen Zeitplan zu lesen, führen Sie Folgendes durch:

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

for cadence in schedule.schedule:
    print(cadence)

Java SDK

Um einen wöchentlichen Rhythmus festzulegen, der jeden Schnappschuss für 7 Tage hält, führen Sie Folgendes aus:

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

Benötigt Databricks CLI 1.16.0 und höher. Lies den Zeitplan mit get-snapshot-schedule und stelle ihn mit update-snapshot-schedule ein. Das zweite Argument ist die Update-Maske, die muss sein schedule. Das Festlegen des Zeitplans ersetzt die gesamte Gruppe von Taktungen und ist ein langwieriger Vorgang; daher wartet der Befehl auf dessen Abschluss, sofern Sie nicht --no-wait übergeben.

Um den aktuellen Zeitplan zu lesen, führen Sie Folgendes durch:

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

Um einen wöchentlichen Rhythmus festzulegen, der jeden Schnappschuss für 7 Tage hält, führen Sie Folgendes aus:

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

Um automatisierte Snapshots zu deaktivieren, setzen Sie einen leeren Zeitplan:

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

Terraform

Verwalten Sie den Zeitplan mit einer databricks_postgres_snapshot_schedule Ressource. Setzen Sie parent auf den Namen der Branch-Ressource; der eigene name des Zeitplans wird davon abgeleitet. Das Attribut schedule ist eine Liste von Kadenzwerten, und beim Anwenden der Ressource wird der Kadenzsatz des Zweigs ersetzt:

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

Definiere den Zeitplan unter dem postgres_snapshot_schedules Schlüssel in deiner Bundle-Konfiguration. Legen Sie branch auf den Namen der Branch-Ressource fest. Durch das Bereitstellen des Bundles wird der Kadenzsatz der Verzweigung ersetzt:

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

Rufe den Zeitplan mit GET auf und stelle ihn mit PATCH ein. Das Update ersetzt den gesamten Kadenzsatz. Gib daher alle Kadenzen an, die du beibehalten möchtest, und übergebe update_mask=schedule.

Um den aktuellen Zeitplan zu lesen, führen Sie Folgendes durch:

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

Das Aktualisieren des Zeitplans ist eine langjährige Aufgabe. Um einen wöchentlichen Rhythmus festzulegen, der jeden Schnappschuss für 7 Tage hält, führen Sie Folgendes aus:

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

Fragen Sie den zurückgegebenen Vorgang ab, bis donetrue ist. Siehe Lang andauernde Vorgänge. Das Ergebnis der abgeschlossenen Operation response wird zu SnapshotSchedule entpackt.

Um automatisierte Snapshots zu deaktivieren, setzen Sie einen leeren Zeitplan:

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

Kadenz- und Retentionsreferenz

Jeder Rhythmus in einem Zeitplan ist genau eine der folgenden Wiederholungen, die in UTC über eine ganze Stunde aufgenommen werden. Minuten und Sekunden werden nicht unterstützt.

Täglich: Set hour (0–23).
Wöchentlich: setzen day_of_week (MONDAY bis SUNDAY) und hour (0–23).
Monatlich: day (1–31, auf den letzten Tag kürzerer Monate begrenzt) und hour (0–23) festlegen.

Jede Kadenz legt außerdem eine Dauer retention fest, nach der ihre Schnappschüsse ablaufen:

Die Aufbewahrungsdauer muss mindestens 1 Stunde und darf höchstens 35 Tage betragen.
Die Aufbewahrung gilt, wenn ein Schnappschuss gemacht wird und nicht rückwirkend erfolgt. Bestehende Snapshots behalten ihr ursprüngliches Ablaufdatum. Nur Schnappschüsse, die nach der Änderung erstellt wurden, verwenden die neue Aufbewahrungsdauer.
Wenn im selben Fenster mehr als eine Kadenz fällig ist, erstellt Lakebase einen einzelnen Schnappschuss und behält ihn für die längste Erinnerung unter den passenden Kadenzen.

Das Lesen und Aktualisieren des Zeitplans erfordert beide die Erlaubnis CAN_USE für das Projekt.

Aufbewahrung von Momentaufnahmen

Momentaufnahmen werden nach Ablauf des Aufbewahrungszeitraums automatisch gelöscht. Sie können die Aufbewahrungseinstellungen jederzeit anpassen, indem Sie den Zeitplan bearbeiten. Beachten Sie Folgendes:

Kürzere Aufbewahrungszeiträume helfen bei der Verwaltung der Anzahl geplanter Momentaufnahmen.
Gelöschte Momentaufnahmen können nicht wiederhergestellt werden.
Manuelle Momentaufnahmen sind von den Aufbewahrungseinstellungen für den Sicherungszeitplan nicht betroffen.

Snapshots abrufen und auflisten

Sehen Sie Ihre Schnappschüsse auf der Seite Backup & Restore in der Lakebase-App an oder rufen Sie sie programmatisch mit der API ab.

Momentaufnahmen auflisten

Benutzeroberfläche

Auf der Seite Backup & Restore in der Lakebase-App werden Ihre Schnappschüsse nach Datum aufgelistet, wobei das Datum und die Größe jedes Schnappschusss angezeigt werden. Geplante Schnappschüsse erscheinen in derselben Liste mit einem Label, das anzeigt, dass sie automatisch erstellt wurden.

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

cURL

Liste die Schnappschüsse in einem Projekt auf. Verwenden Sie page_size und page_token, um durch die Ergebnisse zu blättern. Ein leeres next_page_token Zeichen zeigt die letzte Seite an:

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

Erhalte einen einzelnen Schnappschuss

Holen Sie die Details eines Schnappschusses anhand seiner ID ab. Im Gegensatz zum Erstellen und Löschen gibt get die Ressource Snapshot direkt zurück (es ist keine langlaufende Operation). Bei Lesevorgängen wird die Ablaufzeit entweder als expire_time oder no_expiry angegeben.

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

cURL

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

Wiederherstellen aus einer Momentaufnahme

Um einen Snapshot zu verwenden, stellen Sie ihn wieder her, indem Sie daraus einen neuen Branch erstellen. Es gibt keine Wiederherstellung vor Ort: Ihr aktueller Branch bleibt unverändert, und ein neuer Root-Branch wird mit den Snapshot-Daten erstellt.

Benutzeroberfläche

Auf der Seite "Sicherung und Wiederherstellung " in der Lakebase-App werden Momentaufnahmen nach Datum aufgelistet. Suchen Sie die Momentaufnahme, die Sie wiederherstellen möchten, und klicken Sie auf "Wiederherstellen". Es wird ein Bestätigungsdialogfeld angezeigt, in dem erläutert wird, was passiert: Die Wiederherstellung erfolgt sofort, Ihr aktueller Branch bleibt unverändert, und ein neuer Branch wird mit einem Namen wie branch_from_snapshot_ gefolgt vom Snapshot-Datum und der Snapshot-Zeit erstellt. Vergewissern Sie sich, dass Sie den Vorgang ausführen möchten, indem Sie auf "Wiederherstellen" klicken. Mit den Momentaufnahmedaten wird ein neuer Stammzweig erstellt. Ihre aktuelle Verzweigung bleibt unverändert.

Nach Abschluss der Wiederherstellung wird eine Erfolgsmeldung und die Branch-Übersichtsseite für die neue Verzweigung angezeigt. Im Abschnitt "Mit der neuen Verzweigung verbinden, um wiederhergestellte Daten zu überprüfen" wird erläutert, dass Sie eine Verbindung von Ihrer Anwendung oder Ihrem Client herstellen können, um die wiederhergestellten Daten zu überprüfen.

Verzweigungsübersicht nach der Wiederherstellung aus einer Momentaufnahme

Klicken Sie auf "Verbindungsdetails abrufen" , um ein Dialogfeld mit den Verbindungsinformationen der neuen Verzweigung zu öffnen: Verzweigung, Berechnung, Datenbank, Rolle und eine Verbindungszeichenfolge, die Sie kopieren können. Die Berechnung der Verzweigung kann während des Starts als „Ausstehend“ angezeigt werden. Sobald sie aktiv ist, können Sie die Verbindungszeichenfolge verwenden, um eine Verbindung herzustellen.

Andere Dinge, die Sie mit Ihrem neuen Zweig tun können:

Zeigen Sie eine Vorschau der Daten an. Verwenden Sie die Verbindungsdetails der neuen Verzweigung, um die Daten zu überprüfen und die Wiederherstellung zu bestätigen, bevor Sie die Anwendungskonfiguration ändern. Siehe Herstellen einer Verbindung mit Ihrer Datenbank.
Benennen Sie die Verzweigung um. Geben Sie dem Branch einen klareren Namen aus der Branch-Übersicht oder Branch-Liste. Siehe Verzweigungseinstellungen aktualisieren.
Als Standard festlegen. Wenn Sie mit den wiederhergestellten Daten zufrieden sind, können Sie diese Verzweigung als Standardverzweigung des Projekts festlegen. Siehe "Als Standard festlegen".
Richten Sie für Ihre Anwendung einen Verweis auf die neue Verzweigung ein. Nachdem Sie sicher sind, dass die Daten korrekt sind, aktualisieren Sie die Verbindungseinstellungen Ihrer Anwendung, um die Verbindungsdetails dieser Verzweigung zu verwenden.
Entfernen oder Beibehalten des vorherigen Zweigs. Sie können die zuvor verwendete Verzweigung löschen, wenn Sie sie nicht mehr benötigen, oder sie als Sicherung beibehalten. Siehe "Verzweigung löschen".

Sie können die neue Verzweigung und alle Projektzweige über die Seite "Verzweigungen " des Projekts verwalten, auf der die wiederhergestellte Verzweigung zusammen mit ihren anderen Verzweigungen als Stammzweig angezeigt wird.

Python SDK

Es gibt keine eigenständige Wiederherstellungsfunktion. Erstellen Sie eine Verzweigung, bei der source_snapshot auf den Ressourcennamen de Momentaufnahme gesetzt ist. Dadurch wird das Erstellen eines Branches über den Wiederherstellungspfad geleitet, wodurch ein neuer Stamm-Branch mit den Daten des Snapshots erzeugt wird. source_snapshot schließt sich gegenseitig mit source_branch, source_branch_lsn und source_branch_time aus, und die Verzweigung erfordert weiterhin ein Ablaufdatum (no_expiry, ttl oder expire_time). Das Setzen von replace_existing: true zusammen mit source_snapshot aktualisiert oder erstellt einen vorhandenen Ziel-Branch, ein idempotenter Wiederherstellungsvorgang.

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

Stellen Sie einen Snapshot wieder her, indem Sie ein databricks_postgres_branch deklarieren, bei dem source_snapshot in spec festgelegt ist. Die Terraform-Unterstützung für Schnappschüsse ist auf diesen Wiederherstellungspfad beschränkt – es gibt keine Terraform-Ressource zum Erstellen, Auflisten oder Löschen von Schnappschüssen.

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

Es gibt keine eigenständige Wiederherstellungsfunktion. Um einen Snapshot wiederherzustellen, erstellen Sie einen neuen Branch und setzen Sie source_snapshot in der Branch-Spezifikation auf den Ressourcennamen des Snapshots. Dies leitet die Branch-Erstellung durch den Wiederherstellungspfad und erzeugt einen neuen Root-Branch, der die Daten des Snapshots enthält. Ihre bestehenden Branches bleiben unverändert.

source_snapshot ist gegenseitig ausschließend mit source_branch, source_branch_lsn, und source_branch_time. Das Setzen von replace_existing: true zusammen mit source_snapshot aktualisiert oder erstellt einen vorhandenen Ziel-Branch, ein idempotenter Wiederherstellungsvorgang. Der referenzierte Snapshot muss AVAILABLE sein und zum selben Projekt gehören wie der neue Branch.

Erstelle den Zweig aus dem Snapshot. Der branch_id steht im 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
    }
  }'

Fragen Sie den zurückgegebenen Vorgang ab, bis donetrue ist. Die abgeschlossene Operation wird in die neue Branch entpackt.
Verbinden Sie sich mit dem neuen Zweig, um die wiederhergestellten Daten zu überprüfen, bevor Sie Ihre Anwendung darauf verweisen. Siehe Branch erstellen und mit Ihrer Datenbank verbinden.

Löschen Sie einen Snapshot

Gelöschte Schnappschüsse können nicht wiederhergestellt werden.

Benutzeroberfläche

Suchen Sie auf der Seite Backup & Restore in der Lakebase-App den Snapshot in der Liste, öffnen Sie dessen Kebab-Menü-Symbol Kebab-Menü und wählen Sie Momentaufnahme löschen aus.

Python SDK

Das Löschen eines Schnappschusses ist eine langwierige Operation. Rufen Sie .wait() auf, um zu blockieren, bis der Vorgang abgeschlossen ist.

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

cURL

Das Löschen eines Schnappschusses ist eine langwierige Operation. Die Anfrage gibt eine Operation zurück. Die Antwort auf die abgeschlossene Operation ist leer.

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

Fragen Sie den zurückgegebenen Vorgang ab, bis donetrue ist.

Speicherkosten für Momentaufnahmen

Ab dem 1. Juni 2026 ist der Snapshot-Speicher für Lakebase kostenpflichtig.

Die Abrechnung basiert auf dem Typ der Momentaufnahme:

Manuelle Momentaufnahmen werden als vollständige Momentaufnahmen in Rechnung gestellt.
Geplante Momentaufnahmen werden als vollständige Momentaufnahmen für die erste Momentaufnahme in einem Zeitplan und dann als inkrementeller Speicher (Delta) für nachfolgende geplante Momentaufnahmen in Rechnung gestellt.

Die Größe jeder Momentaufnahme wird auf der Seite " Sicherung und Wiederherstellung " angezeigt. Details zu den Preisen finden Sie auf der Lakebase-Preisseite.

Einschränkungen

Die Snapshots-API hat folgende Einschränkungen:

Momentaufnahmen sind unveränderlich. Es gibt keinen Update-Vorgang. Der Quellzweig, die Zeitpunktauswahl und der Ablaufzeitpunkt werden bei der Erstellung festgelegt und können nicht geändert werden.
Keine Wiederherstellung vor Ort. Du stellst einen Snapshot nur wieder, indem du daraus einen neuen Zweig erstellst.
Dasselbe Projekt, verfügbarer Snapshot. Der Quell-Snapshot muss sich im Zustand AVAILABLE befinden und zum selben Projekt wie der neue Branch gehören.
Sich gegenseitig ausschließende Wiederherstellungsfelder. Bei der Anfrage zum Erstellen eines Branches kann source_snapshot nicht mit source_branch, einer Branch-LSN oder einem Branch-Zeitstempel kombiniert werden. Es kann mit replace_existing kombiniert werden, um einen vorhandenen Ziel-Branch zu aktualisieren oder zu erstellen.
Terraform. Der Provider unterstützt die Wiederherstellung aus einer Momentaufnahme nur über das Argument source_snapshot auf databricks_postgres_branch. Es gibt keine Terraform-Ressource zum Erstellen, Auflisten oder Löschen von Snapshots.
Beta-Verfügbarkeit. Die Snapshots-API befindet sich in der Beta und steht allen Lakebase-Arbeitsbereichen zur Verfügung.

Filialen – Wie die Verzweigung in Lakebase funktioniert
Lakebase API-Leitfaden — Authentifizierung, Ressourcenbenennung und langjährige Operationen

Feedback

War diese Seite hilfreich?

Zuletzt aktualisiert um 2026-09-30

Schnappschüsse

Gründe für die Verwendung von Momentaufnahmen

Manuelles Erstellen von Momentaufnahmen

Erstellen einer Momentaufnahme

Benutzeroberfläche

Python SDK

Java SDK

CLI

cURL

Erstellen eines Sicherungszeitplans

Benutzeroberfläche

Python SDK

Java SDK

CLI

Terraform

Databricks-Ressourcenpakete

cURL

Kadenz- und Retentionsreferenz

Aufbewahrung von Momentaufnahmen

Snapshots abrufen und auflisten

Momentaufnahmen auflisten

Benutzeroberfläche

Python SDK

Java SDK

CLI

cURL

Erhalte einen einzelnen Schnappschuss

Python SDK

Java SDK

CLI

cURL

Wiederherstellen aus einer Momentaufnahme

Benutzeroberfläche

Python SDK

Java SDK

CLI

Terraform

cURL

Löschen Sie einen Snapshot

Benutzeroberfläche

Python SDK

Java SDK

CLI

cURL

Speicherkosten für Momentaufnahmen

Einschränkungen

Related

Feedback

Zusätzliche Ressourcen