Instantáneas

Una instantánea es una captura a un momento dado de la rama raíz de un proyecto, incluido el esquema y todos los datos. Lakebase crea instantáneas al instante con un impacto mínimo en el rendimiento. Úselos como punto de copia de seguridad o restauración.

Puedes crear, restaurar y gestionar instantáneas en la app de Lakebase, o trabajar con ellas de forma programática usando la API de instantáneas del SDK de Python, el SDK de Java, la CLI de Databricks o el curl. Terraform puede restaurar a partir de una instantánea creando una rama. Cuando una operación está disponible en más de una dirección, las instrucciones se muestran juntas como tabulaciones.

Note

A partir del 1 de junio de 2026, el almacenamiento de instantáneas es facturable para Lakebase. Consulte Costos de almacenamiento de instantáneas.

Cuándo usar instantáneas

Las instantáneas son útiles para copias de seguridad normales o antes de realizar cambios de esquema u otras operaciones potencialmente destructivas. Proporcionan una manera rápida de crear puntos de restauración desde los que puede restaurar si es necesario.

Creación manual de instantáneas

Las instantáneas capturan el estado de su rama en un momento dado. Puede crear instantáneas manualmente solamente en ramas raíz. Las instantáneas manuales están limitadas a 10 por proyecto (consulte Límites del proyecto). Puede restaurar estas instantáneas desde cualquier rama del proyecto.

Creación de una instantánea

Las instantáneas se crean al instante y son útiles antes de realizar cambios significativos en el esquema o los datos.

Interfaz de usuario

Ve a tu proyecto en Lakebase App y selecciona Copia de seguridad y restauración en la navegación de la rama. Haga clic en Crear instantánea para capturar el estado actual de los datos.

Editor de SQL con SQL de ejemplo precargado

SDK de Python

create_snapshot devuelve una operación de larga duración. Llame a .wait() para bloquear hasta que la instantánea esté disponible. El resultado es el Snapshot. Se requiere source_branch, así como una caducidad: establezca exactamente uno de ttl, expire_time o no_expiry. Opcionalmente, localiza un momento en el tiempo con source_branch_lsn o 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}")

SDK de 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

El snapshot_id es un argumento posicional después del proyecto. La especificación corresponde al cuerpo --json:

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

curl

Crear una instantánea es una operación de larga duración. La solicitud devuelve una operación que sondea hasta que se completa. La operación completada se descomprime en el recurso Snapshot. En la práctica, la instantánea pasa a ser AVAILABLE rápidamente.

La especificación de instantánea requiere un source_branch. Configura el momento en el tiempo y la expiración de la siguiente manera:

Momento concreto (opcional): establezca source_branch_lsn o source_branch_time (mutuamente excluyentes). Omite ambos para crear una instantánea del estado actual de la rama.
Expiración (obligatoria): debe establecerse exactamente uno de expire_time (una marca de tiempo RFC 3339 que debe estar en el futuro), ttl (una duración en segundos, por ejemplo "604800s"), o no_expiry: true.

El snapshot_id es obligatorio, es elegido por ti y no puede cambiarse tras la creación.

Envíe la solicitud de creación. snapshot_id va en la cadena de consulta, y la especificación se asigna al cuerpo de la solicitud:

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 respuesta es una operación de larga duración:

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

Consultar la operación hasta que done esté true:

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

Cuando finaliza, la response de la operación se descomprime en el 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"
    }
  }
}

Los campos de tamaño son int64 valores serializados como cadenas.

Confirma que la instantánea está disponible obteniéndola directamente.

Para más información sobre operaciones de larga duración, véase Operaciones de larga duración.

Creación de una programación de copia de seguridad

Programe instantáneas automatizadas para que se ejecuten a intervalos regulares (diarias, semanales o mensuales) para garantizar copias de seguridad coherentes sin intervención manual. Las programaciones de copia de seguridad se configuran por rama y solo se aplican a las ramas raíz. El límite de instantáneas manuales (consulte Límites del proyecto) no se aplica a las instantáneas programadas.

Cada rama raíz tiene un único programa de respaldo que contiene una lista de cadencias. Lee la programación y sustituye sus cadencias in situ. No existe una operación separada de crear o eliminar, y configurar una lista vacía desactiva las instantáneas automáticas. Configura el horario en la aplicación Lakebase, o programáticamente con la API de planificación de respaldo del SDK de Python, el SDK Java, la CLI de Databricks, Terraform, los paquetes de activos de Databricks o curl.

Note

El acceso programático a las programaciones de copia de seguridad se encuentra en fase beta y está disponible para todos los espacios de trabajo de Lakebase.

Interfaz de usuario

Para crear o modificar una programación de copia de seguridad:

