Migawki

Migawka jest uchwyceniem stanu głównej gałęzi projektu w danym punkcie w czasie, obejmującym schemat oraz wszystkie dane. Usługa Lakebase tworzy migawki natychmiast z minimalnym wpływem na wydajność. Użyj ich jako punktu tworzenia kopii zapasowej lub przywracania.

Możesz tworzyć, przywracać i zarządzać snapshotami w aplikacji Lakebase lub pracować z nimi programowo za pomocą snapshots API z Python SDK, Java SDK, Databricks CLI lub curl. Terraform może przywrócić z migawki przez utworzenie gałęzi. Gdy operacja jest dostępna na więcej niż jeden sposób, instrukcje są wyświetlane razem jako zakładki.

Note

Od 1 czerwca 2026 roku przechowywanie zdjęć jest rozliczane w Lakebase. Zobacz Koszty przechowywania migawek.

Kiedy należy używać migawek

Migawki są przydatne w przypadku zwykłych kopii zapasowych lub przed wprowadzeniem zmian schematu lub innych potencjalnie destrukcyjnych operacji. Zapewniają one szybki sposób na utworzenie punktów przywracania, które można wykorzystać w razie potrzeby.

Ręczne tworzenie migawek

Zrzuty przechwytują stan gałęzi w danym momencie. Migawki można tworzyć ręcznie tylko na gałęziach root. Migawki ręczne są ograniczone do 10 na projekt (zobacz Limity projektów). Możesz przywrócić te migawki z dowolnej gałęzi w obrębie projektu.

Tworzenie migawki

Migawki są tworzone natychmiast i są przydatne przed wprowadzeniem znaczących zmian w schemacie lub danych.

interfejs użytkownika

Wejdź do swojego projektu w aplikacji Lakebase i wybierz Backup & Restore w nawigacji gałęzi. Kliknij Utwórz migawkę, aby przechwycić bieżący stan danych.

Edytor SQL z wstępnie załadowanym przykładowym kodem SQL

Zestaw SDK dla języka Python

create_snapshot zwraca operację długotrwałą. Wywołaj .wait(), aby czekać, aż migawka będzie dostępna. Wynikiem jest Snapshot. source_branch jest wymagany, a także wymagany jest czas wygaśnięcia: ustaw dokładnie jedną z wartości ttl, expire_time lub no_expiry. Opcjonalnie przypnij punkt w czasie za pomocą source_branch_lsn lub 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

Element snapshot_id jest argumentem położeniowym po nazwie projektu. Specyfikacja odpowiada treści --json:

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

curl

Tworzenie migawki to długotrwała operacja. Żądanie zwraca operację, której stan regularnie sprawdzasz aż do jej zakończenia. Ukończona operacja jest rozpakowywana do zasobu Snapshot. W praktyce migawka szybko staje się AVAILABLE.

Specyfikacja migawki wymaga elementu source_branch. Skonfiguruj punkt czasowy i czas wygaśnięcia w następujący sposób:

Moment w czasie (opcjonalnie): ustaw source_branch_lsn albo source_branch_time (wzajemnie wykluczające się). Pomiń oba elementy, aby zrobić migawkę z aktualnej głowy gałęzi.
Termin wygaśnięcia (wymagany): ustaw dokładnie jeden z expire_time (znacznik czasu RFC 3339, który musi być w przyszłości), ttl (czas trwania w sekundach, np. "604800s"), lub no_expiry: true.

snapshot_id jest wymagany, wybierasz go samodzielnie i nie można go zmienić po utworzeniu.

Wyślij żądanie utworzenia. Element snapshot_id trafia do parametrów zapytania, a specyfikacja odpowiada treści żądania:

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

Odpowiedź to długotrwała operacja:

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

Sprawdzaj operację, aż done będzie mieć wartość true:

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

Po zakończeniu element operacji response zostaje rozpakowany do 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"
    }
  }
}

Pola rozmiaru to int64 wartości serializowane jako ciągi znaków.

Potwierdź, że migawka jest dostępna, pobierając ją bezpośrednio.

Więcej informacji o długoterminowych operacjach można znaleźć w artykule Długoterminowe operacje.

Tworzenie harmonogramu tworzenia kopii zapasowych

