Explorar guías rápidas · Microsoft Fabric

Tecnología: Microsoft FabricCategoría: ArquitecturaNivel: IntermedioActualizado

Arquitectura Medallion en Fabric

Diseña una arquitectura Bronze, Silver y Gold práctica en Microsoft Fabric, con contratos de datos claros, capacidad de reprocesamiento, procesamiento incremental, controles de calidad y responsabilidades de publicación bien definidas.

En esta página
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. Mantén Bronze alineada con el origen
  5. 2. Añade metadatos de ingesta en Bronze
  6. 3. Conserva las columnas de origen sin procesar cuando la conversión pueda fallar
  7. 4. Lleva la normalización del esquema a Silver
  8. 5. Valida las claves obligatorias en Silver
  9. 6. Pon en cuarentena los registros no válidos en lugar de borrar evidencias
  10. 7. Elimina duplicados en Silver con reglas deterministas
  11. 8. Usa MERGE para las entidades Silver modificables
  12. 9. Mantén Bronze como solo inserción siempre que sea posible
  13. 10. Usa Silver para entidades canónicas reutilizables
  14. 11. Construye Gold a partir de Silver fiable, no directamente de los datos sin procesar
  15. 12. Coloca las métricas de negocio en Gold
  16. 13. Haz explícita la granularidad de Gold
  17. 14. Valida la unicidad en Gold
  18. 15. Concilia los totales entre Silver y Gold
  19. 16. Usa ingesta incremental en Bronze
  20. 17. No avances el watermark antes de que los datos sean duraderos
  21. 18. Haz que la carga incremental de Silver sea idempotente
  22. 19. Propaga el linaje operativo entre capas
  23. 20. Separa los metadatos técnicos de las columnas de negocio
  24. 21. Usa un diseño Medallion centrado en el Lakehouse para cargas de ingeniería intensivas
  25. 22. Usa un Warehouse como Gold cuando necesites una capa de publicación centrada en SQL
  26. 23. Gold no significa solo agregación
  27. 24. No mezcles la limpieza del origen con el formato para el consumidor
  28. 25. Usa shortcuts cuando los datos no deban copiarse
  29. 26. Mantén clara la propiedad por dominio
  30. 27. Organiza primero por dominio cuando crezca la escala
  31. 28. Usa controles de calidad entre capas
  32. 29. Registra métricas de calidad
  33. 30. Evita recalcular la misma lógica Silver costosa para cada consumidor Gold
  34. 31. Haz que los contratos de cada capa sean versionables
  35. 32. Prefiere esquemas explícitos para las capas estables
  36. 33. No sobrescribas la tabla completa en cada actualización de Silver
  37. 34. Usa reconstrucciones completas de forma intencionada para tablas Gold pequeñas y deterministas
  38. 35. Conserva el historial cuando el negocio lo necesite
  39. 36. Ten en cuenta los datos que llegan tarde en el diseño
  40. 37. Vuelve a procesar desde Bronze cuando cambie la lógica de transformación
  41. 38. Separa el tiempo de negocio del tiempo de ingesta
  42. 39. Usa las tablas Gold para estabilizar los contratos con los consumidores
  43. 40. Documenta cada capa con cuatro preguntas
  44. Qué significa el resultado
  45. Qué revisar
  46. Bronze contiene lógica de negocio compleja
  47. Las tablas Silver son distintas para cada informe
  48. Gold sigue conteniendo códigos de origen sin procesar y lógica de limpieza
  49. Volver a ejecutar un lote genera duplicados
  50. Los datos no se pueden volver a procesar después de un error
  51. Los totales de Gold no cuadran con Silver
  52. Muchos consumidores limpian por su cuenta los mismos campos
  53. Notas de producción
  54. La arquitectura Medallion es lógica, no una separación física obligatoria
  55. Conservar Bronze tiene un costo
  56. Silver debe ser el principal contrato de ingeniería reutilizable
  57. Gold se puede implementar en un Lakehouse o en un Warehouse
  58. El procesamiento incremental debe ser de extremo a extremo
  59. Los controles de calidad deben corresponder a la capa
  60. OneLake reduce la necesidad de copias
  61. Errores comunes
  62. 1. Tratar Bronze como un vertedero sin metadatos
  63. 2. Limpiar los datos de forma destructiva en Bronze
  64. 3. Usar dropDuplicates() sin decidir qué registro debe conservarse
  65. 4. Poner toda la lógica de negocio directamente en Gold
  66. 5. Hacer que Silver sea específica de un consumidor
  67. 6. Reconstruir desde cero cada tabla grande en cada ejecución
  68. 7. Avanzar el watermark antes de que la escritura sea duradera
  69. 8. Ignorar los datos que llegan tarde
  70. 9. Crear un Warehouse solo porque «Gold debería ser un warehouse»
  71. 10. Crear tres capas sin diferencias reales de contrato
  72. Siguiente paso
  73. Para profundizar