En la página Copia de seguridad y restauración del proyecto, haga clic en Editar programación para abrir el cuadro de diálogo de configuración de programación de copia de seguridad.
Seleccione una frecuencia de programación en las siguientes opciones:
- Sin programación : deshabilita las instantáneas automatizadas (valor predeterminado)
- Diariamente : crea una instantánea cada día a la hora especificada.
- Semanal : crea una instantánea en un día específico de la semana
- Mensual : crea una instantánea en un día específico del mes.
Configure los detalles de la programación en función de la frecuencia seleccionada. Especifique la frecuencia con la que desea crear instantáneas y cuánto tiempo se conservan.

Una vez configuradas, las instantáneas creadas por la programación aparecen en la página Copia de seguridad y restauración con una etiqueta que indica que se crearon automáticamente.

SDK de Python

Lee el horario con get_snapshot_schedule, y ajusta sus cadencias con update_snapshot_schedule. update_snapshot_schedule toma el nombre del recurso del calendario como argumento name y reemplaza todo el conjunto de cadencias. Para establecer una cadencia semanal que mantenga cada instantánea durante 7 días, ejecuta lo siguiente:

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

Para leer el calendario actual, ejecuta lo siguiente:

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

for cadence in schedule.schedule:
    print(cadence)

SDK de Java

Para establecer una cadencia semanal que mantenga cada instantánea durante 7 días, ejecuta lo siguiente:

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

Requiere la CLI de Databricks 1.16.0 y superiores. Lee el horario con get-snapshot-schedule, y configúralo con update-snapshot-schedule. El segundo argumento es la máscara de actualización, que debe ser schedule. Configurar el horario reemplaza todo el conjunto de cadencias y es una operación de larga duración, por lo que el comando espera a que se complete a menos que pases --no-wait.

Para leer el calendario actual, ejecuta lo siguiente:

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

Para establecer una cadencia semanal que mantenga cada instantánea durante 7 días, ejecuta lo siguiente:

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

Para desactivar las instantáneas automáticas, establece un horario vacío:

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

Terraform

Gestiona el horario con un databricks_postgres_snapshot_schedule recurso. Establece parent como el nombre del recurso de la rama; el propio name de la programación se deriva de él. El schedule atributo es una lista de cadencias, y al aplicar el recurso se reemplaza el conjunto de cadencias de la rama:

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

Conjuntos de recursos de Databricks

Define el horario en la clave postgres_snapshot_schedules de la configuración del paquete. Establece branch en el nombre del recurso de la rama. Desplegar el paquete reemplaza la configuración de cadencia establecida para la rama:

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

Lee el horario con GET, y configúralo con PATCH. La actualización sustituye todo el conjunto de cadencias, por lo que debe incluir todas las cadencias que desee conservar y pasar update_mask=schedule.

Para leer el calendario actual, ejecuta lo siguiente:

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

Actualizar el calendario es una operación de larga duración. Para establecer una cadencia semanal que mantenga cada instantánea durante 7 días, ejecuta lo siguiente:

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

Consulte periódicamente la operación devuelta hasta que done sea true. Consulte Operaciones de ejecución prolongada. El response de la operación completada se descomprime en el SnapshotSchedule.

Para desactivar las instantáneas automáticas, establece un horario vacío:

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

Referencia sobre cadencia y retención

Cada cadencia en un horario es exactamente una de las siguientes recurrencias, tomada a la hora completa en UTC. No se admiten minutos ni segundos.

Diariamente: establecer hour (0–23).
Semanal: establece day_of_week (de MONDAY a SUNDAY) y hour (0–23).
Mensual: establece day (1–31, ajustado al último día de los meses más cortos) y hour (0–23).

Cada cadencia establece también una duración retention, tras la cual caducan sus instantáneas:

La retención debe ser de al menos 1 hora y como máximo 35 días.
La retención se aplica cuando se toma una instantánea y no es retroactiva. Las instantáneas existentes mantienen su fecha de expiración original. Solo las instantáneas tomadas después del cambio usan la nueva política de retención.
Si coincide más de una cadencia dentro de la misma ventana, Lakebase crea una única instantánea y la conserva durante el periodo de retención más largo entre las cadencias coincidentes.

Tanto leer como actualizar la programación requieren el permiso CAN_USE en el proyecto.

Retención de instantáneas

Las instantáneas se eliminan automáticamente después de que expire su período de retención. Puede ajustar la configuración de retención en cualquier momento editando la programación. Tenga en cuenta:

Los períodos de retención más cortos ayudan a administrar el número de instantáneas programadas que se conservan.
No se pueden recuperar instantáneas eliminadas
Las instantáneas manuales no se ven afectadas por la configuración de retención de la programación de copias de seguridad.

