Aperçus instantanés

Un instantané est une capture à un instant T de la Branch racine d'un projet, y compris le schéma et toutes les données. Lakebase crée des instantanés instantanément avec un impact minimal sur les performances. Utilisez-les comme sauvegarde ou point de restauration.

Vous pouvez créer, restaurer et gérer des instantanés dans l'application Lakebase, ou interagir avec eux par programmation à l'aide de l'API des instantanés du SDK Python, du SDK Java, de la CLI Databricks ou de curl. Terraform peut effectuer une restauration à partir d'un instantané en créant une Branch. Lorsqu'une opération est disponible de plusieurs manières, les instructions s'affichent ensemble sous forme d'onglets.

remarque

À partir du 1er juin 2026, le stockage des snapshots sera facturable pour Lakebase. Voir Coûts de stockage des snapshots.

Quand utiliser des snapshots

Les instantanés sont utiles pour les sauvegardes régulières ou avant d'apporter des modifications au schéma ou d'autres opérations potentiellement destructrices. Ils offrent un moyen rapide de créer des points de restauration à partir desquels vous pouvez restaurer si nécessaire.

Créer des instantanés manuellement

Les instantanés capturent l'état de votre Branch à un moment donné. Vous ne pouvez créer des instantanés manuellement que sur les branches racine. Les instantanés manuels sont limités à 10 par projet (voir Limites du projet). Vous pouvez restaurer ces instantanés à partir de n'importe quelle Branch de votre projet.

Créer un instantané.

Des instantanés sont créés instantanément et s'avèrent utiles avant d'apporter des modifications importantes à votre schéma ou à vos données.

UI

Accédez à votre projet dans l'application Lakebase et sélectionnez Backup & Restore dans la navigation des Branch. Cliquez sur Create snapshot pour capturer l'état actuel de vos données.

Python SDK

create_snapshot renvoie une opération de longue durée. Appelez .wait() pour bloquer jusqu'à ce que l'instantané soit disponible. Le résultat est Snapshot. source_branch est requis, tout comme une expiration : définissez exactement un des éléments ttl, expire_time ou no_expiry. Vous pouvez éventuellement pin un point dans le temps avec source_branch_lsn ou source_branch_time.

Python

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

Java

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

Le snapshot_id est un argument positionnel après le projet. La spécification correspond au corps --json :

Bash

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

curl

La création d’un instantané est une opération de longue durée. La requête renvoie une opération que vous interrogez jusqu'à ce qu'elle soit terminée. L'opération terminée se déploie vers la ressource Snapshot. En pratique, l'instantané devient rapidement AVAILABLE.

La spécification d'instantané requiert un source_branch. Configurez le point dans le temps et l'expiration comme suit :

• Point dans le temps (facultatif) : définissez soit source_branch_lsn, soit source_branch_time (exclusifs). Omettez les deux pour créer un instantané de la tête actuelle de la Branch.
• Expiration (obligatoire) : définissez exactement un des éléments suivants : expire_time (un Timestamp RFC 3339 qui doit être dans le futur), ttl (une durée en secondes, telle que "604800s"), ou no_expiry: true.

Le paramètre snapshot_id est obligatoire, est choisi par vos soins et ne peut pas être modifié après sa création.

1. Envoyez la requête de création. Le snapshot_id se trouve dans la chaîne de query, et la spécification correspond au corps de la requête :

   Bash

   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 réponse est une opération de longue durée :

   JSON

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

2. Poll the operation until done is true:

   Bash

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

   Une fois l'opération terminée, le paramètre response de l'opération se décompresse vers le Snapshot:

   JSON

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

   Les champs de taille sont des valeurs int64 sérialisées sous forme de chaînes.

3. Confirmez que l’instantané est disponible en le récupérant directement.

Pour plus d'information sur les opérations de longue durée, consultez Opérations de longue durée.

Créer un calendrier de sauvegarde

Planifiez des instantanés automatisés à intervalles réguliers (quotidiens, hebdomadaires ou mensuels) afin de garantir des sauvegardes cohérentes sans intervention manuelle. Les calendriers de sauvegarde sont configurés par Branch et ne s'appliquent qu'aux Branches racines. La limite sur les instantanés manuels (voir limites du projet) ne s'applique pas aux instantanés planifiés.

Chaque root Branch dispose d’un unique planning de sauvegarde qui contient une liste de cadences. Vous lisez le planning et remplacez ses cadences directement. Il n’y a pas d’opération de création ou de suppression distincte, et la définition d’une liste vide désactive les instantanés automatisés. Configurez le planning dans l’application Lakebase, ou par programmation avec l’API de planning d’instantanés depuis le SDK Python, le SDK Java, l’interface de ligne de commande Databricks, Terraform, les ensembles de ressources Databricks ou curl.