Zaplanuj automatyczne migawki, aby uruchamiały się w regularnych odstępach czasu (codziennie, co tydzień lub co miesiąc), aby utrzymywać spójne kopie zapasowe bez ręcznej interwencji. Harmonogramy tworzenia kopii zapasowych są konfigurowane na gałąź i mają zastosowanie tylko do gałęzi głównych. Limit ręcznych migawek (zobacz Limity projektów) nie ma zastosowania do zaplanowanych migawek.

Każda gałąź główna ma jeden harmonogram kopii zapasowych obejmujący listę częstotliwości. Czytasz harmonogram i przywracasz jego rytm. Nie ma osobnej operacji tworzenia ani usuwania, a ustawienie pustej listy wyłącza automatyczne migawki. Konfiguruj harmonogram w aplikacji Lakebase lub programowo za pomocą API harmonogramu kopii zapasowych z Python SDK, Java SDK, Databricks CLI, Terraform, Databricks Asset Bundles lub curl.

interfejs użytkownika

Aby utworzyć lub zmodyfikować harmonogram tworzenia kopii zapasowych:

Na stronie Tworzenie kopii zapasowej i przywracanie w projekcie kliknij pozycję Edytuj harmonogram , aby otworzyć okno dialogowe konfiguracji harmonogramu tworzenia kopii zapasowych.
Wybierz częstotliwość harmonogramu z następujących opcji:
- Brak harmonogramu — wyłącza automatyczne migawki (ustawienie domyślne)
- Codziennie — tworzy migawkę codziennie o określonej godzinie
- Co tydzień — tworzy migawkę w określonym dniu tygodnia
- Co miesiąc — tworzy migawkę w określonym dniu miesiąca
Skonfiguruj szczegóły harmonogramu na podstawie wybranej częstotliwości. Określ, jak często chcesz migawki tworzyć i jak długo je przechowywać.

Po skonfigurowaniu, migawki utworzone według harmonogramu pojawiają się na stronie Kopia zapasowa i przywracanie z etykietą wskazującą, że zostały utworzone automatycznie.

Zestaw SDK dla języka Python

Odczytuj harmonogram za pomocą get_snapshot_schedule, a jego częstotliwości ustaw za pomocą update_snapshot_schedule. update_snapshot_schedule przyjmuje nazwę zasobu harmonogramu jako argument name i zastępuje cały zestaw częstotliwości. Aby ustalić tygodniowy rytm, który utrzymuje każde zdjęcie przez 7 dni, wykonaj następujące:

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

Aby odczytać bieżący harmonogram, uruchom następujące polecenie:

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

for cadence in schedule.schedule:
    print(cadence)

Java SDK

Aby ustalić tygodniowy rytm, który utrzymuje każde zdjęcie przez 7 dni, wykonaj następujące:

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

Wymaga interfejsu wiersza poleceń Databricks w wersji 1.16.0 lub nowszej. Odczytaj harmonogram za pomocą get-snapshot-schedule, a ustaw go za pomocą update-snapshot-schedule. Drugim argumentem jest maska aktualizacji, która musi mieć wartość schedule. Ustawienie harmonogramu zastępuje cały zestaw harmonogramów i jest operacją długotrwałą, więc polecenie czeka na jej zakończenie, chyba że podasz --no-wait.

Aby odczytać bieżący harmonogram, uruchom następujące polecenie:

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

Aby ustalić tygodniowy rytm, który utrzymuje każde zdjęcie przez 7 dni, wykonaj następujące:

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

Aby wyłączyć automatyczne migawki, ustaw pusty harmonogram:

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

Terraform

Zarządzaj harmonogramem za pomocą zasobów databricks_postgres_snapshot_schedule . Ustaw dla elementu parent nazwę zasobu gałęzi; własna name harmonogramu jest z niej wyprowadzona. Atrybut schedule to lista cykli, a zastosowanie zasobu zastępuje zestaw cykli gałęzi:

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

Pakiety zasobów Databricks

Zdefiniuj harmonogram pod kluczem postgres_snapshot_schedules w konfiguracji pakietu. Ustaw branch na nazwę zasobu gałęzi. Wdrożenie pakietu zastępuje zestaw harmonogramów gałęzi:

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

Odczytaj harmonogram za pomocą GET, a ustaw go za pomocą PATCH. Aktualizacja zastępuje cały zestaw kadencji, więc uwzględnij każdą kadencję, którą chcesz zachować, i przekaż update_mask=schedule.