Problema

Necesitas organizar una plataforma de datos de Microsoft Fabric de forma que la ingesta sin procesar, la limpieza, la transformación de negocio y los informes no acaben en un único notebook enorme ni en una sola tabla frágil.

Una arquitectura Medallion separa las responsabilidades en capas:

Bronze
→ ingesta alineada con el origen y reprocesable

Silver
→ datos validados, estandarizados y sin duplicados

Gold
→ modelos de publicación listos para el negocio

Lo difícil no es ponerles nombre a las capas.

Las verdaderas preguntas de diseño son:

  • ¿Qué debe ir exactamente en cada capa?
  • ¿Bronze debe ser modificable o de solo inserción?
  • ¿Dónde se deben eliminar los duplicados?
  • ¿Dónde deben vivir las reglas de negocio?
  • ¿Cuándo debe Gold ser un Lakehouse y cuándo un Warehouse?
  • ¿Cómo avanzan las cargas incrementales por las capas?
  • ¿Adónde van los fallos de calidad de datos?
  • ¿Cómo vuelves a ejecutar un proceso de forma segura sin duplicar datos?
  • ¿Cómo evitas repetir las mismas transformaciones en cada consumidor?

Respuesta rápida

Usa este modelo de responsabilidades:

Bronze
- conservar la fidelidad al origen
- insertar o depositar los datos de origen
- conservar los metadatos de ingesta
- hacer posible el reprocesamiento

Silver
- estandarizar el esquema
- convertir los tipos
- eliminar duplicados
- validar las claves
- aplicar las reglas de negocio propias del origen
- crear entidades fiables y reutilizables

Gold
- dar forma a los datos para su consumo
- agregar
- modelar las métricas de negocio
- crear hechos/dimensiones o tablas de informes seleccionadas
- optimizar para uso en BI/API/informes

Un flujo práctico en Fabric:

  1. Sistemas de origen
  2. Pipelines / shortcuts / notebooks
  3. Lakehouse Bronze
  4. Lakehouse Silver
  5. GoldLakehouse Gold o Fabric Warehouse
  6. Modelos semánticos / Power BI / API / informes
Un flujo Medallion práctico en Fabric

No crees una capa solo porque el diagrama de arquitectura diga que debería existir.

Cada capa debe eliminar un tipo concreto de ambigüedad o de riesgo operativo.

Código / comandos

1. Mantén Bronze alineada con el origen

Ejemplo de evento de origen:

{
  "sale_id": "10001",
  "merchant_id": "501",
  "sale_time": "2026-10-04T15:30:00Z",
  "amount": "125.50"
}

Una representación Bronze debe conservar el significado del origen y añadir metadatos de ingesta, en lugar de transformarlo todo de inmediato en agregados de negocio.

Ejemplo en PySpark:

from pyspark.sql import functions as F

bronze = (
    source_df
    .withColumn(
        "_ingested_at_utc",
        F.current_timestamp(),
    )
    .withColumn(
        "_source_file",
        F.input_file_name(),
    )
    .withColumn(
        "_pipeline_run_id",
        F.lit(pipeline_run_id),
    )
)

Escritura:

(
    bronze.write
    .format("delta")
    .mode("append")
    .saveAsTable("bronze_sales")
)

Usa Bronze para conservar suficientes evidencias como para volver a procesar los datos más adelante.


2. Añade metadatos de ingesta en Bronze

Entre los metadatos útiles pueden estar:

_ingested_at_utc
_pipeline_run_id
_batch_id
_source_file
_source_system
_source_modified_at

Ejemplo:

bronze = (
    source_df
    .withColumn(
        "_source_system",
        F.lit("transaction-api"),
    )
    .withColumn(
        "_batch_id",
        F.lit(batch_id),
    )
    .withColumn(
        "_ingested_at_utc",
        F.current_timestamp(),
    )
)

