Todos los labs de Fabric

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. 1Área de trabajows_demo
  2. 2Lakehousedemo
  3. 3Archivos CSV sin procesarFiles/raw
  4. 4Tablas Delta Bronzenb_02_bronze_ingestion
  5. 5Datos Silver limpiosnb_03_silver_transformations
  6. 6Calidad de datos y solución de problemasInspeccionar, corregir, volver a ejecutar, verificar
  7. 7Capa Gold para informesnb_04_gold_model
  8. 8Orquestación con un pipeline de Fabricpl_sales_analytics
El flujo que se construye en este lab, desde los archivos sin procesar hasta una capa Gold orquestada.

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.

Panel Áreas de trabajo de Microsoft Fabric con el área ws_demo y el botón New workspace abajo (abrir la captura a tamaño completo)
Las áreas de trabajo se crean desde el panel Áreas de trabajo; ws_demo es la única que usa este lab.

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.

Página de inicio del área ws_demo con New item, Manage access y Workspace settings, y en la lista un Lakehouse demo, su punto de conexión de SQL analytics y un notebook (abrir la captura a tamaño completo)
La página de inicio del área reúne todos los elementos del lab; New item, Manage access y Workspace settings están arriba.

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.

Opciones de tipo de área de trabajo en Microsoft Fabric, con Fabric Trial seleccionado entre los tipos de Power BI y de Fabric (abrir la captura a tamaño completo)
Elige un tipo de área de Fabric (prueba o capacidad); los tipos solo de Power BI no pueden alojar un Lakehouse ni notebooks.

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.

Panel Add people de ws_demo con los roles Admin, Member, Contributor y Viewer (abrir la captura a tamaño completo)
Los roles van de Admin a Viewer; solo Admin, Member y Contributor pueden editar elementos.

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.

Workspace settings abierto en Git integration, con Azure DevOps y GitHub como proveedores de Git (abrir la captura a tamaño completo)
La integración con Git está en Workspace settings; sigue desconectada en este lab y vuelve en el lab de Git y despliegue.

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.
Panel New item de Microsoft Fabric filtrado por lake, con los elementos Lakehouse, Sample lakehouse y Warehouse (abrir la captura a tamaño completo)
Crea un Lakehouse normal; el Lakehouse de ejemplo trae datos que aquí no necesitas.
Explorador del Lakehouse demo con Tables y Files, mostrando una vista previa de la tabla demo_customers (abrir la captura a tamaño completo)
Tables guarda tablas Delta y Files guarda archivos sin procesar; este lab usa ambas zonas.

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.

Punto de conexión de SQL analytics del Lakehouse demo con el esquema dbo, sus tablas y una vista previa de los datos de demo_customers (abrir la captura a tamaño completo)
El punto de conexión de SQL analytics lee las mismas tablas Delta con T-SQL, sin sesión de Spark.

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.

Notebook de Fabric con el Lakehouse demo adjunto en el explorador, ejecutando PySpark que escribe una tabla Delta demo_customers (abrir la captura a tamaño completo)
Con el Lakehouse adjunto, los nombres de tabla en PySpark se refieren directamente a él.

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.csv
  • products.csv
  • purchase_orders.csv
  • sales_orders.csv
  • sales_order_lines.csv

Crea una carpeta raw en Files, abre su menú … y elige Upload › Upload files.

Menú contextual de la carpeta raw en el explorador del Lakehouse, con Upload desplegado en Upload files y Upload folder (abrir la captura a tamaño completo)
Subir desde el menú de la carpeta deja los archivos justo donde los esperan los notebooks.

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ó.

Carpeta Files/raw en el explorador del Lakehouse con customers.csv, products.csv, purchase_orders.csv, sales_order_lines.csv y sales_orders.csv (abrir la captura a tamaño completo)
Los cinco archivos de origen están juntos en la zona de aterrizaje.

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.

Vista previa del archivo customers.csv en el Lakehouse con las columnas customer_id, first_name, last_name, email, segment, city, state, country, created_at e is_active (abrir la captura a tamaño completo)
La vista previa del archivo sin procesar muestra los nombres reales de las columnas antes de que el código dependa de ellos.

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.