Aby odczytać bieżący harmonogram, uruchom następujące polecenie:

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

Aktualizacja harmonogramu to operacja trwająca od dawna. Aby ustalić tygodniowy rytm, który utrzymuje każde zdjęcie przez 7 dni, wykonaj następujące:

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

Sprawdzaj zwróconą operację, aż done będzie mieć wartość true. Zobacz Długotrwałe operacje. Zakończona operacja response rozpakowuje się do .SnapshotSchedule

Aby wyłączyć automatyczne migawki, ustaw pusty harmonogram:

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

Odniesienie do kadencji i retencji

Każdy cykl w harmonogramie to dokładnie jeden z następujących typów powtórzeń, przypadający dokładnie na pełną godzinę w UTC. Minuty i sekundy nie są obsługiwane.

Codziennie: ustalona hour (0–23).
Co tydzień: ustaw day_of_week (od MONDAY do SUNDAY) i hour (0–23).
Miesięcznie: ustalane day (1–31, ograniczone do ostatniego dnia krótszych miesięcy) oraz hour (0–23).

Każdy harmonogram określa również czas trwania retention, po upływie którego jego migawki wygasają:

Zatrzymanie musi trwać co najmniej 1 godzinę, a maksymalnie 35 dni.
Retencja dotyczy momentu wykonania snapshotu i nie jest wsteczna. Istniejące migawki zachowują swój pierwotny termin ważności. Tylko migawki utworzone po wprowadzeniu zmiany podlegają nowym ustawieniom retencji.
Jeśli w tym samym oknie przypada więcej niż jeden harmonogram, Lakebase tworzy pojedynczą migawkę i przechowuje ją przez najdłuższy okres przechowywania spośród pasujących harmonogramów.

Zarówno odczyt, jak i aktualizacja harmonogramu wymagają uprawnienia CAN_USE w projekcie.

Przechowywanie kopii zapasowych

Migawki są usuwane automatycznie po upływie okresu przechowywania. Ustawienia przechowywania można dostosować w dowolnym momencie, edytując harmonogram. Należy pamiętać:

Krótsze okresy przechowywania ułatwiają zarządzanie liczbą przechowywanych zaplanowanych migawek.
Nie można odzyskać usuniętych migawek
Ręczne migawki nie mają wpływu na ustawienia przechowywania harmonogramu kopii zapasowych

Pobierz i wyświetl listę migawek

Zobacz swoje migawki na stronie Backup & Restore w aplikacji Lakebase lub pobierz je programowo za pomocą API.

Wylistuj migawki

interfejs użytkownika

Na stronie Backup & Restore w aplikacji Lakebase Twoje snapshoty są wymienione według daty, pokazując datę i rozmiar każdego snapshota. Zaplanowane migawki pojawiają się na tej samej liście, z etykietą informującą, że zostały utworzone automatycznie.

Zestaw SDK dla języka Python

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

Wyświetl migawki w projekcie. Użyj page_size i page_token, aby przechodzić między stronami wyników. Puste next_page_token oznacza ostatnią stronę:

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

Zrób pojedyncze zdjęcie

Pobierz dane jednego zdjęcia według jego identyfikatora. W przeciwieństwie do create and delete, get zwraca zasób Snapshot bezpośrednio (nie jest to operacja długotrwała). Przy odczycie czas wygaśnięcia jest podawany jako expire_time albo no_expiry.

Zestaw SDK dla języka Python

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

Przywracanie z migawki

Aby użyć migawki, przywróć ją, tworząc z niej nową gałąź. Nie ma przywracania na miejscu: obecna gałąź pozostaje niezmieniona, a nowa gałąź główna jest tworzona z danymi migawkowymi.

interfejs użytkownika

Na stronie Kopia zapasowa i przywracanie w aplikacji Lakebase zrzuty są wyświetlane według daty. Znajdź migawkę, którą chcesz przywrócić, a następnie kliknij przycisk Przywróć. Zostanie wyświetlone okno dialogowe potwierdzenia z wyjaśnieniem, co się stanie: przywracanie zostanie wykonane natychmiast, gałąź bieżąca nadal będzie niezmieniona, a nowa gałąź zostanie utworzona z nazwą branch_from_snapshot_, zawierającą datę i godzinę migawki. Upewnij się, że chcesz wykonać operację, klikając pozycję Przywróć. Zostanie utworzona nowa gałąź główna z danymi migawki. Bieżąca gałąź pozostaje niezmieniona.