remarque

L’accès programmatique aux planifications de sauvegarde via l’API de planification des instantanés est en version bêta et disponible pour tous les Workspace Lakebase.

UI

Pour créer ou modifier un calendrier de sauvegarde :

1. Depuis la page **Sauvegarde et restauration** de votre projet, cliquez sur **Modifier le planning** pour ouvrir la boîte de dialogue de configuration du planning de sauvegarde.

   

2. Sélectionnez une fréquence de planification parmi les options suivantes :

   • Aucune planification – Désactive les instantanés automatiques (default)
   • Quotidien – Crée un instantané chaque jour à une heure spécifiée
   • Hebdomadaire – Crée un instantané un jour précis de la semaine
   • Mensuel – Crée un instantané un jour précis du mois

   

3. Configurez les détails de la planification en fonction de votre fréquence sélectionnée. Spécifiez la fréquence à laquelle vous souhaitez créer des instantanés et combien de temps les conserver.

Une fois configurés, les snapshots créés par le planning apparaissent sur la page Sauvegarde et restauration avec une étiquette indiquant qu'ils ont été créés automatiquement.

Python SDK

Lisez le planning avec get_snapshot_schedule, et définissez ses cadences avec update_snapshot_schedule. update_snapshot_schedule prend le nom de ressource du planning comme argument name et remplace l’ensemble des cadences. Pour définir une cadence hebdomadaire qui conserve chaque instantané pendant 7 jours, exécutez la commande suivante :

Python

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

Pour lire la planification actuelle, exécutez la commande suivante :

Python

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

for cadence in schedule.schedule:
    print(cadence)

Java SDK

Pour définir une cadence hebdomadaire qui conserve chaque instantané pendant 7 jours, exécutez la commande suivante :

Java

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

Nécessite Databricks CLI 1.16.0 ou une version ultérieure. Lire la programmation avec get-snapshot-schedule et la définir avec update-snapshot-schedule. Le deuxième argument est le masque de mise à jour, qui doit être schedule. La définition du calendrier remplace l'ensemble des cadences et constitue une opération longue ; par conséquent, la commande attend qu'elle soit terminée, sauf si vous transmettez --no-wait.

Pour lire la planification actuelle, exécutez la commande suivante :

Bash

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

Pour définir une cadence hebdomadaire qui conserve chaque instantané pendant 7 jours, exécutez la commande suivante :

Bash

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

Pour désactiver les instantanés automatisés, définissez une planification vide :

Bash

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

Terraform

Gérer la planification avec une ressource databricks_postgres_snapshot_schedule. Définissez parent sur le nom de la ressource de Branch ; le name propre à la planification en est dérivé. L'attribut schedule est une liste de cadences, et l'application de la ressource remplace l'ensemble des cadences de la Branch :

Hcl

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 Bundles

Définissez la planification sous la clé postgres_snapshot_schedules dans la configuration de votre bundle. Définissez branch sur le nom de la ressource de type branch. Le déploiement du bundle remplace l’ensemble des cadences de la branch :

YAML

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

Lisez la planification avec GET et configurez-la avec PATCH. La mise à jour remplace l’ensemble des cadences, veillez donc à inclure chaque cadence que vous souhaitez conserver, et passez update_mask=schedule.

Pour lire la planification actuelle, exécutez la commande suivante :

Bash

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

La mise à jour du planning est une opération de longue durée. Pour définir une cadence hebdomadaire qui conserve chaque instantané pendant 7 jours, exécutez la commande suivante :

Bash

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

Interroger l'opération renvoyée jusqu'à ce que done soit true. Voir Opérations de longue durée. L'élément response de l'opération terminée se décompresse vers SnapshotSchedule.

Pour désactiver les instantanés automatisés, définissez une planification vide :

Bash

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

Référence de cadence et de fidélisation

Chaque cadence d’une planification correspond exactement à l’une des récurrences suivantes, calculée à heure fixe en UTC. Les minutes et les secondes ne sont pas prises en charge.

• Daily : définir hour (0–23).
• Hebdomadaire : définir day_of_week (MONDAY à SUNDAY) et hour (0–23).
• Mensuel : définissez day (1–31, ramené au dernier jour des mois les plus courts) et hour (0–23).

Chaque cadence définit également une durée retention, après laquelle ses instantanés expirent :

• La durée de conservation doit être d’au moins 1 heure et de 35 jours au maximum.
• La rétention s’applique lorsqu’un instantané est pris et n’est pas rétroactive. Les instantanés existants conservent leur expiration d’origine. Seuls les instantanés pris après la modification utilisent la nouvelle rétention.
• Si plusieurs cadences sont prévues au cours de la même fenêtre, Lakebase crée un instantané unique et le conserve pour la durée de rétention la plus longue parmi les cadences correspondantes.