Cuadro de diálogo New Notebook en el área ws_demo con el nombre nb_02_bronze_ingestion (abrir la captura a tamaño completo)
Un notebook por capa mantiene cada paso corto y permite que el pipeline los ejecute por separado.

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ó:

PySpark
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())
)
PySpark10 líneasCelda de ejemplo de solo lectura. Nada en esta página ejecuta código.
Celda de notebook de Fabric que lee Files/raw/customers.csv con PySpark y añade las columnas _source_file e _ingested_at (abrir la captura a tamaño completo)
Los metadatos de ingesta se añaden al leer, así que cada fila Bronze puede rastrearse hasta su archivo.

Después escribe el DataFrame como tabla Delta:

PySpark
(
    customers_df.write
    .format("delta")
    .mode("overwrite")
    .saveAsTable("bronze_customers")
)
PySpark6 líneasCelda de ejemplo de solo lectura. Nada en esta página ejecuta código.
Celda de notebook de Fabric que escribe customers_df en la tabla Delta bronze_customers en modo overwrite, completada correctamente (abrir la captura a tamaño completo)
El modo overwrite permite volver a ejecutar el notebook sin riesgo: cada ejecución reemplaza la tabla en lugar de añadir duplicados.

Actualiza Tables: aparece bronze_customers con las columnas originales más _source_file e _ingested_at.

Explorador del Lakehouse con la tabla bronze_customers y sus columnas, entre ellas _source_file e _ingested_at (abrir la captura a tamaño completo)
El explorador es la forma más rápida de comprobar que la tabla existe con el esquema esperado.

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_name construida a partir de first_name y last_name.
Cuadro de diálogo New Notebook en ws_demo con el nombre nb_03_silver_transformations (abrir la captura a tamaño completo)
El notebook Silver solo lee de Bronze, nunca de los archivos sin procesar.
PySpark
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)
PySpark31 líneasCelda de ejemplo de solo lectura. Nada en esta página ejecuta código.
Notebook de Fabric que ejecuta el código de limpieza Silver sobre bronze_customers, con el esquema de bronze_customers en el explorador y las filas limpias debajo (abrir la captura a tamaño completo)
Bronze tiene first_name y last_name; Silver deriva customer_name de ellas en lugar de esperarla en el origen.

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:

PySpark
(
    silver_customers_df.write
    .format("delta")
    .mode("overwrite")
    .saveAsTable("silver_customers")
)
PySpark6 líneasCelda de ejemplo de solo lectura. Nada en esta página ejecuta código.
Tables del Lakehouse con bronze_customers y silver_customers después de que la celda de escritura Silver terminara correctamente (abrir la captura a tamaño completo)
silver_customers ya está junto a bronze_customers; Bronze queda intacta para volver a procesar.

Paso 6 — Calidad de datos y solución de problemas

El primer intento de Silver recortaba una columna que nunca existió en el origen:

PySpark
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")))
    )
)
PySpark12 líneasCelda de ejemplo de solo lectura. Nada en esta página ejecuta código.
Primera versión de la celda Silver que hace referencia a una columna customer_name, mientras la celda todavía se está ejecutando (abrir la captura a tamaño completo)
El primer intento parecía razonable, pero hacía referencia a customer_name, una columna que Bronze nunca tuvo.

Spark lo rechazó antes de procesar una sola fila:

Notebook de Fabric con un error AnalysisException UNRESOLVED_COLUMN.WITH_SUGGESTION: customer_name no se puede resolver, con customer_id, last_name y first_name como sugerencias (abrir la captura a tamaño completo)
Lee primero las últimas líneas del error: el nombre de la columna y las sugerencias de Spark llevan directamente a la causa.

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:

  1. Inspeccionar el esquema. Ejecuta spark.table("bronze_customers").printSchema() o despliega la tabla en el explorador.
  2. Identificar la columna que falta. Bronze tiene first_name y last_name, no customer_name. El archivo sin procesar tampoco la tenía (paso 3).
  3. Corregir la transformación. Construye customer_name con concat_ws a partir de las dos columnas que sí existen, en lugar de leerla.
  4. Volver a ejecutar la celda.
  5. Verificar la tabla Silver. Revisa las filas mostradas y confirma que silver_customers aparece 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
