Snapshots

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

Vous pouvez créer, restaurer et gérer des instantanés dans l’application Lakebase, ou travailler avec eux de manière programmatique en utilisant l’API des instantanés du SDK Python, du SDK Java, de la interface de code Databricks ou du curl. Terraform peut restaurer à partir d’un instantané en créant une branche. Lorsqu’une opération est disponible dans plusieurs sens, les instructions sont affichées ensemble sous forme de tabulations.

Note

À partir du 1er juin 2026, le stockage instantané est facturable pour Lakebase. Consultez les coûts de stockage d’instantanés.

Quand utiliser des instantanés

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

Créer des instantanés manuellement

Les captures instantanées capturent l’état de votre branche à un moment donné. Vous pouvez créer des instantanés manuellement sur des branches racines uniquement. 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 branche de votre projet.

Créer un instantané

Les instantanés sont créés instantanément et sont utiles avant d’apporter des modifications significatives à votre schéma ou à vos données.

Interface utilisateur

Allez dans votre projet dans l’application Lakebase et sélectionnez Sauvegarder & Restaurer dans la navigation de branche. Cliquez sur Créer un instantané pour capturer l’état actuel de vos données.

Éditeur SQL avec l’exemple SQL préchargé

Kit de développement logiciel (SDK) Python

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 le Snapshot. source_branch est requis, et une date d’expiration l’est également : définissez exactement un seul de ttl, expire_time ou no_expiry. Éventuellement, fixez un moment dans le temps avec source_branch_lsn ou 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}")

Kit de développement logiciel (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());

Interface de ligne de commande (CLI)

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

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

curl

Créer un instantané est une opération de longue durée. La requête renvoie une opération que vous sondez jusqu’à ce qu’elle soit terminée. Une fois l’opération terminée, le contenu est décompressé dans la ressource Snapshot. En pratique, l’instantané devient rapidement AVAILABLE.

La spécification de l’instantané requiert un source_branch. Configurez le moment et l’expiration comme suit :

Point dans le temps (optionnel) : définissez soit source_branch_lsn, soit source_branch_time (mutuellement exclusifs). Omettez les deux pour créer un instantané de la tête actuelle de la branche.
Expiration (obligatoire) : définir exactement un de expire_time (un horodatage RFC 3339 qui doit être dans le futur), ttl (une durée en secondes, comme "604800s"), ou no_expiry: true.

Le snapshot_id est obligatoire, vous le choisissez, et il ne peut pas être modifié après sa création.

Envoyez la demande de création. snapshot_id va dans la chaîne de requête, et la spécification correspond au corps de la requête :

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 :

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

Interrogez l’opération jusqu’à ce que done soit true:

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

Une fois terminée, l’opération response se décompose dans le 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"
    }
  }
}

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

Vérifiez que la capture instantanée est disponible en la récupérant directement.

Pour plus d’informations sur les opérations de longue durée, voir Opérations de longue durée.

Créer une planification de sauvegarde

Planifiez des captures instantanées automatisées à des intervalles réguliers (quotidiens, hebdomadaires ou mensuels) pour garantir des sauvegardes cohérentes sans intervention manuelle. Les planifications de sauvegarde sont configurées par branche et s’appliquent uniquement aux branches racines. La limite des instantanés manuels (voir limites du projet) ne s’applique pas aux instantanés planifiés.

Chaque branche racine dispose d’un seul calendrier de sauvegarde contenant une liste de cadences. Vous lisez le planning et remettez ses cadences en place. Il n’existe pas d’opération distincte de création ou de suppression, et la création d’une liste vide désactive les instantanés automatisés. Configurez le planning dans l’application Lakebase, ou programmatiquement avec l’API de sauvegarde du planning depuis le SDK Python, le SDK Java, la CLI Databricks, Terraform, les bundles d’assets Databricks, ou curl.

Interface utilisateur

Pour créer ou modifier une planification de sauvegarde :

Dans la page Sauvegarde et restauration de votre projet, cliquez sur Modifier la planification pour ouvrir la boîte de dialogue de configuration de planification de sauvegarde.
Sélectionnez une fréquence de planification dans les options suivantes :
- Aucune planification : désactive les instantanés automatisés (par défaut)
- Quotidien : crée un instantané tous les jours à l’heure spécifiée
- Hebdomadaire : crée un instantané sur un jour spécifique de la semaine
- Mensuel : crée un instantané sur un jour spécifique du mois
Configurez les détails de la planification en fonction de la fréquence sélectionnée. Spécifiez la fréquence à laquelle vous souhaitez créer des instantanés et la durée de leur conservation.