Obtén y publica instantáneas

Consulta tus instantáneas en la página de Copia de Seguridad y Restauración de la app Lakebase, o recupéralas programáticamente con la API.

Enumerar instantáneas

Interfaz de usuario

En la página de Copia de Seguridad y Restauración de la app Lakebase, tus instantáneas están listadas por fecha, mostrando la fecha y el tamaño de cada una. Las instantáneas programadas aparecen en la misma lista con una etiqueta que indica que se crearon automáticamente.

SDK de Python

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

for snapshot in w.postgres.list_snapshots(parent="projects/my-project"):
    print(f"Snapshot: {snapshot.name}")

SDK de 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

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

curl

Enumera las instantáneas de un proyecto. Usa page_size y page_token para desplazarte por los resultados. Un vacío next_page_token indica la última página:

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

Consigue una sola instantánea

Obtén los detalles de una instantánea por su ID. A diferencia de crear y eliminar, get devuelve el Snapshot recurso directamente (no es una operación de larga duración). Al leer, la caducidad se indica como expire_time o no_expiry.

SDK de 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")

SDK de 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

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

Restaurar desde una instantánea

Para usar una instantánea, restaura la imagen creando una nueva rama a partir de ella. No hay restauración in situ: tu rama actual se queda sin cambios y se crea una nueva rama raíz con los datos de la instantánea.

Interfaz de usuario

En la página Copia de seguridad y restauración de la aplicación Lakebase, las instantáneas se enumeran por fecha. Busque la instantánea que desea restaurar y haga clic en Restaurar. Aparece un cuadro de diálogo de confirmación que explica lo que ocurrirá: la restauración se produce al instante, la rama actual permanece sin cambios y se creará una nueva rama con un nombre como branch_from_snapshot_ seguido de la fecha y hora de la instantánea. Para confirmar que desea realizar la operación, haga clic en Restaurar. Se crea una nueva rama raíz con los datos de instantánea. Tu rama actual queda sin cambios.

Una vez completada la restauración, verá un mensaje de éxito y la página de Información general de la rama para la nueva sucursal. La sección titulada Conectar a la nueva rama para obtener una vista previa de los datos restaurados explica que puede conectarse desde la aplicación o el cliente para comprobar los datos restaurados.

Visión general de ramas después de restaurar desde una instantánea

Haga clic en Obtener detalles de conexión para abrir un cuadro de diálogo con la información de conexión de la nueva rama: rama, proceso, base de datos, rol y una cadena de conexión que puede copiar. El proceso de la rama puede mostrarse como "Pendiente" mientras se inicia. Una vez que esté activa, puede usar la cadena de conexión para conectarse.

Otras cosas que puedes hacer con tu nueva rama:

Obtenga una vista previa de los datos. Use los detalles de conexión de la nueva rama para comprobar los datos y confirmar la restauración antes de cambiar la configuración de la aplicación. Consulte Conexión a la base de datos.
Cambie el nombre de la rama. Dé a la rama un nombre más claro desde la visión general de ramas o la lista de ramas. Consulte Actualización de la configuración de la rama.
Establezca como valor predeterminado. Si está satisfecho con los datos restaurados, puede convertir esta rama en la rama predeterminada del proyecto. Consulte Establecer como valor predeterminado.
Dirija la aplicación a la nueva rama. Una vez que esté seguro de que los datos son correctos, actualice la configuración de conexión de la aplicación para usar los detalles de conexión de esta rama.
Quite o mantenga la rama anterior. Puede eliminar la rama que estaba usando antes si ya no la necesita o conservarla como copia de seguridad. Consulte Eliminar una rama.

Puede administrar la nueva rama y todas las ramas de proyecto desde la página Ramas del proyecto, donde la rama restaurada aparece como una rama raíz junto con las demás ramas.

SDK de Python

No existe una operación de restauración independiente. Crea una rama con source_snapshot establecido en el nombre de recurso de la instantánea. Esto enruta la creación de ramas a través de la ruta de restauración, produciendo una nueva rama raíz con los datos de la instantánea. source_snapshot es mutuamente excluyente con source_branch, source_branch_time y no_expiry, y la rama sigue requiriendo una expiración (ttl, expire_time o source_branch_lsn). Configurar replace_existing: true junto con source_snapshot actualiza una rama de destino existente, lo que da lugar a una restauración 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}")

SDK de 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

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

Terraform

Restaurar a partir de una instantánea declarando un databricks_postgres_branch con source_snapshot establecido en su spec. El soporte de Terraform para instantáneas se limita a esta ruta de restauración: no existe un recurso de Terraform para crear, listar o eliminar instantáneas.

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