Notebook nb_04_gold_model vacío con el Lakehouse demo adjunto, que muestra bronze_customers, demo_customers, demo_sales y silver_customers (abrir la captura a tamaño completo)
Gold parte de las tablas que ya están en el Lakehouse; en esta fase no se lee ningún archivo sin procesar.

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:

PySpark
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)
PySpark26 líneasCelda de ejemplo de solo lectura. Nada en esta página ejecuta código.
Notebook de Fabric que lee silver_customers, selecciona nueve columnas de cliente en dim_customer y la escribe como tabla Delta, con dim_customer y sus columnas en el explorador y 50 filas de clientes mostradas (abrir la captura a tamaño completo)
La dimensión solo lee de Silver: nueve columnas, 50 clientes, sin _source_file ni _ingested_at.

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:

PySpark
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)
PySpark25 líneasCelda de ejemplo de solo lectura. Nada en esta página ejecuta código.
Notebook de Fabric que construye fact_sales a partir de demo_sales, con dim_customer ya en el Lakehouse y tres filas de resultado clasificadas como Small, Medium y Large (abrir la captura a tamaño completo)
fact_sales cambia amount por sales_amount y clasifica cada pedido; dim_customer ya aparece en Tables.

La tabla de resumen agrega fact_sales por país:

PySpark
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)
PySpark12 líneasCelda de ejemplo de solo lectura. Nada en esta página ejecuta código.
Notebook de Fabric que agrega fact_sales por país: USA con 2 pedidos y 335.50 en ventas totales, Canada con 1 pedido y 89.99 (abrir la captura a tamaño completo)
Una tabla pequeña y preagregada responde a la pregunta más habitual sin ningún cálculo en el informe.

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:

Tables del Lakehouse con dim_customer, fact_sales y gold_sales_by_country, y la salida de SHOW TABLES que confirma las tablas en el espacio de nombres demo (abrir la captura a tamaño completo)
SHOW TABLES y el explorador coinciden: las tablas Bronze, Silver y Gold viven en el mismo Lakehouse.

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_sales procede de los tres pedidos de ejemplo de demo_sales, cuyos valores de customer_id (1, 2) no coinciden con las claves CUST… de dim_customer. Por eso las dos tablas todavía no se pueden combinar. Construir fact_sales a partir de sales_orders.csv y sales_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.

Cuadro de diálogo New Pipeline en ws_demo con el nombre pl_sales_analytics, sobre los tres notebooks de la lista del área (abrir la captura a tamaño completo)
El pipeline vive en la misma área de trabajo que los notebooks que ejecuta.

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
Lienzo del pipeline con tres actividades Notebook sin conectar llamadas Bronze Ingestion, Silver Transformations y Gold Model (abrir la captura a tamaño completo)
Tres actividades Notebook, una por capa, todavía sin conectar.

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.

Lienzo del pipeline con Bronze Ingestion conectada a Silver Transformations y Silver Transformations conectada a Gold Model mediante flechas On success (abrir la captura a tamaño completo)
Las flechas On success reflejan el orden medallion: cada capa solo se ejecuta después de que la anterior termine bien.

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).

Pestaña Settings de la actividad Notebook Bronze Ingestion, que apunta a nb_02_bronze_ingestion, con los parámetros base load_date en 2026-10-11, environment en dev y full_reload en True (abrir la captura a tamaño completo)
Los parámetros base son el punto donde los valores del pipeline llegan a un notebook; este lab solo muestra dónde están.

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.

Pestaña Output del pipeline con el estado Succeeded y las actividades Bronze Ingestion, Silver Transformations y Gold Model marcadas como Succeeded (abrir la captura a tamaño completo)
Una ejecución en verde de las tres actividades: toda la solución se actualiza ahora con un clic o con una programación.

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_sales y gold_sales_by_country
  • orquestación con un pipeline de Fabric mediante pl_sales_analytics
  1. CSV sin procesar
  2. Files/rawZona de aterrizaje
  3. Bronze
  4. Silver
  5. Gold
  6. Orquestación con pipeline
La arquitectura final del Lab 01.

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.

  1. Lab 02Próximamente

    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

  2. Lab 03Próximamente

    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

  3. Lab 04Próximamente

    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

  4. Lab 05Próximamente

    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

  5. Lab 06Próximamente

    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