Une fois configurés, les instantanés créés par la planification s’affichent sur la page Sauvegarde et restauration avec une étiquette indiquant qu’elles ont été créées automatiquement.

Kit de développement logiciel (SDK) Python

Lisez le calendrier avec get_snapshot_schedule, et réglez ses cadences avec update_snapshot_schedule. update_snapshot_schedule prend le nom de ressource de la planification comme argument name et remplace la totalité des cadences. Pour définir une cadence hebdomadaire qui conserve chaque instantané pendant 7 jours, exécutez ce qui suit :

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 le calendrier actuel, exécutez ce qui suit :

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

for cadence in schedule.schedule:
    print(cadence)

Kit de développement logiciel (SDK) Java

Pour définir une cadence hebdomadaire qui conserve chaque instantané pendant 7 jours, exécutez ce qui suit :

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());

Interface de ligne de commande (CLI)

Nécessite Databricks CLI 1.16.0 ou version ultérieure. Lisez le planning avec get-snapshot-schedule, et réglez-le avec update-snapshot-schedule. Le second argument est le masque de mise à jour, qui doit être schedule. Définir le planning remplace l’ensemble des cadences et est une opération à long terme ; la commande attend donc qu’elle se termine à moins que vous ne réussissiez --no-wait.

Pour lire le calendrier actuel, exécutez ce qui suit :

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 ce qui suit :

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 un planning vide :

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

Terraform

Gérez le planning avec une databricks_postgres_snapshot_schedule ressource. Définissez parent sur le nom de la ressource de branche ; le propre name de la planification en est dérivé. L’attribut schedule est une liste de cadences, et l’application de la ressource remplace l’ensemble de cadences de la branche :

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

Packs de ressources Databricks

Définissez le planning sous la postgres_snapshot_schedules clé dans votre configuration de bundle. Réglez branch sur le nom de la ressource de branche. Le déploiement du package remplace le jeu de cadences de la branche :

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 le planning avec GET, et réglez-le avec PATCH. La mise à jour remplace tout l’ensemble de cadences, donc incluez toutes les cadences que vous souhaitez conserver, et passez update_mask=schedule.

Pour lire le calendrier actuel, exécutez ce qui suit :

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

Mettre à jour le planning est une opération de longue durée. Pour définir une cadence hebdomadaire qui conserve chaque instantané pendant 7 jours, exécutez ce qui suit :

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

Interrogez l’opération retournée jusqu’à ce que done soit true. Consultez les opérations de longue durée. Le response de l’opération terminée est décompressé dans le SnapshotSchedule.

Pour désactiver les instantanés automatisés, définissez un planning vide :

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

Informations de référence sur la cadence et la rétention

Chaque cadence dans un planning correspond exactement à l’une des récurrences suivantes, prises à une heure entière en UTC. Les minutes et les secondes ne sont pas prises en charge.

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

Chaque cadence fixe également une retention durée, après quoi ses instantanés expirent :

La rétention doit durer au moins 1 heure et au maximum 35 jours.
La rétention prend effet au moment où un instantané est pris et n’est pas rétroactive. Les snapshots existants conservent leur expiration d’origine. Seuls les instantanés pris après la modification utilisent la nouvelle durée de conservation.
Si plusieurs cadences sont dues dans la même fenêtre, Lakebase crée un instantané unique et le conserve le plus longtemps possible parmi les cadences correspondantes.

La lecture et la mise à jour du planning nécessitent toutes deux l’autorisation CAN_USE du projet.

Conservation des 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 la planification. Gardez à l’esprit :

Les périodes de rétention plus courtes permettent de gérer le nombre d’instantanés planifiés conservés.
Les captures instantanées supprimées ne peuvent pas être récupérées
Les instantanés manuels ne sont pas affectés par les paramètres de rétention de planification de sauvegarde

Obtenez et listez des instantanés

Consultez vos instantanés sur la page Sauvegarde & Restauration de l’application Lakebase, ou récupérez-les par programmation avec l’API.

Répertorier les instantanés

Interface utilisateur

Sur la page Sauvegarde & Restauration de l’application Lakebase, vos instantanés sont listés par date, indiquant la date et la taille de chaque instantané. Les instantanés programmés apparaissent dans la même liste avec une étiquette indiquant qu’ils ont été créés automatiquement.

Kit de développement logiciel (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}")

Kit de développement logiciel (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());
}

Interface de ligne de commande (CLI)

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

curl

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

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

Obtenez un seul instantané