Esto ayuda con:

  • el linaje
  • el reprocesamiento
  • la investigación de duplicados
  • la conciliación con el origen
  • el análisis de incidentes

No añadas credenciales ni secretos como metadatos.


3. Conserva las columnas de origen sin procesar cuando la conversión pueda fallar

Supón que Bronze contiene:

amount = "$125.50"
sale_time = "10/04/2026 15:30"

En Silver, conserva el valor original mientras creas el valor tipado durante la validación:

silver_stage = (
    bronze
    .withColumn(
        "amount_decimal",
        F.regexp_replace(
            F.col("amount"),
            r"[\$,]",
            "",
        ).cast("decimal(18,2)"),
    )
    .withColumn(
        "sale_timestamp",
        F.to_timestamp(
            "sale_time",
            "MM/dd/yyyy HH:mm",
        ),
    )
)

No destruyas el valor de origen antes de saber si la conversión ha funcionado.


4. Lleva la normalización del esquema a Silver

Ejemplo:

silver = (
    bronze
    .select(
        F.col("sale_id").cast("long").alias("sale_id"),
        F.col("merchant_id").cast("int").alias("merchant_id"),
        F.to_timestamp("sale_time").alias("sale_time"),
        F.col("amount").cast("decimal(18,2)").alias("amount"),
        "_ingested_at_utc",
        "_pipeline_run_id",
    )
)

Silver es donde las peculiaridades de cada origen deben convertirse en un contrato interno estable.


5. Valida las claves obligatorias en Silver

Ejemplo:

invalid_keys = (
    silver
    .filter(
        F.col("sale_id").isNull()
        | F.col("merchant_id").isNull()
    )
)

Recuento:

invalid_count = invalid_keys.count()

Si las claves obligatorias deben existir siempre:

if invalid_count > 0:
    raise RuntimeError(
        f"Silver validation failed: "
        f"{invalid_count} rows have missing required keys"
    )

Que el proceso falle o que los registros vayan a cuarentena depende del contrato del origen.

No descartes en silencio los registros no válidos sin dejar constancia de ellos.


6. Pon en cuarentena los registros no válidos en lugar de borrar evidencias

Ejemplo:

valid = (
    silver
    .filter(
        F.col("sale_id").isNotNull()
        & F.col("merchant_id").isNotNull()
    )
)

invalid = (
    silver
    .filter(
        F.col("sale_id").isNull()
        | F.col("merchant_id").isNull()
    )
)

Escribe las filas no válidas por separado:

(
    invalid.write
    .format("delta")
    .mode("append")
    .saveAsTable("quarantine_sales")
)

Usa la cuarentena cuando las filas erróneas deban investigarse en lugar de eliminarse en silencio.


7. Elimina duplicados en Silver con reglas deterministas

Ejemplo:

from pyspark.sql import Window

w = (
    Window
    .partitionBy("sale_id")
    .orderBy(
        F.col("source_updated_at").desc(),
        F.col("_ingested_at_utc").desc(),
    )
)

silver_deduped = (
    silver
    .withColumn(
        "_rn",
        F.row_number().over(w),
    )
    .filter(
        F.col("_rn") == 1
    )
    .drop("_rn")
)

Esto es mejor que:

dropDuplicates(["sale_id"])

cuando importa qué fila se conserva.

Define qué fila prevalece.


8. Usa MERGE para las entidades Silver modificables

Para entidades de negocio que pueden cambiar:

from delta.tables import DeltaTable

target = DeltaTable.forName(
    spark,
    "silver_sales",
)

(
    target.alias("t")
    .merge(
        silver_deduped.alias("s"),
        "t.sale_id = s.sale_id",
    )
    .whenMatchedUpdateAll()
    .whenNotMatchedInsertAll()
    .execute()
)

Usa MERGE cuando las claves existentes puedan recibir correcciones o actualizaciones posteriores.

No insertes a ciegas entidades modificables.


9. Mantén Bronze como solo inserción siempre que sea posible

Un buen punto de partida:

Bronze = historial del origen de solo inserción
Silver = conciliación del estado fiable actual

Así resulta más fácil:

  • volver a ejecutar las transformaciones
  • investigar defectos del origen
  • comparar la lógica antigua con la nueva
  • reparar las capas posteriores