La lecture de la programmation nécessite l'autorisation CAN_USE sur le projet. La mise à jour de la programmation nécessite CAN_MANAGE.

Rétention d'instantanés

Les instantanés sont automatiquement supprimés après l'expiration de leur période de rétention. Vous pouvez ajuster les paramètres de rétention à tout moment en modifiant le planning. Gardez à l'esprit :

• Des périodes de rétention plus courtes aident à gérer le nombre de snapshots planifiés conservés.
• Les instantanés supprimés ne peuvent pas être récupérés
• Les instantanés manuels ne sont pas affectés par les paramètres de rétention de la planification des sauvegardes.

Obtenir et lister des instantanés

Consultez vos instantanés sur la page Sauvegarde et restauration de l’application Lakebase, ou récupérez-les par programmation à l’aide de l’API.

Lister les instantanés

UI

On the Backup & Restore page in the Lakebase App, your snapshots are listed by date, showing each snapshot's date and size. Les instantanés planifiés apparaissent dans la même liste avec une étiquette indiquant qu'ils ont été créés automatiquement.

Python SDK

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

Java

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

Bash

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

curl

Répertorier les instantanés d'un projet. Utilisez page_size et page_token pour parcourir les résultats. Un next_page_token vide indique la dernière page :

Bash

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

JSON

{
  "snapshots": [{ "name": "projects/my-project/snapshots/my-snapshot" }],
  "next_page_token": ""
}

Obtenir un seul instantané

Récupérez les détails d'un instantané par son ID. Contrairement à la création et à la suppression, get renvoie directement la ressource Snapshot (il ne s'agit pas d'une opération de longue durée). Lors des lectures, l'expiration est signalée comme étant soit expire_time, soit no_expiry.

Python SDK

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

Java

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

Bash

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

curl

Bash

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

Restaurer à partir d'un instantané

Pour utiliser un instantané, restaurez-le en créant une nouvelle Branch à partir de celui-ci. Il n'y a pas de restauration sur place : votre Branch actuelle reste inchangée et une nouvelle Branch racine est créée avec les données de l'instantané.

UI

Sur la page **Backup & Restore** de l'application Lakebase, les snapshots sont listés par date. Recherchez l'instantané que vous souhaitez restaurer et cliquez sur Restaurer . Une boîte de dialogue de confirmation apparaît, expliquant ce qui va se passer : la restauration s'effectue instantanément, votre Branch actuelle reste inchangée et une nouvelle Branch sera créée avec un nom tel que branch_from_snapshot_ suivi de la date et de l'heure de l'instantané. Confirmez que vous souhaitez effectuer l'opération en cliquant sur Restaurer . Une nouvelle Branch racine est créée avec les données de l'instantané. Votre Branch actuelle reste inchangée.

Une fois la restauration terminée, vous voyez un message de succès et la page Vue d'ensemble de la Branch pour la nouvelle Branch. La section intitulée Connectez-vous à la nouvelle Branch pour prévisualiser les données restaurées explique que vous pouvez vous connecter depuis votre application ou votre client pour vérifier les données restaurées.

Cliquez sur Obtenir les détails de la connexion pour ouvrir une boîte de dialogue contenant les informations de connexion de la nouvelle Branch : Branch, compute, base de données, rôle et une chaîne de connexion que vous pouvez copier. Le compute de la Branch peut s'afficher comme « En attente » pendant que la Branch start. Une fois qu'elle est active, vous pouvez utiliser la chaîne de connexion pour vous connecter.

Autres actions que vous pouvez effectuer avec votre nouvelle branch :

• Prévisualisez les données. Utilisez les détails de connexion de la nouvelle Branch pour vérifier les données et confirmer la restauration avant de modifier la configuration de votre application. Consultez Connectez-vous à votre base de données.
• Rename the Branch. Donnez à la Branch un nom plus clair à partir de l'aperçu des Branches ou de la liste des Branches. Voir Mettre à jour les paramètres de Branch.
• Set as default. Si vous êtes satisfait des données restaurées, vous pouvez faire de cette branch la branch par default du projet. Consultez Définir comme default.
• Dirigez votre application vers la nouvelle Branch. Une fois que vous êtes sûr que les données sont correctes, mettez à jour les paramètres de connexion de votre application pour utiliser les informations de connexion de cette branch.
• Supprimer ou conserver la Branch précédente. Vous pouvez supprimer la branch que vous utilisiez auparavant si vous n'en avez plus besoin, ou la conserver comme sauvegarde. Voir Supprimer une Branch.

Vous pouvez gérer la nouvelle branche et toutes les branches du projet à partir de la page Branches du projet, où la branche restaurée apparaît comme une branche racine à côté de vos autres branches.

