Explorar guías rápidas · Microsoft Fabric
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
- Problema
- Respuesta rápida
- Código / comandos
- 1. Mantén Bronze alineada con el origen
- 2. Añade metadatos de ingesta en Bronze
- 3. Conserva las columnas de origen sin procesar cuando la conversión pueda fallar
- 4. Lleva la normalización del esquema a Silver
- 5. Valida las claves obligatorias en Silver
- 6. Pon en cuarentena los registros no válidos en lugar de borrar evidencias
- 7. Elimina duplicados en Silver con reglas deterministas
- 8. Usa MERGE para las entidades Silver modificables
- 9. Mantén Bronze como solo inserción siempre que sea posible
- 10. Usa Silver para entidades canónicas reutilizables
- 11. Construye Gold a partir de Silver fiable, no directamente de los datos sin procesar
- 12. Coloca las métricas de negocio en Gold
- 13. Haz explícita la granularidad de Gold
- 14. Valida la unicidad en Gold
- 15. Concilia los totales entre Silver y Gold
- 16. Usa ingesta incremental en Bronze
- 17. No avances el watermark antes de que los datos sean duraderos
- 18. Haz que la carga incremental de Silver sea idempotente
- 19. Propaga el linaje operativo entre capas
- 20. Separa los metadatos técnicos de las columnas de negocio
- 21. Usa un diseño Medallion centrado en el Lakehouse para cargas de ingeniería intensivas
- 22. Usa un Warehouse como Gold cuando necesites una capa de publicación centrada en SQL
- 23. Gold no significa solo agregación
- 24. No mezcles la limpieza del origen con el formato para el consumidor
- 25. Usa shortcuts cuando los datos no deban copiarse
- 26. Mantén clara la propiedad por dominio
- 27. Organiza primero por dominio cuando crezca la escala
- 28. Usa controles de calidad entre capas
- 29. Registra métricas de calidad
- 30. Evita recalcular la misma lógica Silver costosa para cada consumidor Gold
- 31. Haz que los contratos de cada capa sean versionables
- 32. Prefiere esquemas explícitos para las capas estables
- 33. No sobrescribas la tabla completa en cada actualización de Silver
- 34. Usa reconstrucciones completas de forma intencionada para tablas Gold pequeñas y deterministas
- 35. Conserva el historial cuando el negocio lo necesite
- 36. Ten en cuenta los datos que llegan tarde en el diseño
- 37. Vuelve a procesar desde Bronze cuando cambie la lógica de transformación
- 38. Separa el tiempo de negocio del tiempo de ingesta
- 39. Usa las tablas Gold para estabilizar los contratos con los consumidores
- 40. Documenta cada capa con cuatro preguntas
- Qué significa el resultado
- Qué revisar
- Bronze contiene lógica de negocio compleja
- Las tablas Silver son distintas para cada informe
- Gold sigue conteniendo códigos de origen sin procesar y lógica de limpieza
- Volver a ejecutar un lote genera duplicados
- Los datos no se pueden volver a procesar después de un error
- Los totales de Gold no cuadran con Silver
- Muchos consumidores limpian por su cuenta los mismos campos
- Notas de producción
- La arquitectura Medallion es lógica, no una separación física obligatoria
- Conservar Bronze tiene un costo
- Silver debe ser el principal contrato de ingeniería reutilizable
- Gold se puede implementar en un Lakehouse o en un Warehouse
- El procesamiento incremental debe ser de extremo a extremo
- Los controles de calidad deben corresponder a la capa
- OneLake reduce la necesidad de copias
- Errores comunes
- 1. Tratar Bronze como un vertedero sin metadatos
- 2. Limpiar los datos de forma destructiva en Bronze
- 3. Usar dropDuplicates() sin decidir qué registro debe conservarse
- 4. Poner toda la lógica de negocio directamente en Gold
- 5. Hacer que Silver sea específica de un consumidor
- 6. Reconstruir desde cero cada tabla grande en cada ejecución
- 7. Avanzar el watermark antes de que la escritura sea duradera
- 8. Ignorar los datos que llegan tarde
- 9. Crear un Warehouse solo porque «Gold debería ser un warehouse»
- 10. Crear tres capas sin diferencias reales de contrato
- Siguiente paso
- 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:
- Sistemas de origen
- Pipelines / shortcuts / notebooks
- Lakehouse Bronze
- Lakehouse Silver
- GoldLakehouse Gold o Fabric Warehouse
- Modelos semánticos / Power BI / API / informes
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.
¿Te resultó útil este contenido?
¿Qué podríamos mejorar?
Gracias — esto me ayuda a mejorar Javi Builds.
Mantente al día
Recibe solo las novedades de Javi Builds que realmente te interesan.
Revisa tu bandeja de entrada
Te he enviado un enlace de confirmación. Tu suscripción se activará cuando la confirmes.