No existe una operación de restauración independiente. Para restaurar una instantánea, crea una nueva rama y establece source_snapshot en la especificación de la rama el nombre del recurso de la instantánea. Esto enruta la creación de la rama a través de la ruta de restauración, produciendo una nueva rama raíz que contiene los datos de la instantánea. Tus sucursales actuales no han cambiado.

source_snapshot es mutuamente excluyente con source_branch, source_branch_lsn, y source_branch_time. Configurar replace_existing: true junto con source_snapshot actualiza una rama de destino existente, lo que da lugar a una restauración idempotente. La instantánea referenciada debe ser AVAILABLE y pertenecer al mismo proyecto que la nueva rama.

Crea la rama a partir de la instantánea. El branch_id se incluye en la cadena de consulta:

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

Consulte periódicamente la operación devuelta hasta que done sea true. La operación completada se descomprime en la nueva Branch.
Conéctate a la nueva sucursal para verificar los datos restaurados antes de dirigir tu solicitud a ella. Consulta Crear una rama y Conectar a tu base de datos.

Eliminar una instantánea

Las instantáneas eliminadas no se pueden recuperar.

Interfaz de usuario

En la página de Copia de Seguridad y Restauración de la app Lakebase, busca la instantánea en la lista, abre el icono del menú Kebab. Menú kebab, y selecciona Eliminar instantánea.

SDK de Python

Eliminar una instantánea es una operación de larga duración. Llame a .wait() para bloquear hasta que finalice.

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

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

print("Snapshot deleted")

SDK de 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

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

curl

Eliminar una instantánea es una operación de larga duración. La solicitud devuelve una operación. La respuesta de la operación finalizada está vacía.

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

Consulte periódicamente la operación devuelta hasta que done sea true.

Costos de almacenamiento de instantáneas

A partir del 1 de junio de 2026, el almacenamiento de instantáneas es facturable para Lakebase.

La facturación se basa en el tipo de instantánea:

Las instantáneas manuales se cobran como instantáneas completas.
Las instantáneas programadas se cobran como instantáneas completas en el caso de la primera instantánea de la programación y como almacenamiento incremental (delta) en el de las instantáneas programadas posteriores.

El tamaño de cada instantánea se muestra en la página Copia de seguridad y restauración . Para obtener más información sobre los precios, consulte la página de precios de Lakebase.

Limitations

La API de instantáneas tiene las siguientes limitaciones:

Las instantáneas son inmutables. No hay operación de actualización. La rama de origen, el selector de punto en el tiempo y la expiración están fijados en la creación y no pueden cambiarse.
No hay restauración in situ. Una instantánea solo se puede restaurar creando una nueva rama a partir de ella.
Mismo proyecto, instantánea disponible. La instantánea de origen debe estar en estado AVAILABLE y debe pertenecer al mismo proyecto que la nueva rama.
Campos de restauración mutuamente excluyentes. En la solicitud de creación de rama, source_snapshot no se puede combinar con source_branch, un LSN de rama ni una marca de tiempo de rama. Se puede combinar para replace_existing potenciar una rama objetivo existente.
Terraform. El proveedor solo admite la restauración desde una instantánea, a través del argumento source_snapshot de databricks_postgres_branch. No existe ningún recurso de Terraform para crear, listar o eliminar instantáneas.
Disponibilidad beta. La API de snapshots está en Beta y disponible para todos los espacios de trabajo de Lakebase.

Ramas — Cómo funciona la ramificación en Lakebase
Guía de la API de Lakebase — Autenticación, nombres de recursos y operaciones de larga duración

Comentarios

¿Le ha resultado útil esta página?

Se actualizó por última vez el 2026-09-30

Instantáneas

Cuándo usar instantáneas

Creación manual de instantáneas

Creación de una instantánea

Interfaz de usuario

SDK de Python

SDK de Java

CLI

curl

Creación de una programación de copia de seguridad

Interfaz de usuario

SDK de Python

SDK de Java

CLI

Terraform

Conjuntos de recursos de Databricks

curl

Referencia sobre cadencia y retención

Retención de instantáneas

Obtén y publica instantáneas

Enumerar instantáneas

Interfaz de usuario

SDK de Python

SDK de Java

CLI

curl

Consigue una sola instantánea

SDK de Python

SDK de Java

CLI

curl

Restaurar desde una instantánea

Interfaz de usuario

SDK de Python

SDK de Java

CLI

Terraform

curl

Eliminar una instantánea

Interfaz de usuario

SDK de Python

SDK de Java

CLI

curl

Costos de almacenamiento de instantáneas

Limitations

Relacionado

Comentarios

Recursos adicionales