Po zakończeniu przywracania zostanie wyświetlony komunikat o powodzeniu i strona Przegląd gałęzi dla nowej gałęzi. Sekcja zatytułowana Łączenie z nową gałęzią w celu wyświetlenia podglądu przywróconych danych wyjaśnia, że możesz nawiązać połączenie z poziomu aplikacji lub klienta w celu zweryfikowania przywróconych danych.

Przegląd gałęzi po przywróceniu z migawki

Kliknij pozycję Pobierz szczegóły połączenia , aby otworzyć okno dialogowe z informacjami o połączeniu nowej gałęzi: gałąź, obliczenia, baza danych, rola i parametry połączenia, które można skopiować. Obliczenia gałęzi mogą być wyświetlane jako "Oczekujące" podczas uruchamiania. Po jego aktywacji można użyć ciągu połączenia do nawiązania połączenia.

Inne czynności, które można wykonać za pomocą nowej gałęzi:

Wyświetl podgląd danych. Użyj szczegółów połączenia nowej gałęzi, aby sprawdzić dane i potwierdzić przywracanie przed zmianą konfiguracji aplikacji. Zobacz Nawiązywanie połączenia z bazą danych.
Zmień nazwę gałęzi. Nadaj gałęzi bardziej przejrzystą nazwę, korzystając z przeglądu gałęzi lub listy gałęzi. Zobacz Aktualizowanie ustawień gałęzi.
Ustaw jako wartość domyślną. Jeśli dane przywrócone są zadowalające, możesz ustawić tę gałąź jako gałąź domyślną projektu. Zobacz Ustawianie jako domyślne.
Wskaż aplikację na nową gałąź. Po upewnieniu się, że dane są poprawne, zaktualizuj ustawienia połączenia aplikacji, aby użyć szczegółów połączenia tej gałęzi.
Usuń lub zachowaj poprzednią gałąź. Możesz usunąć gałąź używaną wcześniej, jeśli nie jest już potrzebna, lub zachować ją jako kopię zapasową. Zobacz Usuwanie gałęzi.

Nową gałąź i wszystkie gałęzie projektu można zarządzać na stronie Gałęzie projektu, gdzie przywrócona gałąź jest wyświetlana jako gałąź główna obok innych gałęzi.

Zestaw SDK dla języka Python

Nie ma oddzielnej operacji przywracania. Utwórz gałąź, ustawiając source_snapshot na nazwę zasobu migawki. Powoduje to, że tworzenie gałęzi odbywa się przez ścieżkę odtwarzania, w wyniku czego powstaje nowa gałąź główna z danymi ze snapshotu. source_snapshot wzajemnie się wyklucza z source_branch, source_branch_lsn i source_branch_time, a gałąź nadal wymaga terminu wygaśnięcia (no_expiry, ttl lub expire_time). Ustawienie replace_existing: true razem z source_snapshot powoduje operację upsert na istniejącej gałęzi docelowej, czyli idempotentne przywrócenie.

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

Przywróć z migawki, deklarując databricks_postgres_branch z ustawionym source_snapshot w jego spec. Wsparcie Terraform dla snapshotów ogranicza się do tej ścieżki przywracania — nie ma zasobu Terraform do tworzenia, umieszczania lub usuwania snapshotów.

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

Nie ma oddzielnej operacji przywracania. Aby przywrócić migawkę, utwórz nową gałąź i ustaw w specyfikacji gałęzi pole source_snapshot na nazwę zasobu migawki. Powoduje to utworzenie gałęzi za pośrednictwem procesu przywracania, w wyniku czego powstaje nowa gałąź główna zawierająca dane migawki. Twoje istniejące oddziały pozostają bez zmian.

source_snapshot wzajemnie się wyklucza z source_branch, source_branch_lsn oraz source_branch_time. Ustawienie replace_existing: true razem z source_snapshot powoduje operację upsert na istniejącej gałęzi docelowej, czyli idempotentne przywrócenie. Wskazana migawka musi być AVAILABLE i należeć do tego samego projektu co nowa gałąź.

Utwórz gałąź na podstawie migawki. branch_id trafia do ciągu zapytania:

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