Hay excepciones válidas, pero modificar Bronze debe ser una decisión deliberada.


10. Usa Silver para entidades canónicas reutilizables

Ejemplos de tablas Silver:

silver_sales
silver_customers
silver_merchants
silver_products
silver_commissions

Deben poder reutilizarlas varios consumidores posteriores.

Evita lógica específica de un consumidor, como:

formato de paneles de Power BI
etiquetas de informes puntuales
nombres de columnas específicos de una API

dentro de las tablas Silver compartidas, salvo que forme parte realmente de la definición de negocio de la empresa.


11. Construye Gold a partir de Silver fiable, no directamente de los datos sin procesar

Ejemplo:

gold_daily_sales = (
    spark.table("silver_sales")
    .groupBy(
        "sale_date",
        "merchant_id",
    )
    .agg(
        F.sum("amount").alias("revenue"),
        F.countDistinct("sale_id").alias("sales"),
    )
)

Escritura:

(
    gold_daily_sales.write
    .format("delta")
    .mode("overwrite")
    .saveAsTable("gold_daily_sales")
)

Para tablas Gold grandes, usa un patrón incremental controlado en lugar de reconstruirlas siempre.


12. Coloca las métricas de negocio en Gold

Ejemplos:

ingresos diarios por comercio
valor de vida del cliente
resumen de comisiones
clientes activos mensuales
métricas de conversión
hechos y dimensiones de informes

Gold es el lugar adecuado para definir una semántica de negocio lista para usar que debe ser coherente entre consumidores.


13. Haz explícita la granularidad de Gold

Para cada tabla Gold, documenta:

Una fila representa:
comercio + fecha del calendario

o bien:

Una fila representa:
cliente + mes del informe

Ejemplo:

gold_merchant_daily_sales
granularidad = merchant_id + sale_date

Esto evita el doble conteo en las capas posteriores.


14. Valida la unicidad en Gold

Si la granularidad es:

merchant_id + sale_date

valídala:

duplicates = (
    gold_daily_sales
    .groupBy(
        "merchant_id",
        "sale_date",
    )
    .count()
    .filter(
        F.col("count") > 1
    )
)

if duplicates.limit(1).count() > 0:
    raise RuntimeError(
        "Gold grain validation failed"
    )

Una tabla Gold debe garantizar su granularidad lógica mediante controles operativos, aunque la capa de almacenamiento no aplique una restricción de unicidad.


15. Concilia los totales entre Silver y Gold

Ejemplo:

silver_total = (
    spark.table("silver_sales")
    .filter(
        F.col("sale_date") == "2026-10-04"
    )
    .agg(
        F.sum("amount").alias("amount")
    )
    .first()["amount"]
)

gold_total = (
    spark.table("gold_daily_sales")
    .filter(
        F.col("sale_date") == "2026-10-04"
    )
    .agg(
        F.sum("revenue").alias("amount")
    )
    .first()["amount"]
)

Después compara:

if silver_total != gold_total:
    raise RuntimeError(
        "Silver-to-Gold reconciliation failed"
    )

Aplica tolerancias cuando la aritmética de coma flotante o reglas de transformación válidas lo requieran.

Para datos financieros, prefiere tipos decimales exactos siempre que sea viable.


16. Usa ingesta incremental en Bronze

Patrón de ejemplo:

último watermark procesado
→ registros de origen posteriores al watermark
→ insertar en Bronze
→ guardar el nuevo watermark solo tras completarse correctamente

Un watermark puede ser:

source_modified_at
ID incremental
secuencia CDC
hora de llegada del archivo
ID de lote

Elige el que coincida con la semántica del origen.


17. No avances el watermark antes de que los datos sean duraderos

Orden incorrecto:

1. actualizar el watermark
2. escribir en Bronze

Orden más seguro:

1. leer el origen
2. escribir en Bronze
3. validar la escritura
4. actualizar el watermark

De lo contrario, un fallo entre pasos puede hacer que se pierdan datos de forma permanente.


18. Haz que la carga incremental de Silver sea idempotente

Ejemplo:

Lote Bronze
→ eliminar duplicados del origen
→ MERGE en Silver por clave de negocio

Así, el mismo lote Bronze puede volver a procesarse de forma segura.

Usa claves de negocio estables y un orden de actualización estable.


