Cómo crear snapshots de tablas Delta en Lakehouse: paso a paso

Este tutorial muestra cómo crear snapshots periódicos de una tabla Delta en el Lakehouse con fines de auditoría, copia de seguridad rápida y rollback fácil. Hacer snapshots ayuda a preservar estados históricos sin depender solo del time travel o VACUUM, y es útil para exportar versiones para análisis fuera del Lakehouse.

Requisitos previos

• Cuenta y workspace en Microsoft Fabric con Lakehouse disponible.
• Permisos de lectura/escritura en el Lakehouse y en Direct Lake o OneLake.
• Entorno con PySpark (notebook en Fabric o cluster que acceda al Lakehouse).
• Conocimientos básicos de Delta Lake, PySpark y SQL.

Paso 1: Elegir la tabla Delta y la estrategia de snapshot

Decide qué tabla Delta quieres snapshotear y con qué frecuencia. Estrategias comunes: snapshot completo (copia completa) o snapshot incremental basado en columna de fecha/versión. Para empezar, usaremos una copia completa diaria por simplicidad.

Paso 2: Crear un directorio de snapshots en el Lakehouse

Crea una carpeta dentro del Lakehouse o OneLake donde se guardarán los snapshots como nuevas tablas Delta con un prefijo de fecha. Esto facilita la gestión y la limpieza.

# Exemplo PySpark para criar o diretório (se necessário apenas criar metadados)
from delta.tables import DeltaTable
from pyspark.sql import SparkSession

spark = SparkSession.builder.getOrCreate()

# Paths de exemplo
lakehouse_base = 'abfss://@.dfs.core.windows.net/lakehouse'
snapshots_path = lakehouse_base + '/snapshots'
print(snapshots_path)

Paso 3: Exportar la tabla Delta a un snapshot con timestamp

Lee la tabla Delta original y grábala como nueva tabla Delta con sufijo de fecha/hora. Esto preserva el estado completo en el momento del snapshot.

# Lê a tabela Delta existente e grava snapshot com timestamp
from datetime import datetime

table_path = lakehouse_base + '/tables/minha_tabela'
now = datetime.utcnow().strftime('%Y%m%d_%H%M%S')
snapshot_path = f"{snapshots_path}/minha_tabela_snapshot_{now}"

df = spark.read.format('delta').load(table_path)
# grava como nova tabela Delta
(df.write.format('delta')
   .mode('overwrite')
   .option('overwriteSchema','true')
   .save(snapshot_path))

print(f'Snapshot criado em: {snapshot_path}')

Paso 4: Registrar el snapshot como tabla en el metastore (opcional)

Para facilitar consultas vía endpoint de SQL analytics y catálogo, puedes crear una entrada en el metastore que apunte al snapshot.

# Exemplo SQL para criar tabela no metastore (no SQL notebook do Fabric)
CREATE TABLE IF NOT EXISTS snapshots.minha_tabela_snapshot_20240101_000000
USING DELTA
LOCATION 'abfss://@.dfs.core.windows.net/lakehouse/snapshots/minha_tabela_snapshot_20240101_000000';

Paso 5: Programar snapshots automáticos

Usa un scheduler (Azure Data Factory, Power Automate, Azure Functions, o job del Fabric) para ejecutar el script PySpark diariamente. En Fabric puedes usar pipelines para orquestar un notebook que ejecute el código anterior.

# Exemplo esquemático: Azure Function (Python) invoca o notebook ou script PySpark
# Pseudocódigo para agendamento diário
# 1. Trigger Timer daily
# 2. Call Fabric notebook REST API or submit job to Spark cluster
# 3. Monitor retorno e regista sucesso/erro

Paso 6: Política de retención y limpieza de snapshots

Define una política para eliminar snapshots antiguos (por ejemplo, mantener 30 días). Puedes listar directorios de snapshots y eliminar los que excedan la retención. Atención: elimina solo los snapshots de los que estés seguro de que no son necesarios.

# Exemplo PySpark para listar e remover snapshots antigos (pseudo)
from datetime import datetime, timedelta
import re

retention_days = 30
cutoff = datetime.utcnow() - timedelta(days=retention_days)

# lista diretórios (exemplo com dbutils/fs ou filesystem API)
files = dbutils.fs.ls(snapshots_path)
for f in files:
    m = re.search(r'minha_tabela_snapshot_(\d{8}_\d{6})', f.name)
    if m:
        ts = datetime.strptime(m.group(1), '%Y%m%d_%H%M%S')
        if ts < cutoff:
            dbutils.fs.rm(f.path, recurse=True)
            print('Removido', f.path)

Verificar el resultado

Confirma que el snapshot existe leyéndolo como Delta o consultando la tabla registrada en el metastore. Verifica el recuento de filas, el esquema y algunas filas para garantizar la integridad.

# Verificação simples
snap = spark.read.format('delta').load(snapshot_path)
print('count=', snap.count())
snap.show(5)

Conclusión

Has ejecutado un proceso repetible para crear snapshots de tablas Delta en el Lakehouse, útil para auditoría, análisis histórico y rollback. Próximos pasos: automatizar con un job, probar la retención e integrar notificaciones de éxito/error. Consejo: empieza con snapshots completos y, cuando te sientas cómodo, evoluciona a snapshots incrementales por partición para reducir costes — ¿quieres un ejemplo de snapshot incremental?