Récupérez les détails d’un instantané selon son ID. Contrairement à créer et supprimer, get renvoie directement la Snapshot ressource (ce n’est pas une opération de longue durée). Lors de la lecture, l’expiration est indiquée soit par expire_time, soit par no_expiry.

Kit de développement logiciel (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")

Kit de développement logiciel (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");

Interface de ligne de commande (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

Restaurer à partir d'une capture instantanée

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

Interface utilisateur

Dans la page Sauvegarde et restauration dans l’application Lakebase, les instantanés sont répertoriés par date. Recherchez l’instantané que vous souhaitez restaurer, puis cliquez sur Restaurer. Une boîte de dialogue de confirmation s’affiche expliquant ce qui se passera : la restauration se produit instantanément, votre branche actuelle reste inchangée et une nouvelle branche sera créée avec un nom tel que branch_from_snapshot_ suivi de la date et de l’heure de l’instantané. Vérifiez que vous souhaitez effectuer l’opération en cliquant sur Restaurer. Une nouvelle branche racine est créée à partir des données de l’instantané. Votre branche actuelle reste inchangée.

Une fois la restauration terminée, vous voyez un message de réussite et la page vue d’ensemble de la branche pour la nouvelle branche. La section intitulée Se connecter à la nouvelle branche pour afficher un aperçu des données restaurées explique que vous pouvez vous connecter à partir de votre application ou client pour vérifier les données restaurées.

Vue d’ensemble de la branche après la restauration à partir d’un instantané

Cliquez sur Obtenir les détails de connexion pour ouvrir une boîte de dialogue avec les informations de connexion de la nouvelle branche : branche, calcul, base de données, rôle et chaîne de connexion que vous pouvez copier. Le calcul de la branche peut s’afficher sous la forme « En attente » pendant son démarrage. Une fois qu’elle est active, vous pouvez utiliser la chaîne de connexion pour vous connecter.

D’autres choses que vous pouvez faire avec votre nouvelle branche :

Affichez un aperçu des données. Utilisez les détails de connexion de la nouvelle branche pour vérifier les données et confirmer la restauration avant de modifier la configuration de votre application. Consultez Se connecter à votre base de données.
Renommez la branche. Donnez à la branche un nom plus clair à partir de l'aperçu des branches ou de la liste de branches. Consultez Paramètres de branche de mise à jour.
Définissez comme valeur par défaut. Si vous êtes satisfait des données restaurées, vous pouvez faire de cette branche la branche par défaut du projet. Voir Définir comme valeur par défaut.
Pointez votre application vers la nouvelle branche. 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 détails de connexion de cette branche.
Supprimez ou conservez la branche précédente. Vous pouvez supprimer la branche que vous utilisiez avant si vous n’en avez plus besoin, ou la conserver en tant que sauvegarde. Voir Supprimer une branche.

Vous pouvez gérer la nouvelle branche et toutes les branches de projet à partir de la page Branches du projet, où la branche restaurée apparaît en tant que branche racine en même temps que vos autres branches.

Kit de développement logiciel (SDK) Python

Il n’existe pas d’opération de restauration autonome. Créez une branche avec source_snapshot définie sur le nom de ressource de l’instantané. Cela fait transiter la création de branches par le processus de restauration, produisant une nouvelle branche racine avec les données de l’instantané. source_snapshot est mutuellement exclusif avec source_branch, source_branch_time et no_expiry, et la branche reste soumise à une expiration (ttl, expire_time ou source_branch_lsn). Définir replace_existing: true avec source_snapshot effectue une mise à jour ou une insertion sur une branche cible existante, soit une restauration idempotente.

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Branch, BranchSpec

w = WorkspaceClient()

branch = Branch(
    spec=BranchSpec(
        source_snapshot="projects/my-project/snapshots/my-snapshot",
        no_expiry=True,
    )
)

result = w.postgres.create_branch(
    parent="projects/my-project",
    branch=branch,
    branch_id="restored-branch",
).wait()

print(f"Branch created: {result.name}")

Kit de développement logiciel (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());

Interface de ligne de commande (CLI)

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

Terraform

Restaurer à partir d’un instantané en déclarant un databricks_postgres_branch avec source_snapshot défini dans son spec. Le support des instantanés de Terraform est limité à ce chemin de restauration — il n’existe aucune ressource Terraform pour créer, lister ou supprimer des instantanés.

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’existe pas d’opération de restauration autonome. Pour restaurer un instantané, créez une nouvelle branche et définissez source_snapshot sur la spécification de branche le nom de la ressource de l’instantané. Cela fait passer la création de la branche par le processus de restauration, ce qui produit une nouvelle branche racine contenant les données de l’instantané. Vos branches existantes sont inchangées.

source_snapshot est mutuellement exclusif avec source_branch, source_branch_lsn, et source_branch_time. Définir replace_existing: true avec source_snapshot effectue une mise à jour ou une insertion sur une branche cible existante, soit une restauration idempotente. La capture instantanée référencée doit être AVAILABLE et appartenir au même projet que la nouvelle branche.

Créez la branche à partir du snapshot. Le branch_id s’insère dans la chaîne de requête :

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

Interrogez l’opération retournée jusqu’à ce que done soit true. L’opération terminée est décompressée vers le nouveau Branch.
Connectez-vous à la nouvelle branche pour vérifier les données restaurées avant de diriger votre application vers celle-ci. Voir Créer une branche et connecter à votre base de données.

Supprimer un instantané

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

Interface utilisateur

Sur la page Sauvegarde & Restauration de l’application Lakebase, trouvez l’instantané dans la liste, ouvrez son icône de menu Kebab. menu kebab, et sélectionnez Supprimer l’instantané.

Kit de développement logiciel (SDK) Python

Supprimer un instantané est une opération de longue durée. Appelez .wait() pour bloquer jusqu’à ce que ce soit terminé.

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

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

print("Snapshot deleted")

Kit de développement logiciel (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");

Interface de ligne de commande (CLI)

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

curl

Supprimer 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.

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

Interrogez l’opération retournée jusqu’à ce que done soit true.

Coûts de stockage d’instantanés

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

La facturation dépend du type de cliché :

Les instantanés manuels sont facturés en tant qu’instantanés 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 suivants.

La taille de chaque instantané s’affiche sur la page Sauvegarde et restauration . Pour plus d’informations sur la tarification, consultez la page de tarification Lakebase.

Limitations

L’API snapshots présente les limitations suivantes :

Les instantanés sont immuables. Il n’y a pas d’opération de mise à jour. La branche source, le sélecteur point-in-time et l’expiration sont fixes à la création et ne peuvent pas être modifiés.
Pas de restauration sur place. Vous ne restaurez un instantané qu’en créant une nouvelle branche à partir de celui-ci.
Même projet, instantané disponible. L’instantané source doit être à l’état AVAILABLE et appartenir au même projet que la nouvelle branche.
Champs de restauration exclusifs les uns des autres. Sur la requête create-branch, source_snapshot ne peut pas être combiné avec source_branch, un LSN de branche, ni un timestamp de branchement. Il peut être combiné à replace_existing pour créer ou mettre à jour une branche cible existante.
Terraform. Le fournisseur supporte la restauration à partir d’un instantané uniquement, via l’argument source_snapshot sur databricks_postgres_branch. Il n’existe aucune ressource Terraform pour créer, lister ou supprimer des instantanés.

Branches — Comment fonctionnent les branches dans Lakebase
Guide API Lakebase — Authentification, nommage des ressources et opérations de longue durée

Commentaires

Cette page a-t-elle été utile ?

Dernière mise à jour : 2026-09-30

Snapshots

Quand utiliser des instantanés

Créer des instantanés manuellement

Créer un instantané

Interface utilisateur

Kit de développement logiciel (SDK) Python

Kit de développement logiciel (SDK) Java

Interface de ligne de commande (CLI)

curl

Créer une planification de sauvegarde

Interface utilisateur

Kit de développement logiciel (SDK) Python

Kit de développement logiciel (SDK) Java

Interface de ligne de commande (CLI)

Terraform

Packs de ressources Databricks

curl

Informations de référence sur la cadence et la rétention

Conservation des instantanés

Obtenez et listez des instantanés

Répertorier les instantanés

Interface utilisateur

Kit de développement logiciel (SDK) Python

Kit de développement logiciel (SDK) Java

Interface de ligne de commande (CLI)

curl

Obtenez un seul instantané

Kit de développement logiciel (SDK) Python

Kit de développement logiciel (SDK) Java

Interface de ligne de commande (CLI)

curl

Restaurer à partir d'une capture instantanée

Interface utilisateur

Kit de développement logiciel (SDK) Python

Kit de développement logiciel (SDK) Java

Interface de ligne de commande (CLI)

Terraform

curl

Supprimer un instantané

Interface utilisateur

Kit de développement logiciel (SDK) Python

Kit de développement logiciel (SDK) Java

Interface de ligne de commande (CLI)

curl

Coûts de stockage d’instantanés

Limitations

Related

Commentaires

Ressources supplémentaires