19. Propaga el linaje operativo entre capas

Columnas de ejemplo:

_source_system
_batch_id
_pipeline_run_id
_ingested_at_utc
_source_updated_at

No necesitas todos los campos de metadatos en cada tabla Gold.

Pero conserva suficiente linaje para responder:

¿De dónde viene esta fila?
¿Qué carga la generó?
¿Qué marca de tiempo del origen prevaleció?

20. Separa los metadatos técnicos de las columnas de negocio

Una convención clara ayuda:

Columnas de negocio
sale_id
merchant_id
amount

Columnas técnicas
_ingested_at_utc
_batch_id
_pipeline_run_id

Así los campos operativos resultan evidentes.

Aplica un estándar de nomenclatura de forma coherente.


21. Usa un diseño Medallion centrado en el Lakehouse para cargas de ingeniería intensivas

Una implementación habitual en Fabric:

Lakehouse
  bronze_*
  silver_*
  gold_*

Úsala cuando:

  • Spark sea el motor principal
  • las tablas Delta sean el almacenamiento principal
  • los equipos de ingeniería sean responsables de la lógica de transformación
  • Power BI pueda consumir datos preparados del Lakehouse

A menudo esto es suficiente sin añadir un Warehouse.


22. Usa un Warehouse como Gold cuando necesites una capa de publicación centrada en SQL

Ejemplo:

Lakehouse Bronze
→ Lakehouse Silver
→ Fabric Warehouse Gold

Úsalo cuando la capa de publicación necesite:

  • DML de T-SQL completo
  • procedimientos almacenados
  • modelado dimensional
  • publicación relacional
  • transacciones SQL de varias tablas

No copies datos a un Warehouse salvo que la capa de publicación SQL aporte un valor claro.


23. Gold no significa solo agregación

Una tabla Gold puede ser:

tabla de hechos
dimensión
tabla de informes amplia
entidad de negocio
agregado
conjunto de datos servido por API

La propiedad que la define es:

semántica de negocio lista para los consumidores

y no simplemente:

datos agregados

24. No mezcles la limpieza del origen con el formato para el consumidor

Ejemplo:

Silver:
country_code = "US"

Gold/informe:
country_display = "Estados Unidos"

Mantén separadas la normalización del origen y la presentación para el consumidor cuando cumplan propósitos distintos.

Esto reduce el acoplamiento entre la ingeniería de datos y un informe concreto.


25. Usa shortcuts cuando los datos no deban copiarse

Si los datos externos o de otro dominio ya existen y no requieren duplicación física:

Ubicación de origen
→ OneLake shortcut
→ consumidor Bronze/Silver

Usa shortcuts cuando:

  • la propiedad de los datos siga estando en otro lugar
  • la actualización deba seguir ligada al origen
  • duplicar los datos aporte poco valor

No uses shortcuts a ciegas cuando necesites:

  • instantáneas estables
  • aislamiento respecto al origen
  • retención controlada
  • reprocesamiento reproducible

26. Mantén clara la propiedad por dominio

Ejemplo:

Dominio de ventas
- bronze_sales
- silver_sales
- gold_sales_daily

Dominio de clientes
- bronze_customers
- silver_customers
- gold_customer_360

Evita un único workspace o espacio de nombres de tablas gigante donde nadie sabe quién es el propietario de un conjunto de datos.

Las capas Medallion no sustituyen la propiedad por dominio.


27. Organiza primero por dominio cuando crezca la escala

Un patrón escalable puede ser:

Lakehouse de ventas
  Bronze
  Silver
  Gold

Lakehouse de comisiones
  Bronze
  Silver
  Gold

en lugar de:

Un Lakehouse Bronze corporativo
Un Lakehouse Silver corporativo
Un Lakehouse Gold corporativo

Ambos pueden funcionar.

Elige en función de:

  • los límites entre equipos
  • la seguridad
  • el despliegue
  • la propiedad de los datos
  • el aislamiento de cargas de trabajo

No impongas una única topología a todas las organizaciones.


28. Usa controles de calidad entre capas

Ejemplos de controles Bronze → Silver:

campos obligatorios presentes
esquema analizable
clave de negocio válida
marca de tiempo válida
reglas de duplicados del origen aplicadas

Ejemplos de controles Silver → Gold:

