Como fazer streaming incremental de alterações CDC em Databricks
Este tutorial mostra como fazer streaming incremental de alterações (CDC) em Databricks para aplicar upserts contínuos numa tabela Delta. É útil quando precisa de manter uma base de dados de destino sincronizada com alterações de origem em tempo quase real.
Pré-requisitos
- Workspace Databricks com cluster em execução.
- Permissões para ler a origem (por exemplo Kafka, ou um ficheiro de log) e escrever em DBFS/Delta.
- Conhecimentos básicos de PySpark e Delta Lake.
- Exemplo de feed de alterações em formato JSON com campos: op (I/U/D), id, payload, timestamp.
Passo 1: Entender o padrão CDC e porque usar Structured Streaming
CDC (Change Data Capture) representa operações de CRUD como eventos. Em Databricks, usar Structured Streaming permite tratar esses eventos continuamente e aplicar MERGE em tabelas Delta com baixa latência. A ideia é ler o stream, normalizar eventos e executar micro-batches com upsert.
Passo 2: Ler o stream de eventos (exemplo com ficheiros JSON em DBFS)
Para aprender, usamos um diretório em DBFS onde são colocados ficheiros JSON com eventos. Structured Streaming vai detetar ficheiros novos e processá-los em 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)
Passo 3: Transformar eventos para formato de upsert
Converta o payload JSON em colunas, normalize operações e marque linhas para MERGE. Vamos criar uma coluna _is_deleted para operações 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'"))
Passo 4: Fazer upsert incrementais para a tabela Delta usando foreachBatch
Em cada micro-batch, utilizamos foreachBatch para executar MERGE SQL numa tabela Delta. Isto dá controlo para aplicar as alterações 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()
Passo 5: Gerir idempotência e ordenação de eventos
Erros comuns: eventos fora de ordem ou duplicados. Para manter idempotência, inclua um campo de versão/timestamp e aplique lógica que compare ts para decidir atualizações. Outra prática é compactar a tabela Delta com OPTIMIZE periodicamente.
# 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 o resultado
Para confirmar que o streaming aplica CDC corretamente, consulte a tabela Delta de destino e verifique timestamps, valores e remoções.
-- 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
Conclusão
Seguindo estes passos, ficou um pipeline de CDC em Databricks que lê eventos, normaliza e aplica upserts em Delta com baixa latência. Próximos passos: ligar uma fonte real (Kafka, Debezium), adicionar monitorização e otimizar consistência (compaction, OPTIMIZE). Dica: teste cenários de duplicação e ordenação antes de ir para produção.