Python SDK

Il n'existe aucune opération de restauration autonome. Créer une Branch avec source_snapshot défini sur le nom de la ressource de l'instantané. Cela achemine la création de la Branch via le chemin de restauration, produisant une nouvelle Branch racine avec les données de l'instantané. source_snapshot s'exclut mutuellement avec source_branch, source_branch_lsn et source_branch_time, et la Branch nécessite toujours une expiration (no_expiry, ttl ou expire_time). Définir replace_existing: true avec source_snapshot met à jour (upsert) une Branch cible existante, ce qui constitue une restauration idempotente.

Python

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

Java

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

Bash

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

Terraform

Restaurez à partir d'un instantané en déclarant un databricks_postgres_branch avec source_snapshot défini dans son spec. Le support de Terraform pour les instantanés se limite à ce chemin de restauration — il n'y a pas de resource Terraform pour créer, lister ou supprimer des instantanés.

Hcl

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

Il n'y a pas d'opération de restauration autonome. Pour restaurer un instantané, créez une nouvelle Branch et définissez source_snapshot sur la spécification de la Branch sur le nom de ressource de l'instantané. Cela achemine la création de la Branch via le chemin de restauration, produisant une nouvelle Branch racine qui contient les données de l'instantané. Vos branches existantes restent inchangées.

source_snapshot s'exclut mutuellement avec source_branch, source_branch_lsn et source_branch_time. Définir replace_existing: true avec source_snapshot met à jour une Branch cible existante, ce qui constitue une restauration idempotente. L'instantané référencé doit être AVAILABLE et appartenir au même projet que la nouvelle Branch.

1. Créer la Branch à partir de l'instantané. Le branch_id est inclus dans la query string :

   Bash

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

2. Interrogez l’opération renvoyée jusqu’à ce que done soit true. L’opération terminée est décompressée vers le nouveau Branch.

3. Connectez-vous à la nouvelle Branch pour vérifier les données restaurées avant d'y pointer votre application. Consultez Créer une Branch et Se connecter à votre base de données.

Supprimer un instantané

Les instantanés supprimés ne peuvent pas être récupérés.

UI

Sur la page Backup & Restore dans l'application Lakebase, recherchez l'instantané dans la liste, ouvrez son menu kebab , puis sélectionnez Supprimer l'instantané .

Python SDK

La suppression d'un instantané est une opération longue. Appelez .wait() pour bloquer jusqu'à ce qu'elle soit terminée.

Python

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

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

print("Snapshot deleted")

Java SDK

Java

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

Bash

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

curl

La suppression d'un instantané est une opération de longue durée. La requête renvoie une opération. La réponse de l'opération terminée est vide.

Bash

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

Interrogez l'opération renvoyée jusqu'à ce que done soit true.

Coûts de stockage des instantanés

À partir du 1er juin 2026, le stockage des instantanés sera facturable pour Lakebase.

La facturation est basée sur le type de snapshot :

• Les snapshots manuels sont facturés comme des snapshots complets.
• Les instantanés planifiés sont facturés comme des instantanés complets pour le premier instantané d'une planification, puis comme stockage incrémentiel (delta) pour les instantanés planifiés ultérieurs.

La taille de chaque instantané est affichée sur la page Sauvegarde et restauration . Pour les détails des Tarifs, consultez la page des Tarifs Lakebase.

Limitations

L'API des instantanés présente les limitations suivantes :

• Les instantanés sont immuables. Il n'y a pas d'opération de mise à jour. La Branch source, le sélecteur d'heure et l'expiration sont fixes lors de la création et ne peuvent pas être modifiés.
• Aucune restauration sur place. Vous ne pouvez restaurer un instantané qu'en créant une nouvelle branch à partir de celui-ci.
• Même projet, instantané disponible. L'instantané source doit être dans l'état AVAILABLE et doit appartenir au même projet que la nouvelle Branch.
• Champs de restauration mutuellement exclusifs. Dans la requête de création de Branch, source_snapshot ne peut pas être combiné avec source_branch, un LSN de Branch ou un Timestamp de Branch. Il peut être combiné avec replace_existing pour effectuer un upsert sur une Branch cible existante.
• Terraform. Le fournisseur ne prend en charge la restauration à partir d'un instantané qu'au moyen de l'argument source_snapshot sur databricks_postgres_branch. Il n'existe aucune ressource Terraform permettant de créer, de lister ou de supprimer des instantanés.
• Disponibilité en version bêta. L’API des instantanés est en version bêta et disponible dans tous les workspaces Lakebase.

Connexes

• Branches — Fonctionnement du branching dans Lakebase
• Guide de l'API Lakebase — Authentification, nommage des ressources et opérations longues