(+351) 21 24 10006  ·  info@bconcepts.pt
Carnaxide, Lisboa

Cómo hacer streaming incremental de cambios CDC en Databricks

João Barros 19 de November de 2026 4 min de lectura

Este tutorial muestra cómo hacer streaming incremental de cambios (CDC) en Databricks para aplicar upserts continuos en una tabla Delta. Es útil cuando necesita mantener una base de datos de destino sincronizada con cambios de origen en tiempo casi real.

Requisitos previos

  • Workspace Databricks con cluster en ejecución.
  • Permisos para leer la fuente (por ejemplo Kafka, o un fichero de log) y escribir en DBFS/Delta.
  • Conocimientos básicos de PySpark y Delta Lake.
  • Ejemplo de feed de cambios en formato JSON con campos: op (I/U/D), id, payload, timestamp.

Paso 1: Entender el patrón CDC y por qué usar Structured Streaming

CDC (Change Data Capture) representa operaciones CRUD como eventos. En Databricks, usar Structured Streaming permite tratar esos eventos de forma continua y aplicar MERGE en tablas Delta con baja latencia. La idea es leer el stream, normalizar eventos y ejecutar micro-batches con upsert.

Paso 2: Leer el stream de eventos (ejemplo con ficheros JSON en DBFS)

Para aprender, usamos un directorio en DBFS donde se colocan ficheros JSON con eventos. Structured Streaming detectará ficheros nuevos y los procesará en micro-batches.

# Exemplo PySpark num notebook Databricks
from pyspark.sql.functions import from_json, col, expr
from pyspark.sql.types import StructType, StructField, StringType, TimestampType

schema = StructType([
    StructField("op", StringType()),     # I, U, D
    StructField("id", StringType()),
    StructField("payload", StringType()),
    StructField("ts", TimestampType())
])

input_path = "/mnt/data/cdc_events/"
raw = spark.readStream.format("json").schema(schema).load(input_path)

Paso 3: Transformar eventos al formato de upsert

Convierta el payload JSON en columnas, normalice operaciones y marque filas para MERGE. Vamos a crear una columna _is_deleted para operaciones D (delete).

from pyspark.sql.functions import from_json, col
from pyspark.sql.types import StructType, StructField, StringType

payload_schema = StructType([
    StructField("name", StringType()),
    StructField("value", StringType())
])

events = raw.withColumn("payload_json", from_json(col("payload"), payload_schema)) \
            .select(
                col("op"),
                col("id"),
                col("ts"),
                col("payload_json.*")
            ) \
            .withColumn("_is_deleted", expr("op = 'D'"))

Paso 4: Realizar upserts incrementales a la tabla Delta usando foreachBatch

En cada micro-batch, utilizamos foreachBatch para ejecutar MERGE SQL en una tabla Delta. Esto da control para aplicar los cambios de forma transaccional.

target_table = "default.cdc_target"

# Cria tabela alvo se não existir
spark.sql(f"CREATE TABLE IF NOT EXISTS {target_table} (id STRING, name STRING, value STRING, ts TIMESTAMP) USING DELTA")

def upsert_to_delta(batch_df, batch_id):
    batch_df.createOrReplaceTempView("staging_cdc")
    merge_sql = f"""
    MERGE INTO {target_table} AS t
    USING staging_cdc AS s
      ON t.id = s.id
    WHEN MATCHED AND s._is_deleted = true THEN
      DELETE
    WHEN MATCHED THEN
      UPDATE SET name = s.name, value = s.value, ts = s.ts
    WHEN NOT MATCHED AND s._is_deleted = false THEN
      INSERT (id, name, value, ts) VALUES (s.id, s.name, s.value, s.ts)
    """
    spark.sql(merge_sql)

query = events.writeStream.foreachBatch(upsert_to_delta) \
    .outputMode("update") \
    .option("checkpointLocation", "/mnt/checkpoints/cdc_upsert_checkpoint") \
    .start()

Paso 5: Gestionar idempotencia y ordenación de eventos

Errores comunes: eventos fuera de orden o duplicados. Para mantener idempotencia, incluya un campo de versión/timestamp y aplique lógica que compare ts para decidir actualizaciones. Otra práctica es compactar la tabla Delta con OPTIMIZE periódicamente.

# Exemplo simples: só aplica UPDATE/INSERT se ts do event for maior
merge_sql = f"""
MERGE INTO {target_table} AS t
USING (SELECT *, row_number() OVER (PARTITION BY id ORDER BY ts DESC) AS rn FROM staging_cdc) AS s
  ON t.id = s.id
WHEN MATCHED AND s._is_deleted = true AND s.rn = 1 THEN DELETE
WHEN MATCHED AND s.rn = 1 AND s.ts > t.ts THEN
  UPDATE SET name = s.name, value = s.value, ts = s.ts
WHEN NOT MATCHED AND s.rn = 1 AND s._is_deleted = false THEN
  INSERT (id, name, value, ts) VALUES (s.id, s.name, s.value, s.ts)
"""

Verificar el resultado

Para confirmar que el streaming aplica CDC correctamente, consulte la tabla Delta de destino y verifique timestamps, valores y eliminaciones.

-- No notebook (SQL ou PySpark)
spark.sql("SELECT * FROM default.cdc_target ORDER BY ts DESC LIMIT 100").show()

-- Verificar estado do stream
query.isActive
query.status

Conclusión

Siguiendo estos pasos, tendrá un pipeline de CDC en Databricks que lee eventos, normaliza y aplica upserts en Delta con baja latencia. Próximos pasos: conectar una fuente real (Kafka, Debezium), añadir monitorización y optimizar consistencia (compaction, OPTIMIZE). Consejo: pruebe escenarios de duplicación y ordenación antes de pasar a producción.