unicidad de la granularidad
conciliación de métricas
joins de referencia válidos
sin claves huérfanas donde no se permitan
cobertura de fechas de los informes

Promueve los datos solo cuando se cumpla el contrato de la capa.


29. Registra métricas de calidad

Ejemplo:

metrics = {
    "rows_in": bronze.count(),
    "rows_valid": valid.count(),
    "rows_invalid": invalid.count(),
}

En cargas de trabajo grandes, evita lanzar innecesariamente varios recorridos costosos.

Prefiere una sola pasada de calidad agregada siempre que sea viable.

Las métricas operativas deben incluir:

filas leídas
filas escritas
filas rechazadas
claves duplicadas
claves obligatorias nulas
ID de lote
ID de ejecución

30. Evita recalcular la misma lógica Silver costosa para cada consumidor Gold

Incorrecto:

Informe Gold A
→ analizar datos sin procesar
→ eliminar duplicados
→ normalizar

Informe Gold B
→ analizar datos sin procesar
→ eliminar duplicados
→ normalizar

Mejor:

Bronze
→ Silver compartida
   ├→ Informe Gold A
   └→ Informe Gold B

Silver debe eliminar la lógica de transformación repetida a nivel de origen.


31. Haz que los contratos de cada capa sean versionables

Si Silver cambia:

customer_id int
→ customer_id string

puede romper a los consumidores Gold posteriores.

Trata los cambios de esquema importantes como contratos.

Usa:

  • despliegue versionado
  • comprobaciones de compatibilidad
  • validación del esquema
  • cambios coordinados en las capas posteriores

No permitas que una evolución de esquema sin control se convierta en la arquitectura.


32. Prefiere esquemas explícitos para las capas estables

Ejemplo:

from pyspark.sql.types import (
    StructType,
    StructField,
    LongType,
    IntegerType,
    DecimalType,
    TimestampType,
)

sales_schema = StructType([
    StructField("sale_id", LongType(), False),
    StructField("merchant_id", IntegerType(), False),
    StructField("amount", DecimalType(18, 2), False),
    StructField("sale_time", TimestampType(), False),
])

Los esquemas explícitos son especialmente útiles en los límites de ingesta con contratos conocidos.


33. No sobrescribas la tabla completa en cada actualización de Silver

Para tablas grandes y modificables, prefiere:

origen incremental
→ eliminar duplicados
→ MERGE en Silver

en lugar de:

leer todo el historial de Bronze
→ reconstruir toda la capa Silver
→ sobrescribir

Las reconstrucciones completas pueden ser útiles para recargas históricas (backfills) o tablas pequeñas, pero no deberían ser la opción por defecto si mantener un estado incremental es viable.


34. Usa reconstrucciones completas de forma intencionada para tablas Gold pequeñas y deterministas

Ejemplo:

(
    gold_dimension.write
    .format("delta")
    .mode("overwrite")
    .saveAsTable("gold_dim_date")
)

Una reconstrucción completa es razonable cuando:

  • la tabla es pequeña
  • la lógica es determinista
  • el costo es bajo
  • un reemplazo atómico es aceptable desde el punto de vista operativo

No todas las tablas necesitan la complejidad de una carga incremental.


35. Conserva el historial cuando el negocio lo necesite

Para entidades que cambian, como los atributos de cliente, decide si Silver representa:

solo el estado actual

o bien:

versiones históricas

No sobrescribas el historial por accidente si el negocio requiere dimensiones de variación lenta o auditabilidad.

Esta decisión afecta a:

  • el modelo Silver
  • las dimensiones Gold
  • la lógica de merge
  • las fechas de vigencia

36. Ten en cuenta los datos que llegan tarde en el diseño

Ejemplo:

sale_date = 2026-10-01
llegada = 2026-10-04

Si Gold está particionada o agregada por fecha de negocio, el pipeline debe poder actualizar periodos anteriores.

No des por hecho que:

la ingesta de hoy solo afecta al Gold de hoy

Usa explícitamente las marcas de tiempo de negocio y reglas para las llegadas tardías.


37. Vuelve a procesar desde Bronze cuando cambie la lógica de transformación

Una de las principales ventajas de conservar Bronze es poder volver a procesar los datos.

Ejemplo:

Error en la normalización de Silver
→ corregir la lógica
→ reprocesar el rango de fechas de Bronze afectado
→ reconstruir/MERGE Silver
→ reconstruir el Gold afectado

