Como fazer Data Lineage em Governação de Dados: passo a passo

João Barros 28 de July de 2026 4 min de leitura

Este tutorial mostra como implementar Data Lineage em Governação de Dados para rastrear a origem, transformações e consumo de um conjunto de dados. Saber o lineage ajuda a diagnosticar erros, avaliar o impacto de alterações e cumprir requisitos de auditoria e conformidade.

Pré-requisitos

Acesso a um ambiente com ETL/ELT (ex.: Azure Data Factory, Synapse ou outro) e a uma base de dados (ex.: Azure SQL ou SQL Server).
Permissões para ler metadados do pipeline e criar tabelas de metadados.
Conhecimentos básicos de SQL e de como exportar logs do pipeline em JSON.

Passo 1: Definir o modelo de metadados para Lineage

Antes de registar qualquer coisa, defina um modelo simples que descreva fontes, transformações e destinos. Um modelo mínimo tem as tabelas: entity (ficheiros/tabelas), process (ETL/transformação) e lineage (liga entidades a processos).

-- Exemplo de esquema mínimo em Azure SQL/SQL Server
CREATE TABLE entity (
  entity_id INT IDENTITY PRIMARY KEY,
  name NVARCHAR(255),
  type NVARCHAR(50), -- e.g. 'table','file','view'
  location NVARCHAR(1000)
);

CREATE TABLE process (
  process_id INT IDENTITY PRIMARY KEY,
  name NVARCHAR(255),
  tool NVARCHAR(100), -- e.g. 'ADF','Spark'
  run_id NVARCHAR(100),
  started_at DATETIME2,
  finished_at DATETIME2
);

CREATE TABLE lineage (
  lineage_id INT IDENTITY PRIMARY KEY,
  process_id INT FOREIGN KEY REFERENCES process(process_id),
  source_entity_id INT FOREIGN KEY REFERENCES entity(entity_id),
  target_entity_id INT FOREIGN KEY REFERENCES entity(entity_id),
  details NVARCHAR(2000)
);

Passo 2: Capturar metadados do pipeline/ETL

Configure o seu ETL (ex.: Azure Data Factory) para exportar logs de execução em JSON ou semelhante. O objetivo é extrair: run_id, nomes de datasets, timestamps e operações (copy, transform).

// Exemplo conceptual de payload JSON que o pipeline deve exportar
{
  "run_id": "abc-123",
  "pipeline": "Load_Sales",
  "started_at": "2026-07-01T10:00:00Z",
  "finished_at": "2026-07-01T10:05:00Z",
  "sources": [{"name":"stg.sales.csv","type":"file","location":"/lake/sales/2026/07"}],
  "targets": [{"name":"dw.sales","type":"table","location":"server.database.schema.dw.sales"}],
  "operations": ["copy","cleanse"]
}

Passo 3: Carregar metadados para as tabelas de Lineage

Crie um processo que converta o JSON do pipeline em linhas nas tabelas entity, process e lineage. Pode ser um script T-SQL, um notebook Spark, ou uma função Azure Function.

-- Pseudocódigo T-SQL para inserir metadados (simplificado)
DECLARE @run_id NVARCHAR(100) = 'abc-123';
-- Inserir process
INSERT INTO process (name, tool, run_id, started_at, finished_at)
VALUES ('Load_Sales','ADF',@run_id,'2026-07-01T10:00:00','2026-07-01T10:05:00');
DECLARE @process_id INT = SCOPE_IDENTITY();
-- Inserir entidades (ex.: fonte)
INSERT INTO entity (name,type,location)
VALUES ('stg.sales.csv','file','/lake/sales/2026/07');
DECLARE @source_id INT = SCOPE_IDENTITY();
-- inserir destino
INSERT INTO entity (name,type,location)
VALUES ('dw.sales','table','server.database.schema.dw.sales');
DECLARE @target_id INT = SCOPE_IDENTITY();
-- ligar
INSERT INTO lineage (process_id, source_entity_id, target_entity_id, details)
VALUES (@process_id,@source_id,@target_id,'copy,cleanse');

Passo 4: Automatizar ingestão e lidar com duplicados

Automatize a carga destes metadados após cada execução: use triggers do pipeline, webhooks ou um job agendado. Evite duplicados verificando run_id e localização da entidade antes de inserir.

-- Verificação simples antes de inserir (exemplo)
IF NOT EXISTS (SELECT 1 FROM process WHERE run_id = @run_id)
BEGIN
  -- inserir process e lineage como acima
END

Passo 5: Visualizar Lineage e gerir impacto

Crie queries ou um dashboard (Power BI) que mostrem o percurso de uma coluna/tabela desde a fonte até ao destino e que permitam calcular o impacto de uma alteração numa entidade.

-- Exemplo de query recursiva para seguir lineage de uma entidade
WITH RecLineage AS (
  SELECT l.source_entity_id, l.target_entity_id, 1 AS depth
  FROM lineage l
  WHERE l.source_entity_id = @start_entity_id
  UNION ALL
  SELECT l2.source_entity_id, l2.target_entity_id, rl.depth + 1
  FROM lineage l2
  JOIN RecLineage rl ON l2.source_entity_id = rl.target_entity_id
)
SELECT * FROM RecLineage ORDER BY depth;

Verificar o resultado

Confirme que cada execução do pipeline cria um registo em process e que existem entradas correspondentes em entity e lineage. Valide com queries simples: procurar por run_id e seguir o lineage com a query recursiva. No Power BI, verifique se o grafo mostra fontes e destinos corretos.

Conclusão

Implementar Data Lineage em Governação de Dados começa por um modelo de metadados simples e pela captura automática de logs do ETL. Próximos passos: enriquecer metadados (colunas, transformações SQL), integrar com Microsoft Purview ou criar visualizações mais ricas em Power BI. Dica: comece pequeno (um pipeline crítico) e expanda quando o processo estiver sólido — qual é o primeiro pipeline que vai rastrear?