Cómo hacer Data Lineage en Gobernanza de Datos: paso a paso

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

Este tutorial muestra cómo implementar Data Lineage en Gobernanza de Datos para rastrear el origen, las transformaciones y el consumo de un conjunto de datos. Conocer el lineage ayuda a diagnosticar errores, evaluar el impacto de cambios y cumplir requisitos de auditoría y conformidad.

Pre-requisitos

Acceso a un entorno con ETL/ELT (p. ej.: Azure Data Factory, Synapse u otro) y a una base de datos (p. ej.: Azure SQL o SQL Server).
Permisos para leer metadatos del pipeline y crear tablas de metadatos.
Conocimientos básicos de SQL y de cómo exportar logs del pipeline en JSON.

Paso 1: Definir el modelo de metadatos para Lineage

Antes de registrar cualquier cosa, define un modelo simple que describa fuentes, transformaciones y destinos. Un modelo mínimo tiene las tablas: entity (ficheros/tablas), process (ETL/transformación) y lineage (conecta entidades con procesos).

-- Exemplo de esquema mínimo en 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)
);

Paso 2: Capturar metadatos del pipeline/ETL

Configura tu ETL (p. ej.: Azure Data Factory) para exportar logs de ejecución en JSON o similar. El objetivo es extraer: run_id, nombres de datasets, timestamps y operaciones (copy, transform).

// Ejemplo conceptual de payload JSON que el pipeline debe 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"]
}

Paso 3: Cargar metadatos en las tablas de Lineage

Crea un proceso que convierta el JSON del pipeline en filas en las tablas entity, process y lineage. Puede ser un script T-SQL, un notebook Spark, o una función Azure Function.

-- Pseudocódigo T-SQL para insertar metadatos (simplificado)
DECLARE @run_id NVARCHAR(100) = 'abc-123';
-- Insertar 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();
-- Insertar entidades (p. ej.: fuente)
INSERT INTO entity (name,type,location)
VALUES ('stg.sales.csv','file','/lake/sales/2026/07');
DECLARE @source_id INT = SCOPE_IDENTITY();
-- insertar destino
INSERT INTO entity (name,type,location)
VALUES ('dw.sales','table','server.database.schema.dw.sales');
DECLARE @target_id INT = SCOPE_IDENTITY();
-- vincular
INSERT INTO lineage (process_id, source_entity_id, target_entity_id, details)
VALUES (@process_id,@source_id,@target_id,'copy,cleanse');

Paso 4: Automatizar ingestión y gestionar duplicados

Automatiza la carga de estos metadatos tras cada ejecución: usa triggers del pipeline, webhooks o un job programado. Evita duplicados verificando run_id y la ubicación de la entidad antes de insertar.

-- Verificación simple antes de insertar (ejemplo)
IF NOT EXISTS (SELECT 1 FROM process WHERE run_id = @run_id)
BEGIN
  -- insertar process y lineage como arriba
END

Paso 5: Visualizar Lineage y gestionar impacto

Crea queries o un dashboard (Power BI) que muestren el recorrido de una columna/tabla desde la fuente hasta el destino y que permitan calcular el impacto de un cambio en una entidad.

-- Ejemplo de query recursiva para seguir lineage de una entidad
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 el resultado

Confirma que cada ejecución del pipeline crea un registro en process y que existen entradas correspondientes en entity y lineage. Valida con queries simples: buscar por run_id y seguir el lineage con la query recursiva. En Power BI, comprueba si el grafo muestra fuentes y destinos correctos.

Conclusión

Implementar Data Lineage en Gobernanza de Datos comienza por un modelo de metadatos simple y por la captura automática de logs del ETL. Próximos pasos: enriquecer metadatos (columnas, transformaciones SQL), integrar con Microsoft Purview o crear visualizaciones más ricas en Power BI. Consejo: empieza pequeño (un pipeline crítico) y expande cuando el proceso esté sólido — ¿cuál es el primer pipeline que vas a rastrear?