Esto es mucho más seguro que intentar reconstruir los valores de origen a partir de datos Gold ya transformados.


38. Separa el tiempo de negocio del tiempo de ingesta

Ejemplo:

sale_time
→ cuándo ocurrió el evento de negocio

_ingested_at_utc
→ cuándo lo recibió Fabric

Ambos pueden ser importantes.

No sustituyas uno por el otro.

Esta distinción es importante para:

  • las llegadas tardías
  • el monitoreo de los SLA
  • el reprocesamiento
  • el análisis de la latencia del origen

39. Usa las tablas Gold para estabilizar los contratos con los consumidores

Un informe no debería tener que entender:

códigos de origen sin procesar
comportamiento de duplicados del origen
secuenciación CDC
marcas de tiempo específicas del origen
columnas de staging temporales

Gold debe exponer un significado de negocio estable.

Eso reduce la duplicación y el acoplamiento en las capas posteriores.


40. Documenta cada capa con cuatro preguntas

Para cada tabla, documenta:

1. ¿Qué representa una fila?
2. ¿Cuál es la clave de negocio?
3. ¿Cómo se carga la tabla?
4. ¿Qué reglas de calidad deben cumplirse?

Ejemplo:

Tabla:
silver_sales

Granularidad:
una fila por sale_id

Clave de negocio:
sale_id

Carga:
MERGE incremental

Calidad:
sale_id no nulo
merchant_id no nulo
amount >= 0 donde lo exijan las reglas de negocio
prevalece la última actualización del origen

Esto es más útil que un diagrama que solo dice Bronze / Silver / Gold.

Qué significa el resultado

Capa Responsabilidad principal
Bronze Conservar los datos de origen y la capacidad de reprocesamiento
Silver Estandarizar, validar, eliminar duplicados y crear datos fiables y reutilizables
Gold Exponer una semántica de negocio lista para los consumidores
Cuarentena Conservar los registros no válidos o rechazados para su investigación
Gold en Warehouse Publicación relacional centrada en SQL cuando sea necesaria
Gold en Lakehouse Publicación orientada a Delta, Spark y Direct Lake

La distinción más importante es:

Bronze = verdad del origen
Silver = verdad operativa fiable
Gold = verdad del consumidor

Es un principio de diseño, no una regla universal del producto.

Qué revisar

Bronze contiene lógica de negocio compleja

Probablemente la capa sin procesar está haciendo demasiado.

Pregúntate si esas transformaciones corresponden a Silver.

Las tablas Silver son distintas para cada informe

Probablemente Silver es demasiado específica de los consumidores.

Lleva la lógica canónica reutilizable a entidades Silver compartidas.

Gold sigue conteniendo códigos de origen sin procesar y lógica de limpieza

Probablemente Gold no está lista para los consumidores.

Lleva la normalización del origen a las capas anteriores.

Volver a ejecutar un lote genera duplicados

La ruta incremental no es idempotente.

Revisa:

  • el comportamiento de inserción
  • la clave de negocio
  • el ID de lote
  • la lógica de merge
  • la gestión del watermark

Los datos no se pueden volver a procesar después de un error

La retención o el linaje de Bronze son insuficientes.

Conserva datos alineados con el origen y los metadatos de ejecución.

Los totales de Gold no cuadran con Silver

Revisa:

  • la cardinalidad de los joins
  • la granularidad duplicada
  • los datos que llegan tarde
  • los filtros
  • los joins con dimensiones
  • la lógica de agregación

Muchos consumidores limpian por su cuenta los mismos campos

A Silver le falta un contrato canónico reutilizable.

Notas de producción

La arquitectura Medallion es lógica, no una separación física obligatoria

Bronze, Silver y Gold pueden estar en:

  • un solo Lakehouse
  • varios Lakehouses
  • workspaces separados
  • una combinación de Lakehouse y Warehouse

Elige la separación física en función de:

  • la seguridad
  • la propiedad
  • el despliegue
  • el aislamiento de cargas de trabajo
  • la escala operativa

No equipares una capa con un elemento de Fabric obligatorio.

Conservar Bronze tiene un costo

Guardar todo el historial sin procesar mejora la capacidad de reprocesamiento, pero consume almacenamiento.