Sprawdzaj zwróconą operację, aż done będzie mieć wartość true. Ukończona operacja zostaje rozpakowana do nowego elementu Branch.
Połącz się z nową gałęzią, aby zweryfikować przywrócone dane, zanim skierujesz do niej swoją aplikację. Zobacz Utwórz gałąź i połącz się z bazą danych.

Usuń migawkę

Usuniętych snapshotów nie da się odzyskać.

interfejs użytkownika

Na stronie Backup & Restore w aplikacji Lakebase znajdź migawkę na liście, otwórz ikonę menu Kebab . menu kebabu i wybierz Usuń migawkę.

Zestaw SDK dla języka Python

Usunięcie migawki to operacja długotrwała. Wywołaj .wait(), aby zablokować wykonywanie do momentu jego zakończenia.

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

Usunięcie migawki to operacja długotrwała. Żądanie zwraca operację. Odpowiedź zakończonej operacji jest pusta.

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

Sprawdzaj zwróconą operację, aż done będzie mieć wartość true.

Koszty przechowywania migawek

Od 1 czerwca 2026 roku przechowywanie zdjęć jest rozliczane w Lakebase.

Rozliczenie zależy od typu migawki:

Za migawki ręczne naliczane są opłaty jak za pełne migawki.
Zaplanowane migawki są rozliczane jako pełne migawki w przypadku pierwszej migawki w harmonogramie, a następnie jako przyrostowa pamięć masowa (delta) dla kolejnych zaplanowanych migawek.

Rozmiar każdej migawki jest wyświetlany na stronie Tworzenie kopii zapasowych i przywracanie . Aby uzyskać szczegółowe informacje o cenach, zobacz stronę cennika usługi Lakebase.

Limitations

API snapshots ma następujące ograniczenia:

Migawki są niemodyfikowalne. Nie ma żadnej operacji aktualizacji. Gałąź źródłowa, selektor punktu w czasie oraz czas wygaśnięcia są ustalane podczas tworzenia i nie można ich później zmienić.
Brak przywracania na miejscu. Przywracasz snapshot tylko przez utworzenie nowej gałęzi z niej.
Ten sam projekt, dostępna migawka. Migawka źródłowa musi znajdować się w AVAILABLE stanie i należeć do tego samego projektu co nowa gałąź.
Pola przywracania, które wzajemnie się wykluczają. W żądaniu utworzenia gałęzi elementu source_snapshot nie można łączyć z source_branch, numerem LSN gałęzi ani znacznikiem czasu gałęzi. Można go połączyć z replace_existing, aby zaktualizować istniejącą gałąź docelową lub utworzyć ją, jeśli nie istnieje.
Terraform. Dostawca wspiera przywracanie wyłącznie ze snapshotu, poprzez source_snapshot argument na databricks_postgres_branch. Nie ma zasobu Terraform do tworzenia, publikowania lub usuwania snapshotów.

Oddziały — Jak działa rozgałęzianie w Lakebase
Przewodnik API Lakebase — Uwierzytelnianie, nazewnictwo zasobów i długotrwałe operacje

Opinia

Czy ta strona była pomocna?

Ostatnia aktualizacja o 2026-09-30

Migawki

Kiedy należy używać migawek

Ręczne tworzenie migawek

Tworzenie migawki

interfejs użytkownika

Zestaw SDK dla języka Python

Java SDK

CLI

curl

Tworzenie harmonogramu tworzenia kopii zapasowych

interfejs użytkownika

Zestaw SDK dla języka Python

Java SDK

CLI

Terraform

Pakiety zasobów Databricks

curl

Odniesienie do kadencji i retencji

Przechowywanie kopii zapasowych

Pobierz i wyświetl listę migawek

Wylistuj migawki

interfejs użytkownika

Zestaw SDK dla języka Python

Java SDK

CLI

curl

Zrób pojedyncze zdjęcie

Zestaw SDK dla języka Python

Java SDK

CLI

curl

Przywracanie z migawki

interfejs użytkownika

Zestaw SDK dla języka Python

Java SDK

CLI

Terraform

curl

Usuń migawkę

interfejs użytkownika

Zestaw SDK dla języka Python

Java SDK

CLI

curl

Koszty przechowywania migawek

Limitations

Related

Opinia

Dodatkowe zasoby