Lab 01
Análisis de ventas de extremo a extremo en Microsoft Fabric
Construye una solución completa de análisis en Microsoft Fabric: área de trabajo y Lakehouse, transformaciones Bronze, Silver y Gold, y orquestación con un pipeline.
- Estado
- Disponible
- Nivel
- Intermedio
- Actualizado
Objetivo: Construir una solución de análisis que funcione, desde los archivos sin procesar hasta una capa Gold orquestada.
Lo que tendrás al final
- Un área de trabajo de Fabric y un Lakehouse
- Archivos CSV sin procesar cargados en OneLake
- Tablas Delta Bronze, Silver y Gold construidas con notebooks de PySpark
- Un pipeline de Fabric que ejecuta los tres notebooks en orden
Antes de empezar
- Acceso a Microsoft Fabric: una prueba o una capacidad de Fabric
- Conocimientos básicos de Python; la experiencia con PySpark ayuda, pero no es imprescindible
- Los cinco archivos CSV de ejemplo (clientes, productos, órdenes de compra, pedidos de venta y líneas de pedido)
- Área de trabajo
- Lakehouse
- PySpark
- Delta Lake
- Arquitectura medallion
- Pipeline de Fabric
Este lab construye una solución de análisis pequeña pero completa en Microsoft Fabric. Cada captura procede de una construcción real del proyecto y cada nombre de objeto es el que se usó en ella, así que puedes seguirlo en tu propio inquilino y comparar.
El lab es deliberadamente compacto: un área de trabajo, un Lakehouse, tres notebooks y un pipeline. Los modelos semánticos, los informes de Power BI, el registro de ejecución y el despliegue con Git llegarán en los labs siguientes.
Qué vas a construir
Los archivos CSV sin procesar llegan al Lakehouse, tres notebooks los refinan capa a capa y un pipeline ejecuta los notebooks en orden.
- 1Área de trabajows_demo
- 2Lakehousedemo
- 3Archivos CSV sin procesarFiles/raw
- 4Tablas Delta Bronzenb_02_bronze_ingestion
- 5Datos Silver limpiosnb_03_silver_transformations
- 6Calidad de datos y solución de problemasInspeccionar, corregir, volver a ejecutar, verificar
- 7Capa Gold para informesnb_04_gold_model
- 8Orquestación con un pipeline de Fabricpl_sales_analytics
Los nombres que se usan en todo el lab:
| Objeto | Nombre |
|---|---|
| Área de trabajo | ws_demo |
| Lakehouse | demo |
| Carpeta de aterrizaje | Files/raw |
| Notebook Bronze | nb_02_bronze_ingestion |
| Notebook Silver | nb_03_silver_transformations |
| Notebook Gold | nb_04_gold_model |
| Pipeline | pl_sales_analytics |
Paso 1 — Crear el área de trabajo
Un área de trabajo contiene todo lo que produce este lab: el Lakehouse, los notebooks y el pipeline. Crea una llamada ws_demo. El tutorial completo sobre el área de trabajo detalla cada opción; aquí solo hace falta lo esencial.
(abrir la captura a tamaño completo)Un área de trabajo vacía se abre en su página de inicio. La lista de elementos de abajo se llena a medida que creas el Lakehouse, los notebooks y el pipeline en los pasos siguientes.
(abrir la captura a tamaño completo)El tipo de área de trabajo decide qué capacidad ejecuta el trabajo. Los elementos de Fabric, como Lakehouses, notebooks y pipelines, necesitan un tipo de área de Fabric; esta construcción usa Fabric Trial.
(abrir la captura a tamaño completo)Manage access controla quién puede abrir y modificar el área de trabajo. En un lab personal puedes seguir siendo el único Admin; en un equipo, da a cada persona el rol más restringido que necesite.
(abrir la captura a tamaño completo)Por último, mira Workspace settings › Git integration. En este lab no conectas Git, pero saber que el área está preparada para Git importará más adelante: el Lab 06 pone esta solución bajo control de versiones. Si quieres adelantarte, consulta cómo conectar Fabric a Git.
(abrir la captura a tamaño completo)Paso 2 — Crear el Lakehouse
En ws_demo, selecciona New item, busca Lakehouse y crea uno llamado demo. Un Lakehouse guarda los datos en OneLake y tiene dos zonas:
- Tables: tablas Delta administradas que Spark, SQL y Power BI pueden leer.
- Files: los archivos que quieras, en las carpetas que elijas. Aquí llegan los datos sin procesar.
(abrir la captura a tamaño completo)
(abrir la captura a tamaño completo)Fabric también crea un punto de conexión de SQL analytics para cada Lakehouse. Expone las tablas Delta en T-SQL, en solo lectura, lo que permite comprobar resultados sin abrir Spark.
(abrir la captura a tamaño completo)Los notebooks trabajan sobre un Lakehouse adjunto: spark.table("nombre") y saveAsTable("nombre") apuntan a su zona Tables. Adjunta demo a cada notebook de este lab.
(abrir la captura a tamaño completo)Las tablas demo_customers y demo_sales de estas capturas vienen del tutorial de notebooks de Microsoft Fabric. Si no lo seguiste, todavía no las tienes; el paso 7 explica dónde se usa demo_sales. Para profundizar en el diseño del Lakehouse, consulta crear tu primer Lakehouse de Fabric.
Paso 3 — Cargar los datos sin procesar
El proyecto usa cinco archivos CSV:
customers.csvproducts.csvpurchase_orders.csvsales_orders.csvsales_order_lines.csv
Crea una carpeta raw en Files, abre su menú … y elige Upload › Upload files.
(abrir la captura a tamaño completo)Files/raw es la zona de aterrizaje. Los archivos llegan sin cambios, tal como los produjo el origen, y nada posterior los modifica. Si una transformación sale mal, siempre puedes reconstruir a partir de lo que aterrizó.
(abrir la captura a tamaño completo)Abre customers.csv para comprobar lo que llegó. El encabezado muestra dos columnas separadas, first_name y last_name; recuérdalo, porque importa en el paso 5.
(abrir la captura a tamaño completo)Los datos de ejemplo son sintéticos: los nombres son generados y todas las direcciones de correo usan el dominio reservado example.com.
Paso 4 — Construir la capa Bronze
Crea un notebook llamado nb_02_bronze_ingestion en ws_demo y adjunta el Lakehouse demo.
(abrir la captura a tamaño completo)Bronze es una copia fiel del origen en formato Delta, con dos columnas que registran de dónde vino cada fila y cuándo llegó:
from pyspark.sql import functions as F
customers_df = (
spark.read
.option("header", True)
.option("inferSchema", True)
.csv("Files/raw/customers.csv")
.withColumn("_source_file", F.input_file_name())
.withColumn("_ingested_at", F.current_timestamp())
)
(abrir la captura a tamaño completo)Después escribe el DataFrame como tabla Delta:
(
customers_df.write
.format("delta")
.mode("overwrite")
.saveAsTable("bronze_customers")
)
(abrir la captura a tamaño completo)Actualiza Tables: aparece bronze_customers con las columnas originales más _source_file e _ingested_at.
(abrir la captura a tamaño completo)En esta versión del lab, Bronze solo ingiere customers.csv, para que cada paso se vea de principio a fin. Los otros cuatro archivos están en Files/raw pero todavía no se cargan; repetir las mismas dos celdas para ellos es un buen ejercicio. La guía Bronze, Silver, Gold explica qué corresponde a cada capa.
Paso 5 — Construir la capa Silver
Crea nb_03_silver_transformations y adjunta demo. Silver convierte Bronze en datos limpios, coherentes y comprensibles para el negocio:
- Eliminación de duplicados: una fila por
customer_id. - Recorte de espacios: sin espacios sobrantes alrededor de nombres, ciudades o segmentos.
- Estandarización: correos en minúsculas y códigos de estado y país en mayúsculas.
- Columnas de negocio: una sola columna
customer_nameconstruida a partir defirst_nameylast_name.
(abrir la captura a tamaño completo)from pyspark.sql import functions as F
bronze_customers_df = spark.table("bronze_customers")
silver_customers_df = (
bronze_customers_df
.dropDuplicates(["customer_id"])
# Clean first and last name
.withColumn("first_name", F.trim(F.col("first_name")))
.withColumn("last_name", F.trim(F.col("last_name")))
# Create a business-friendly full name
.withColumn(
"customer_name",
F.concat_ws(
" ",
F.col("first_name"),
F.col("last_name")
)
)
# Standardize text fields
.withColumn("email", F.lower(F.trim(F.col("email"))))
.withColumn("city", F.trim(F.col("city")))
.withColumn("state", F.upper(F.trim(F.col("state"))))
.withColumn("country", F.upper(F.trim(F.col("country"))))
.withColumn("segment", F.trim(F.col("segment")))
)
display(silver_customers_df)
(abrir la captura a tamaño completo)display() muestra 50 filas y 13 columnas: las diez columnas de origen, las dos de ingesta y la nueva customer_name. Escribe el resultado en Delta:
(
silver_customers_df.write
.format("delta")
.mode("overwrite")
.saveAsTable("silver_customers")
)
(abrir la captura a tamaño completo)Paso 6 — Calidad de datos y solución de problemas
El primer intento de Silver recortaba una columna que nunca existió en el origen:
silver_customers_df = (
spark.table("bronze_customers")
.dropDuplicates(["customer_id"])
.withColumn(
"customer_name",
F.trim(F.col("customer_name"))
)
.withColumn(
"country",
F.upper(F.trim(F.col("country")))
)
)
(abrir la captura a tamaño completo)Spark lo rechazó antes de procesar una sola fila:
(abrir la captura a tamaño completo)El error es [UNRESOLVED_COLUMN.WITH_SUGGESTION]: una columna llamada customer_name no se puede resolver, y Spark sugiere customer_id, last_name, first_name, segment y created_at. La corrección sigue una secuencia corta y repetible:
- Inspeccionar el esquema. Ejecuta
spark.table("bronze_customers").printSchema()o despliega la tabla en el explorador. - Identificar la columna que falta. Bronze tiene
first_nameylast_name, nocustomer_name. El archivo sin procesar tampoco la tenía (paso 3). - Corregir la transformación. Construye
customer_nameconconcat_wsa partir de las dos columnas que sí existen, en lugar de leerla. - Volver a ejecutar la celda.
- Verificar la tabla Silver. Revisa las filas mostradas y confirma que
silver_customersaparece en Tables con las columnas esperadas.
La lección va más allá de una columna: el código Silver debe escribirse contra el esquema que Bronze tiene de verdad, y por eso el paso 3 revisa el archivo sin procesar antes de que el código dependa de él.
Este lab termina con la transformación corregida. Las reglas de validación, las tablas de cuarentena para filas no válidas y los fallos recuperables son el tema del Lab 03.
Paso 7 — Construir la capa Gold
Crea nb_04_gold_model y adjunta demo. Gold contiene tablas pensadas para informes. Este lab mantiene a propósito un modelo Gold compacto, con tres objetos:
| Tabla | Función |
|---|---|
dim_customer |
Dimensión de clientes, a partir de los clientes Silver limpios |
fact_sales |
Una fila por pedido, con el importe y una franja de tamaño de pedido |
gold_sales_by_country |
Ventas preagregadas por país, listas para informes |
(abrir la captura a tamaño completo)dim_customer se construye a partir de silver_customers. Conserva las columnas descriptivas del cliente, incluida la columna customer_name derivada en Silver, deja fuera los metadatos de ingesta y garantiza una fila por customer_id:
silver_customers_df = spark.table("silver_customers")
dim_customer_df = (
silver_customers_df
.select(
"customer_id",
"customer_name",
"email",
"segment",
"city",
"state",
"country",
"created_at",
"is_active"
)
.dropDuplicates(["customer_id"])
)
(
dim_customer_df.write
.format("delta")
.mode("overwrite")
.saveAsTable("dim_customer")
)
display(dim_customer_df)
(abrir la captura a tamaño completo)fact_sales se construye a partir de la pequeña tabla demo_sales creada en el tutorial de notebooks. Cambia el nombre de amount a sales_amount y añade una franja de tamaño de pedido:
from pyspark.sql import functions as F
sales_df = spark.table("demo_sales")
fact_sales_df = (
sales_df
.select(
"order_id",
"customer_id",
"amount",
"country"
)
.withColumnRenamed(
"amount",
"sales_amount"
)
.withColumn(
"order_size",
F.when(F.col("sales_amount") >= 150, "Large")
.when(F.col("sales_amount") >= 100, "Medium")
.otherwise("Small")
)
)
display(fact_sales_df)
(abrir la captura a tamaño completo)La tabla de resumen agrega fact_sales por país:
gold_sales_by_country_df = (
fact_sales_df
.groupBy("country")
.agg(
F.countDistinct("order_id").alias("order_count"),
F.round(F.sum("sales_amount"), 2).alias("total_sales"),
F.round(F.avg("sales_amount"), 2).alias("avg_order_amount")
)
.orderBy(F.desc("total_sales"))
)
display(gold_sales_by_country_df)
(abrir la captura a tamaño completo)Escríbela con saveAsTable("gold_sales_by_country"), igual que en las capas anteriores, y después lista las tablas para confirmar que todo existe:
(abrir la captura a tamaño completo)Ten en cuenta dos límites asumidos de este modelo Gold:
- Es un punto de partida, no un esquema en estrella de producción completo. No hay dimensión de producto ni de fecha.
fact_salesprocede de los tres pedidos de ejemplo dedemo_sales, cuyos valores decustomer_id(1,2) no coinciden con las clavesCUST…dedim_customer. Por eso las dos tablas todavía no se pueden combinar. Construirfact_salesa partir desales_orders.csvysales_order_lines.csv, con claves coherentes, es el siguiente paso natural, y un esquema en estrella completo es el punto de partida del Lab 05.
Paso 8 — Orquestar con un pipeline de Fabric
Ejecutar tres notebooks a mano funciona una vez. Un pipeline los ejecuta en el orden correcto cada vez y se detiene si falla una capa. Crea un pipeline llamado pl_sales_analytics en ws_demo.
(abrir la captura a tamaño completo)Añade tres actividades Notebook y, en la pestaña Settings de cada una, selecciona su notebook:
| Actividad | Notebook |
|---|---|
| Bronze Ingestion | nb_02_bronze_ingestion |
| Silver Transformations | nb_03_silver_transformations |
| Gold Model | nb_04_gold_model |
(abrir la captura a tamaño completo)Ahora conéctalas con dependencias On success: arrastra desde la marca verde de Bronze Ingestion hasta Silver Transformations, y después desde Silver Transformations hasta Gold Model. Silver solo empieza si Bronze terminó bien, y Gold solo si Silver terminó bien, así que un fallo nunca deja una capa Gold actualizada a medias.
(abrir la captura a tamaño completo)Selecciona una actividad y abre su pestaña Settings para comprobar qué notebook ejecuta. La misma pestaña tiene una sección Base parameters, que pasa valores del pipeline al notebook. Como adelanto, la actividad Bronze Ingestion de abajo tiene tres: load_date (String, 2026-10-11), environment (String, dev) y full_reload (True, todavía sin tipo seleccionado).
(abrir la captura a tamaño completo)El código Bronze del paso 4 no lee estos valores, así que de momento no cambian nada: el notebook sigue cargando customers.csv completo. Hacer que los notebooks los usen, con tipos correctos y una celda de parámetros, es el tema del Lab 02.
Guarda el pipeline y selecciona Run. La pestaña Output muestra cada actividad mientras se ejecuta. En esta construcción, las tres terminaron correctamente: Bronze Ingestion en 49 segundos, Silver Transformations en 52 segundos y Gold Model en 1 minuto y 21 segundos.
(abrir la captura a tamaño completo)La pestaña Parameters del propio pipeline sigue vacía. Es intencionado: las rutas fijas y las recargas completas mantienen este lab sencillo. Los parámetros del pipeline, los parámetros del notebook y las cargas incrementales controladas por load_date, environment y full_reload son el tema del Lab 02; si quieres adelantarte, consulta los parámetros de notebook en Fabric.
Resultado
Ya tienes una pequeña solución de análisis que funciona de extremo a extremo en Microsoft Fabric:
- un área de trabajo de Fabric,
ws_demo - un Lakehouse,
demo - archivos sin procesar en OneLake, en
Files/raw - una capa Bronze,
bronze_customers, con metadatos de ingesta - una transformación Silver,
silver_customers, limpia y sin duplicados - tablas Gold para informes:
dim_customer,fact_salesygold_sales_by_country - orquestación con un pipeline de Fabric mediante
pl_sales_analytics
- CSV sin procesar
- Files/rawZona de aterrizaje
- Bronze
- Silver
- Gold
- Orquestación con pipeline
Para entender el razonamiento detrás de las capas, lee la arquitectura medallion explicada. Cuando la solución tenga que registrar lo que hace cada ejecución, diseñar un registro de ejecución para pipelines de datos es la base del Lab 04.
Sigue aprendiendo
Los próximos labs se apoyan en esta solución. Aparecen aquí para que veas hacia dónde va el proyecto; ninguno está publicado todavía.
Pipelines parametrizados y procesamiento incremental
Pasar valores del pipeline a los notebooks y cargar solo lo que cambió en lugar de reprocesarlo todo.
Aún no publicado
Calidad de datos, cuarentena y gestión de errores
Validar las filas antes de que lleguen a Silver, poner en cuarentena las que fallan y hacer que los fallos sean recuperables.
Aún no publicado
Supervisión y registro de ejecución
Registrar cada ejecución en un log Delta para saber qué se ejecutó, qué falló y cuántas filas se procesaron.
Aún no publicado
Modelos semánticos y Power BI
Convertir la capa Gold en un modelo semántico con relaciones y medidas DAX, y crear un informe de Power BI.
Aún no publicado
Git, CI/CD y despliegue
Poner el área de trabajo bajo Git y promover la solución de desarrollo a pruebas y a producción.
Aún no publicado