Define la retención en función de:

  • la posibilidad de volver a leer el origen
  • el cumplimiento normativo
  • las necesidades de auditoría
  • la estrategia de recuperación
  • el costo de almacenamiento

Silver debe ser el principal contrato de ingeniería reutilizable

Si cada consumidor se salta Silver y lee Bronze directamente, la arquitectura pierde la mayor parte de su valor.

Restringe o desaconseja el consumo de Bronze cuando corresponda.

Gold se puede implementar en un Lakehouse o en un Warehouse

Elige en función de las necesidades de publicación.

Usa Gold en Lakehouse cuando:

  • Delta, Spark y Direct Lake encajen
  • no se necesite la semántica de escritura completa de T-SQL

Usa Gold en Warehouse cuando:

  • la publicación relacional centrada en SQL sea importante
  • se necesiten procedimientos almacenados o transacciones SQL de varias tablas

El procesamiento incremental debe ser de extremo a extremo

No basta con que solo Bronze sea incremental.

Analiza todo el recorrido:

Origen → Bronze → Silver → Gold

Cada capa debe definir cómo se propagan las reejecuciones, los datos tardíos y las correcciones.

Los controles de calidad deben corresponder a la capa

Bronze puede tolerar valores mal formados para conservar las evidencias.

Silver debe exigir una validez estructural y de claves de negocio más estricta.

Gold debe garantizar la granularidad orientada al consumidor y la coherencia de las métricas.

OneLake reduce la necesidad de copias

Usa shortcuts y patrones de almacenamiento compartido cuando encajen con el modelo de propiedad.

Copia datos solo cuando la capa de destino necesite:

  • un ciclo de vida independiente
  • aislamiento del esquema
  • una organización física orientada al rendimiento
  • un límite de recuperación
  • un límite de propiedad

Errores comunes

1. Tratar Bronze como un vertedero sin metadatos

Sin metadatos de origen y de ejecución, el reprocesamiento y el análisis de incidentes se complican.

2. Limpiar los datos de forma destructiva en Bronze

Puedes perder las evidencias necesarias para entender más adelante los defectos del origen.

3. Usar dropDuplicates() sin decidir qué registro debe conservarse

La eliminación de duplicados debe ser determinista.

4. Poner toda la lógica de negocio directamente en Gold

Esto obliga a todos los consumidores posteriores a depender de una única ruta de transformación grande y dificulta la reutilización.

5. Hacer que Silver sea específica de un consumidor

Silver debe representar entidades fiables y reutilizables, no el diseño exacto de un informe.

6. Reconstruir desde cero cada tabla grande en cada ejecución

Usa patrones incrementales cuando el origen y las claves de negocio lo permitan.

7. Avanzar el watermark antes de que la escritura sea duradera

Esto puede crear huecos permanentes en los datos después de un fallo.

8. Ignorar los datos que llegan tarde

Los agregados por fecha de negocio pueden necesitar actualizar periodos históricos.

9. Crear un Warehouse solo porque «Gold debería ser un warehouse»

Gold puede quedarse en un Lakehouse cuando eso satisface bien a los consumidores.

10. Crear tres capas sin diferencias reales de contrato

Cambiar el nombre de las tablas:

bronze_x
silver_x
gold_x

no crea por sí solo una arquitectura.

Cada capa necesita una responsabilidad diferenciada.

Siguiente paso

Usa la pregunta de diseño para elegir la siguiente acción.

  • Necesitas poder reprocesar los datos sin procesar → mantén Bronze alineada con el origen y con metadatos de ingesta.
  • Los datos de origen están desordenados → normaliza y valida en Silver.
  • Hay claves de origen duplicadas → define una eliminación de duplicados determinista en Silver.
  • Las entidades existentes pueden cambiar → usa un MERGE incremental en Silver.
  • Los consumidores necesitan métricas estables → define explícitamente la granularidad y la semántica de negocio de Gold.
  • Gold requiere publicación T-SQL completa → considera un Fabric Warehouse.
  • Gold es principalmente para Delta, Power BI o Direct Lake → Gold en Lakehouse puede ser suficiente.
  • Las reejecuciones generan duplicados → diseña la idempotencia en todas las capas.
  • Los datos tardíos modifican periodos históricos → define el comportamiento de recarga y actualización.
  • Aparece un error en una transformación → vuelve a procesar el rango afectado desde Bronze y reconstruye las capas posteriores.

← Todas las guías rápidas