<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Andreretorta on Medium]]></title>
        <description><![CDATA[Stories by Andreretorta on Medium]]></description>
        <link>https://medium.com/@andreretorta046?source=rss-e3e3b218dbe4------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*HovO7UwL2MgrBbPiVcoKug.jpeg</url>
            <title>Stories by Andreretorta on Medium</title>
            <link>https://medium.com/@andreretorta046?source=rss-e3e3b218dbe4------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 02:48:42 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@andreretorta046/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Construyendo un pipeline de datos de extremo a extremo en Microsoft Fabric]]></title>
            <link>https://medium.com/@andreretorta046/construyendo-un-pipeline-de-datos-de-extremo-a-extremo-en-microsoft-fabric-8fe2d2d3cc92?source=rss-e3e3b218dbe4------2</link>
            <guid isPermaLink="false">https://medium.com/p/8fe2d2d3cc92</guid>
            <category><![CDATA[pipeline]]></category>
            <category><![CDATA[microsoft-fabric]]></category>
            <category><![CDATA[data-fabric]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[medallion-architecture]]></category>
            <dc:creator><![CDATA[Andreretorta]]></dc:creator>
            <pubDate>Thu, 25 Jun 2026 09:50:42 GMT</pubDate>
            <atom:updated>2026-06-25T09:50:42.870Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x1CbvqpswF3c0M5Sdjph4w.png" /></figure><p>En este artículo muestro cómo construí, de extremo a extremo, una solución de ingeniería de datos en Microsoft Fabric que ingiere noticias de una API pública, organiza los datos con una arquitectura Medallón (Bronze → Silver → Gold), aplica análisis de sentimientos, publica un informe en Power BI y dispara alertas en tiempo real con Data Activator.</p><p>La idea central del proyecto: ¿cuál es el “estado de ánimo” de las noticias<br>publicadas? Recopilando titulares de la [NewsAPI](<a href="https://newsapi.org/">https://newsapi.org</a>), procesé el contenido y clasifiqué cada noticia como positiva, neutral o negativa, transformando texto en bruto en una métrica que se puede monitorear.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eeHkMVRpy6gv8UAIi9vkSQ.png" /><figcaption>Visión general de la arquitectura</figcaption></figure><p>Todo se construyó dentro de un único workspace de Fabric, `bing_api_project`, que concentra el Lakehouse, los notebooks, el modelo semántico, el informe y el pipeline de orquestación.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LLEFTylFgkitkVQy2ALwyQ.png" /></figure><p>— -</p><h3>1. Capa Bronze — Ingesta desde la NewsAPI:</h3><p>La ingesta comienza con una actividad Copy data (“Ingestion — Bronze”) dentro de un Data Pipeline. Es la responsable de llamar a la API y escribir la respuesta en bruto en el Lakehouse, sin ninguna transformación.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nOl-c-q4ClrgUvWaAK26jA.png" /></figure><p>El origen es una conexión REST que apunta al endpoint `<a href="https://newsapi.org/v2/everything%60">https://newsapi.org/v2/everything`</a>. La URL relativa se construye de forma<br>dinámica, lo que permite reutilizar el mismo pipeline para cualquier término de búsqueda.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gckoky06j8P4wTvYr1qh5w.png" /></figure><p>La conexión usa autenticación anónima, ya que la clave de la API se pasa como parámetro en la propia URL, manteniendo el conector simple y reutilizable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-4_ib4haMEUiHmj0lU3Lzw.png" /></figure><p>El gran truco está en el constructor de expresiones del pipeline. Usando la<br>función `<a href="http://twitter.com/concat">@concat</a>`, combino los parámetros `search_term` y `API_KEY` para construir la consulta en tiempo de ejecución:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*2LuIdivRAzZj84qkuHvVxQ.png" /></figure><p>El destino es el Lakehouse `bing_lake_db`, en la carpeta de Archivos,<br>guardando el resultado como `news-happiness-news.json` en formato JSON. Este es el corazón de la capa Bronze: datos crudos, fieles a la fuente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*unewVNiYnLMn9pG1aYsGrw.png" /></figure><p>— -</p><h3>2. Capa Silver — Limpieza de los datos:</h3><p>Con el JSON en bruto en el Lakehouse, un Notebook (“Silver — Data Cleaning”) entra en acción para estandarizar y limpiar los datos: aplanar la estructura JSON, tratar valores nulos, normalizar fechas y seleccionar solo los campos relevantes (`author`, `title`, `description`, `content`, `source`, `publishedAt`,`url`).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/756/1*u6HIBpylkbNgmFB_YSMMMg.png" /></figure><p>En la configuración de la actividad, el notebook se vincula al workspace<br>`bing_api_project`, ejecutando el “Silver Notebook” orquestado por el pipeline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_-O6OBSt6DIoBPag3Zmg_Q.png" /></figure><p>— -</p><h3>3. Capa Gold — Análisis de Sentimientos:</h3><p>La capa Gold es donde aparece el valor de negocio. El notebook<br>“Sentimental Analysis — Gold” recibe los datos limpios de la Silver y aplica<br>procesamiento de lenguaje natural (NLP) para clasificar cada noticia.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w-IYgtOn1xYtZiWxULYtog.png" /></figure><p>El resultado de la capa Bronze/Silver se puede inspeccionar mediante el SQL analytics endpoint del Lakehouse. La tabla `t_raw_news` muestra las noticias ya estructuradas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n8UEKJqw_lKs75XKsFMcHg.png" /></figure><p>La tabla `t_raw_sentiment_nalysis` trae el resultado del NLP, con la clasificación (`sentiment`) y las puntuaciones de probabilidad `sentiment_pos`, `sentiment_neutral` y `sentiment_neg` para cada artículo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t_kU0-KNmkXnX2f6JDc29w.png" /></figure><p>— -</p><h3>4. Visualización — Informe en Power BI:</h3><p>Sobre la capa Gold, construí el informe “News PBI” en Power BI. Resume los porcentajes de sentimiento en tarjetas (Negative / Neutral / Positive<br>Sentiment %), lista las noticias con título, fuente y descripción, y ofrece un<br>filtro por fecha de publicación (`publishedAt`).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4Hce4kEzJcQjB1I6h7RsZQ.png" /></figure><p>— -</p><h3>5. Tiempo real — Alertas con Data Activator:</h3><p>Para cerrar el ciclo, configuré Data Activator sobre las métricas del informe.<br>Cada vez que el Neutral Sentiment % disminuye más allá de un umbral definido, se dispara una alerta, con una notificación enviada directamente a Microsoft Teams.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ODE9bSGdu-EE_Hchm9h14Q.png" /></figure><p>En el hub de tiempo real, el objeto `newspbi` registra cada evento de métrica de Power BI, lo que permite seguir la evolución del sentimiento a lo largo del tiempo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lCqKO9IEWrOXGkgyn7P5eQ.png" /></figure><p>— -</p><h3>Orquestación de extremo a extremo:</h3><p>Todas las etapas se enlazan en un único Data Pipeline, que ejecuta las tres<br>capas en secuencia, garantizando dependencias y orden correctos:</p><p>Ingestion — Bronze → Silver — Data Cleaning → Sentimental Analysis — Gold</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UeM5uQxSy4XxeaDguO58Mg.png" /></figure><p>— -</p><h3>Conclusión:</h3><p>Con Microsoft Fabric fue posible entregar, en una única plataforma SaaS, todas las piezas de una solución de datos moderna:</p><p>- Ingesta desde una API REST mediante un Data Pipeline;<br>- Arquitectura Medallón (Bronze, Silver, Gold) en el Lakehouse;<br>- Análisis de sentimientos con NLP en notebooks PySpark;<br>- Visualización en Power BI;<br>- Alertas en tiempo real con Data Activator e integración con Teams.</p><p>La gran ventaja es la integración nativa: no tuve que unir servicios separados: todo (almacenamiento, procesamiento, BI y alertas) vive en el mismo ecosistema, con gobernanza y seguridad centralizadas.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8fe2d2d3cc92" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Construire un pipeline de données de bout en bout sur Microsoft Fabric]]></title>
            <link>https://medium.com/@andreretorta046/construire-un-pipeline-de-donn%C3%A9es-de-bout-en-bout-sur-microsoft-fabric-22e4450240df?source=rss-e3e3b218dbe4------2</link>
            <guid isPermaLink="false">https://medium.com/p/22e4450240df</guid>
            <category><![CDATA[medallion-architecture]]></category>
            <category><![CDATA[data-fabric]]></category>
            <category><![CDATA[pipeline]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[microsoft-fabric]]></category>
            <dc:creator><![CDATA[Andreretorta]]></dc:creator>
            <pubDate>Tue, 23 Jun 2026 20:15:52 GMT</pubDate>
            <atom:updated>2026-06-23T20:15:52.332Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x1CbvqpswF3c0M5Sdjph4w.png" /></figure><p>Dans cet article, je montre comment j’ai construit, de bout en bout, une solution d’ingénierie de données sur Microsoft Fabric qui ingère des actualités depuis une API publique, organise les données selon une architecture Médaillon (Bronze → Silver → Gold), applique une analyse de sentiments, publie un rapport Power BI et déclenche des alertes en temps réel avec Data Activator.</p><p>L’idée centrale du projet : quelle est « l’humeur » des actualités publiées ?<br>En collectant les titres de la [NewsAPI](<a href="https://newsapi.org/">https://newsapi.org</a>), j’ai traité le<br>contenu et classé chaque actualité comme positive, neutre ou négative,<br>transformant du texte brut en une métrique suivable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eeHkMVRpy6gv8UAIi9vkSQ.png" /><figcaption>Vue d’ensemble de l’architecture</figcaption></figure><p>Tout a été construit dans un seul workspace Fabric, `bing_api_project`, qui<br>regroupe le Lakehouse, les notebooks, le modèle sémantique, le rapport et le pipeline d’orchestration.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LLEFTylFgkitkVQy2ALwyQ.png" /></figure><p>— -</p><h3>1. Couche Bronze — Ingestion depuis la NewsAPI:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nOl-c-q4ClrgUvWaAK26jA.png" /></figure><p>L’ingestion commence par une activité Copy data (« Ingestion — Bronze ») au sein d’un Data Pipeline. Elle est chargée d’appeler l’API et d’écrire la réponse brute dans le Lakehouse, sans aucune transformation.</p><p>La source est une connexion REST pointant vers le point de terminaison<br>`<a href="https://newsapi.org/v2/everything%60">https://newsapi.org/v2/everything`</a>. L’URL relative est construite dynamiquement, ce qui permet de réutiliser le même pipeline pour n’importe quel terme de recherche.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gckoky06j8P4wTvYr1qh5w.png" /></figure><p>La connexion utilise une authentification anonyme, car la clé de l’API est<br>passée en paramètre dans l’URL elle-même, ce qui garde le connecteur simple et réutilisable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-4_ib4haMEUiHmj0lU3Lzw.png" /></figure><p>L’astuce clé réside dans le constructeur d’expressions du pipeline. À l’aide<br>de la fonction `<a href="http://twitter.com/concat">@concat</a>`, je combine les paramètres `search_term` et `API_KEY`pour construire la requête à l’exécution :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*2LuIdivRAzZj84qkuHvVxQ.png" /></figure><p>La destination est le Lakehouse `bing_lake_db`, dans le dossier Fichiers,<br>enregistrant le résultat sous `news-happiness-news.json` au format JSON.<br>C’est le cœur de la couche Bronze : des données brutes, fidèles à la source.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*unewVNiYnLMn9pG1aYsGrw.png" /></figure><p>— -</p><h3>2. Couche Silver — Nettoyage des données:</h3><p>Avec le JSON brut dans le Lakehouse, un Notebook (« Silver — Data Cleaning ») entre en action pour standardiser et nettoyer les données : aplatir la structure JSON, traiter les valeurs nulles, normaliser les dates et sélectionner uniquement les champs pertinents (`author`, `title`, `description`, `content`, `source`,<br>`publishedAt`, `url`).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/756/1*u6HIBpylkbNgmFB_YSMMMg.png" /></figure><p>Dans les paramètres de l’activité, le notebook est lié au workspace<br>`bing_api_project`, exécutant le « Silver Notebook » orchestré par le pipeline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_-O6OBSt6DIoBPag3Zmg_Q.png" /></figure><p>— -</p><h3>3. Couche Gold — Analyse de Sentiments:</h3><p>La couche Gold est l’endroit où la valeur métier apparaît. Le notebook<br>« Sentimental Analysis Gold » reçoit les données nettoyées de la Silver et<br>applique un traitement du langage naturel (NLP) pour classer chaque actualité.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w-IYgtOn1xYtZiWxULYtog.png" /></figure><p>Le résultat de la couche Bronze/Silver peut être inspecté via le SQL analytics endpoint du Lakehouse. La table `t_raw_news` montre les actualités déjà structurées :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n8UEKJqw_lKs75XKsFMcHg.png" /></figure><p>La table `t_raw_sentiment_nalysis` apporte le résultat du NLP, avec la<br>classification (`sentiment`) et les scores de probabilité `sentiment_pos`,<br>`sentiment_neutral` et `sentiment_neg` pour chaque article.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t_kU0-KNmkXnX2f6JDc29w.png" /></figure><p>— -</p><h3>4. Visualisation — Rapport Power BI:</h3><p>Au-dessus de la couche Gold, j’ai construit le rapport « News PBI » dans<br>Power BI. Il résume les pourcentages de sentiment dans des cartes (Negative /Neutral / Positive Sentiment %), liste les actualités avec titre, source et description, et propose un filtre par date de publication (`publishedAt`).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4Hce4kEzJcQjB1I6h7RsZQ.png" /></figure><p>— -</p><h3>5. Temps réel — Alertes avec Data Activator:</h3><p>Pour boucler la boucle, j’ai configuré Data Activator sur les métriques du<br>rapport. Chaque fois que le Neutral Sentiment % descend au-delà d’un seuil<br>défini, une alerte se déclenche, avec une notification envoyée directement vers Microsoft Teams.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ODE9bSGdu-EE_Hchm9h14Q.png" /></figure><p>Dans le hub temps réel, l’objet `newspbi` enregistre chaque événement de métrique Power BI, permettant de suivre l’évolution du sentiment au fil du temps.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lCqKO9IEWrOXGkgyn7P5eQ.png" /></figure><p>— -</p><h3>Orchestration de bout en bout:</h3><p>Toutes les étapes sont reliées dans un seul Data Pipeline, qui exécute les<br>trois couches en séquence, garantissant les dépendances et l’ordre corrects :</p><p>Ingestion — Bronze → Silver — Data Cleaning → Sentimental Analysis — Gold</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UeM5uQxSy4XxeaDguO58Mg.png" /></figure><p>— -</p><h3>Conclusion:</h3><p>Avec Microsoft Fabric, j’ai pu livrer, sur une seule plateforme SaaS, toutes les pièces d’une solution de données moderne :</p><p>- Ingestion depuis une API REST via un Data Pipeline ;<br>- Architecture Médaillon (Bronze, Silver, Gold) dans le Lakehouse ;<br>- Analyse de sentiments avec NLP dans des notebooks PySpark ;<br>- Visualisation dans Power BI ;<br>- Alertes en temps réel avec Data Activator et intégration Teams.</p><p>Le principal avantage est l’intégration native : je n’ai pas eu à assembler des<br>services séparés — stockage, traitement, BI et alertes vivent tous dans le même écosystème, avec une gouvernance et une sécurité centralisées.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=22e4450240df" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building an end-to-end data pipeline on Microsoft Fabric]]></title>
            <link>https://medium.com/@andreretorta046/building-an-end-to-end-data-pipeline-on-microsoft-fabric-62269c1d9f9e?source=rss-e3e3b218dbe4------2</link>
            <guid isPermaLink="false">https://medium.com/p/62269c1d9f9e</guid>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[data-fabric]]></category>
            <category><![CDATA[microsoft-fabric]]></category>
            <category><![CDATA[pipeline]]></category>
            <category><![CDATA[medallion-architecture]]></category>
            <dc:creator><![CDATA[Andreretorta]]></dc:creator>
            <pubDate>Tue, 23 Jun 2026 20:15:27 GMT</pubDate>
            <atom:updated>2026-06-23T20:15:27.007Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x1CbvqpswF3c0M5Sdjph4w.png" /></figure><p>In this article, I walk through how I built an end-to-end data engineering<br>solution on Microsoft Fabric that ingests news from a public API, organizes<br>it using a Medallion architecture (Bronze → Silver → Gold), applies<br>sentiment analysis, publishes a Power BI report, and triggers<br>real-time alerts with Data Activator.</p><p>The core question of the project: what is the “mood” of published news?<br>By collecting headlines from the [NewsAPI](<a href="https://newsapi.org/">https://newsapi.org</a>), I processed the content and classified each article as positive, neutral, or negative, turning raw text into a trackable metric.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eeHkMVRpy6gv8UAIi9vkSQ.png" /><figcaption>Architecture overview</figcaption></figure><p>Everything was built inside a single Fabric workspace, `bing_api_project`, which holds the Lakehouse, notebooks, semantic model, report, and orchestration pipeline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LLEFTylFgkitkVQy2ALwyQ.png" /></figure><p>— -</p><h3>1. Bronze layer — Ingesting from the NewsAPI:</h3><p>Ingestion starts with a Copy data activity (“Ingestion — Bronze”) inside a<br>Data Pipeline. It calls the API and writes the raw response into the Lakehouse, with no transformation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nOl-c-q4ClrgUvWaAK26jA.png" /></figure><p>The source is a REST connection pointing to the `<a href="https://newsapi.org/v2/everything%60">https://newsapi.org/v2/everything`</a> endpoint. The relative URL is built<br>dynamically, so the same pipeline can be reused for any search term.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gckoky06j8P4wTvYr1qh5w.png" /></figure><p>The connection uses anonymous authentication, since the API key is passed as a parameter in the URL itself — keeping the connector simple and reusable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-4_ib4haMEUiHmj0lU3Lzw.png" /></figure><p>The key trick is the pipeline expression builder. Using the `<a href="http://twitter.com/concat">@concat</a>`<br>function, I combine the `search_term` and `API_KEY` parameters to build the query at runtime:</p><p>```text<br><a href="http://twitter.com/concat">@concat</a>(<br> ‘?q=’, pipeline().parameters.search_term,<br> ‘&amp;apiKey=’, pipeline().parameters.API_KEY<br>)<br>```</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*2LuIdivRAzZj84qkuHvVxQ.png" /></figure><p>![Expression builder with search_term and API_KEY parameters](assets/fig-05.png)</p><p>The destination is the `bing_lake_db` Lakehouse, in the Files folder,<br>writing the result as `news-happiness-news.json` in JSON format. This is the heart of the Bronze layer: raw data, faithful to the source.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*unewVNiYnLMn9pG1aYsGrw.png" /></figure><p>— -</p><h3>2. Silver layer — Cleaning the data:</h3><p>With the raw JSON in the Lakehouse, a Notebook (“Silver — Data Cleaning”)<br>standardizes and cleans the data: flattening the JSON structure, handling nulls, normalizing dates, and selecting only the relevant fields (`author`, `title`, `description`, `content`, `source`, `publishedAt`, `url`).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/756/1*u6HIBpylkbNgmFB_YSMMMg.png" /></figure><p>In the activity settings, the notebook is bound to the `bing_api_project`<br>workspace, running the “Silver Notebook” orchestrated by the pipeline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_-O6OBSt6DIoBPag3Zmg_Q.png" /></figure><p>— -</p><h3>3. Gold layer — Sentiment Analysis:</h3><p>The Gold layer is where the business value appears. The<br>“Sentimental Analysis — Gold” notebook takes the cleaned Silver data and applies natural language processing (NLP) to classify each article.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w-IYgtOn1xYtZiWxULYtog.png" /></figure><p>The output of the Bronze/Silver layers can be inspected through the Lakehouse SQL analytics endpoint. The `t_raw_news` table shows the structured news:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n8UEKJqw_lKs75XKsFMcHg.png" /></figure><p>The `t_raw_sentiment_nalysis` table holds the NLP output, with the classification (`sentiment`) and the probability scores `sentiment_pos`, `sentiment_neutral`, and `sentiment_neg` for each article.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t_kU0-KNmkXnX2f6JDc29w.png" /></figure><p>— -</p><h3>4. Visualization — Power BI report:</h3><p>On top of the Gold layer, I built the “News PBI” report in Power BI. It<br>summarizes the sentiment percentages in cards (Negative / Neutral / Positive Sentiment %), lists the news with title, source, and description, and offers a slicer by publication date (`publishedAt`).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4Hce4kEzJcQjB1I6h7RsZQ.png" /></figure><p>— -</p><h3>5. Real time — Alerts with Data Activator:</h3><p>To close the loop, I configured Data Activator on top of the report metrics.<br>Whenever the Neutral Sentiment % drops beyond a defined threshold, an alert fires with a notification sent straight to Microsoft Teams.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ODE9bSGdu-EE_Hchm9h14Q.png" /></figure><p>In the real-time hub, the `newspbi` object logs every Power BI metric event, making it possible to track sentiment evolution over time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lCqKO9IEWrOXGkgyn7P5eQ.png" /></figure><p>— -</p><h3>End-to-end orchestration:</h3><p>All steps are tied together in a single Data Pipeline that runs the three<br>layers in sequence, ensuring correct dependencies and order:</p><p>Ingestion — Bronze → Silver — Data Cleaning → Sentimental Analysis — Gold</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UeM5uQxSy4XxeaDguO58Mg.png" /></figure><p>— -</p><h3>Conclusion:</h3><p>With Microsoft Fabric I was able to deliver, on a single SaaS platform, all the pieces of a modern data solution:</p><p>- Ingestion from a REST API via Data Pipeline;<br>- Medallion architecture (Bronze, Silver, Gold) in the Lakehouse;<br>- Sentiment analysis with NLP in PySpark notebooks;<br>- Visualization in Power BI;<br>- Real-time alerts with Data Activator and Teams integration.</p><p>The biggest advantage is native integration: I didn’t have to stitch together<br>separate services storage, processing, BI, and alerting all live in the same<br>ecosystem, with centralized governance and security.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=62269c1d9f9e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Construindo um pipeline de dados ponta a ponta no Microsoft Fabric]]></title>
            <link>https://medium.com/@andreretorta046/construindo-um-pipeline-de-dados-ponta-a-ponta-no-microsoft-fabric-20ea338b590b?source=rss-e3e3b218dbe4------2</link>
            <guid isPermaLink="false">https://medium.com/p/20ea338b590b</guid>
            <category><![CDATA[medallion-architecture]]></category>
            <category><![CDATA[microsoft-fabric]]></category>
            <category><![CDATA[data-fabric]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[pipeline]]></category>
            <dc:creator><![CDATA[Andreretorta]]></dc:creator>
            <pubDate>Mon, 22 Jun 2026 09:48:56 GMT</pubDate>
            <atom:updated>2026-06-22T09:48:56.565Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x1CbvqpswF3c0M5Sdjph4w.png" /></figure><p>Neste artigo eu mostro como construí, de ponta a ponta, uma solução de engenharia de dados no Microsoft Fabric que ingere notícias de uma API pública, organiza os dados em uma arquitetura Medalhão (Bronze → Silver → Gold), aplica análise de sentimentos, publica um relatório no Power BI e dispara alertas em tempo real com o Data Activator.</p><p>A ideia central do projeto: qual é o “humor” das notícias publicadas?</p><p>Coletando manchetes da [NewsAPI](https://newsapi.org), processei o conteúdo e classifiquei cada notícia como positiva, neutra ou negativa, transformando o texto bruto em uma métrica mensurável.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eeHkMVRpy6gv8UAIi9vkSQ.png" /><figcaption>Visão geral da arquitetura</figcaption></figure><p>Tudo foi construído dentro de um único workspace do Fabric, o `bing_api_project`, que concentra o Lakehouse, os notebooks, o modelo semântico, o relatório e o pipeline de orquestração.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LLEFTylFgkitkVQy2ALwyQ.png" /></figure><p>— -</p><h3>1. Camada Bronze — Ingestão a partir da NewsAPI:</h3><p>A ingestão começa com uma atividade Copy data (“Ingestion — Bronze”) dentro de um Data Pipeline. Ela é responsável por chamar a API e gravar a resposta bruta no Lakehouse, sem nenhuma transformação.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nOl-c-q4ClrgUvWaAK26jA.png" /></figure><p>A origem é uma conexão REST apontando para o endpoint `https://newsapi.org/v2/everything`. A URL relativa é montada dinamicamente, o que permite reutilizar o mesmo pipeline para qualquer termo de busca.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gckoky06j8P4wTvYr1qh5w.png" /></figure><p>![Atividade Copy data — aba Origem com conexão REST](assets/fig-03.png)</p><p>A conexão usa autenticação anônima, já que a chave da API é passada como parâmetro na própria URL — mantendo o conector simples e reutilizável.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-4_ib4haMEUiHmj0lU3Lzw.png" /></figure><p>O grande truque está no construtor de expressão do pipeline. Usando a função `@concat`, eu combino os parâmetros `search_term` e `API_KEY` para montar a query em tempo de execução:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*2LuIdivRAzZj84qkuHvVxQ.png" /></figure><p>O destino é o Lakehouse `bing_lake_db`, na pasta de Arquivos, gravando o resultado como `news-happiness-news.json` no formato JSON. Esse é o coração da camada Bronze: dados crus, fiéis à fonte.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*unewVNiYnLMn9pG1aYsGrw.png" /></figure><p>— -</p><h3>2. Camada Silver — Limpeza dos dados:</h3><p>Com o JSON bruto no Lakehouse, um Notebook (“Silver — Data Cleaning”) entra em ação para padronizar e limpar os dados: achatar a estrutura JSON, tratar valores nulos, normalizar datas e selecionar apenas os campos relevantes (`author`, `title`, `description`, `content`, `source`, `publishedAt`, `url`).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/756/1*u6HIBpylkbNgmFB_YSMMMg.png" /></figure><p>Nas configurações da atividade, o notebook é vinculado ao workspace `bing_api_project`, executando o “Silver Notebook” de forma orquestrada pelo pipeline.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_-O6OBSt6DIoBPag3Zmg_Q.png" /></figure><p>— -</p><h3>3. Camada Gold — Análise de Sentimentos:</h3><p>A camada Gold é onde o valor de negócio aparece. O notebook “Sentimental Analysis — Gold” recebe os dados limpos da Silver e aplica processamento de linguagem natural (NLP) para classificar cada notícia.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w-IYgtOn1xYtZiWxULYtog.png" /></figure><p>O resultado da camada Bronze/Silver pode ser inspecionado pelo SQL analytics endpoint do Lakehouse. A tabela `t_raw_news` mostra as notícias já estruturadas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n8UEKJqw_lKs75XKsFMcHg.png" /></figure><p>Já a tabela `t_raw_sentiment_nalysis` traz o resultado do NLP, com a classificação (`sentiment`) e os escores de probabilidade `sentiment_pos`, `sentiment_neutral` e `sentiment_neg` para cada artigo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t_kU0-KNmkXnX2f6JDc29w.png" /></figure><p>— -</p><h3>4. Visualização — Relatório no Power BI:</h3><p>Sobre a camada Gold, construí o relatório “News PBI” no Power BI. Ele resume os percentuais de sentimento em cartões (Negative / Neutral / Positive Sentiment %), lista as notícias com título, fonte e descrição, e oferece um filtro por data de publicação (`publishedAt`).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4Hce4kEzJcQjB1I6h7RsZQ.png" /></figure><p>— -</p><h3>5. Tempo real — Alertas com o Data Activator:</h3><p>Para fechar o ciclo, configurei o Data Activator sobre as métricas do relatório. Sempre que o Neutral Sentiment % diminui além de um limite definido, um alerta é disparado — com notificação enviada diretamente para o Microsoft Teams.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ODE9bSGdu-EE_Hchm9h14Q.png" /></figure><p>No hub de tempo real, o objeto `newspbi` registra cada evento de métrica do Power BI, permitindo acompanhar a evolução do sentimento ao longo do tempo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lCqKO9IEWrOXGkgyn7P5eQ.png" /></figure><p>— -</p><h3>Orquestração ponta a ponta:</h3><p>Todas as etapas são amarradas em um único Data Pipeline, que executa as três camadas em sequência, garantindo dependências e ordem corretas:</p><p>Ingestion — Bronze → Silver — Data Cleaning → Sentimental Analysis — Gold</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UeM5uQxSy4XxeaDguO58Mg.png" /></figure><p>— -</p><h3>Conclusão:</h3><p>Com o Microsoft Fabric foi possível entregar, em uma única plataforma SaaS, todas as peças de uma solução de dados moderna:</p><p>- Ingestão de uma API REST via Data Pipeline;</p><p>- Arquitetura Medalhão (Bronze, Silver, Gold) no Lakehouse;</p><p>- Análise de sentimentos com NLP em notebooks PySpark;</p><p>- Visualização no Power BI;</p><p>- Alertas em tempo real com o Data Activator e integração com o Teams.</p><p>O grande diferencial é a integração nativa: não precisei costurar serviços separados tudo (armazenamento, processamento, BI e alertas) vive no mesmo ecossistema, com governança e segurança centralizadas.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=20ea338b590b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Comment j’ai construit un Data Product complet, de MongoDB à BigQuery, façon Data Mesh]]></title>
            <link>https://medium.com/@andreretorta046/comment-jai-construit-un-data-product-complet-de-mongodb-%C3%A0-bigquery-fa%C3%A7on-data-mesh-c03a13874b91?source=rss-e3e3b218dbe4------2</link>
            <guid isPermaLink="false">https://medium.com/p/c03a13874b91</guid>
            <category><![CDATA[data-mesh]]></category>
            <category><![CDATA[airflow]]></category>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[dbt]]></category>
            <category><![CDATA[bigquery]]></category>
            <dc:creator><![CDATA[Andreretorta]]></dc:creator>
            <pubDate>Sun, 21 Jun 2026 15:04:27 GMT</pubDate>
            <atom:updated>2026-06-21T15:04:27.014Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*VbsK1PQqzVk-1-uutiFL_g.png" /></figure><p>Je voulais construire un projet qui montre, concrètement, le cycle de vie complet d’un Data Product du premier octet au dernier, tel qu’il naît vraiment dans une entreprise qui prend les données au sérieux. Sans raccourcis :</p><p>ingestion écrite de zéro, orchestration réelle, transformation en couches, infrastructure as code, sécurité sans clés et un CI/CD qui ne déploie en production qu’après une approbation humaine.</p><p>Le résultat est `music-stream-rawdp` : un Raw Data Product de bout en bout construit sur GCP, qui part d’un MongoDB opérationnel et livre des vues propres et gouvernées dans BigQuery reproductible par n’importe qui, gratuitement, en un seul `docker compose up`.</p><p><em>Ce projet est un clone de portfolio d’un data product d’entreprise réel. Toute la stack est open source ou dispose d’une offre gratuite, et chaque décision d’architecture a été prise pour ressembler à ce qu’on voit en production, pas à un tutoriel.</em></p><h3>Le problème:</h3><p>Imaginez une plateforme de streaming musical. Les données opérationnelles vivent dans MongoDB : genres, artistes, morceaux et événements de lecture (plays).</p><p>Ces données sont parfaites pour l’application mais désastreuses pour l’analyse schéma flexible, documents imbriqués, aucune garantie de type, aucun historique.</p><p>L’équipe data doit transformer cette matière brute en tables propres, typées et fiables dans le data warehouse, avec un contrat clair sur qui peut consommer quoi. C’est précisément le rôle d’un Raw Data Product au sein d’une architecture Data Mesh : le produit est propriétaire de sa source, de sa transformation et de son contrat de sortie.</p><p>Pour tout rendre reproductible, j’ai aussi écrit un générateur de données synthétiques (`seed/`) qui peuple Mongo avec un volume réaliste 15 genres, 300 artistes, 2 000 morceaux et 50 000 événements de lecture pour que le pipeline ait de quoi travailler dès la première seconde.</p><h3>L’architecture:</h3><p>Le flux suit une architecture medallion :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*5iTCYXODV-8JI8gUPw57Cg.png" /></figure><p>En résumé : MongoDB → Airflow (opérateur maison) → Google Cloud Storage → BigQuery `internal` → dbt → `master` → `output_clear`, avec une couche `monitoring` pour la qualité des données.</p><p>- Ingestion : j’ai écrit un opérateur d’ingestion maison (MongoDB → GCS), sans dépendre de plateformes propriétaires de transfert de données.</p><p>- Orchestration : Apache Airflow (exécuté via Astronomer/Astro CLI), avec un DAG qui orchestre l’ingestion et la transformation.</p><p>- Transformation : dbt suivant le modèle medallion — `internal` (brut) → `master` (`t_raw_`, traité) → `output_clear` (`v_raw_`, vues de consommation).</p><p>- Infrastructure as code : Terraform provisionne tout sur GCP projets, IAM, Workload Identity Federation, Secret Manager, buckets, datasets et un Cloud Run Job qui exécute dbt.</p><p>- CI/CD : GitHub Actions exécute le lint, les tests, `dbt parse`, `terraform plan/apply` et reconstruit l’image dbt automatiquement.</p><h3>L’ingestion : un opérateur écrit de zéro</h3><p>Plutôt que de brancher un outil de transfert propriétaire, j’ai écrit le `MongoToGCSIngestionOperator` un opérateur Airflow personnalisé qui lit une collection MongoDB et l’écrit dans GCS au format NDJSON. Il fait trois choses qui comptent dans un scénario réel :</p><p>- Il estampille chaque document avec `airflow_ds` (la partition logique du jour) et un `ingestion_timestamp`, pour que chaque ligne sache exactement de quelle exécution elle provient.</p><p>- Il est idempotent par conception : le préfixe GCS est dérivé du `ds` de l’exécution, donc retraiter le même jour écrase les mêmes fichiers au lieu de dupliquer les données.</p><p>- Il ne transporte aucune clé : il utilise `impersonation_chain` pour endosser l’identité du service account de l’orchestrateur, donc ni MongoDB ni GCS n’ont besoin d’identifiants embarqués dans le conteneur.</p><p>Par entité, le DAG d’ETL exécute la séquence `extract (Mongo → GCS) → gcs_to_bq → delete_gcs_files → transformation (dbt sur Cloud Run)`, en gardant GCS comme zone d’atterrissage éphémère.</p><h3>Les couches medallion en pratique:</h3><p>Chaque dataset BigQuery a un rôle et un contrat bien définis :</p><p>- `internal` (`t_raw_`) : zone d’atterrissage provisionnée par Terraform et chargée par `gcs_to_bq`, partitionnée physiquement par `airflow_ds`. C’est le portrait fidèle de la donnée brute.</p><p>- `master` (`t_raw_`) : modèles incrémentaux dbt qui promeuvent, typent et traitent la donnée. Après la promotion, un `post_hook` tronque la table d’atterrissage dans `internal` — donc un `internal` vide après dbt est voulu, pas un bug.</p><p>- `output_clear` (`v_raw_`) : vues de consommation, exposées en tant qu’authorized views sur `master`. C’est le seul contrat que voient les consommateurs.</p><p>- `monitoring` : modèles de qualité (ex. freshness) qui surveillent le pipeline.</p><p>Une décision délibérée : le filtre de partition vit uniquement au niveau physique de BigQuery, jamais dans le SQL des modèles. Les modèles dbt restent des `SELECT` propres et lisibles, tandis que le partitionnement relève de l’infrastructure.</p><h3>Infrastructure as code et sécurité sans clés:</h3><p>Tout sur GCP est provisionné par Terraform, organisé en modules réutilisables (service account, workload identity, secret manager, buckets, datasets, tables, artifact registry, Cloud Run Job). Deux points traités avec un soin de niveau production :</p><p>- Workload Identity Federation : GitHub Actions s’authentifie sur GCP sans aucune clé de service account stockée dans le dépôt. L’OIDC de GitHub est fédéré directement avec GCP — zéro secret de longue durée à fuiter.</p><p>- dev et prd vraiment isolés : chaque environnement a son propre projet, ses propres buckets et son propre backend de state. Un seul `DEPLOY_ENV` bascule tout le pipeline entre les environnements, et les secrets sont cantonnés par GitHub Environment.</p><h3>CI/CD avec une porte d’approbation humaine pour la production:</h3><p>GitHub Actions relie le flux de qualité et de déploiement :</p><p>- À chaque PR : flake8 + pytest, `dbt parse` et `terraform fmt/validate` s’exécutent comme status checks obligatoires. Pas de vert, pas de merge.</p><p>- Le flux de branches est `dev_andre` → PR → `dev` (déploie automatiquement en DEV) → PR → `main` (déploie en PRD).</p><p>- La production a une porte d’approbation : l’environnement GitHub `prd` exige un relecteur, donc `terraform apply` et le build de l’image dbt se mettent en pause en attendant un “Approve deployment” manuel avant de toucher la production.</p><p>- Tout changement dans `transformations/dbt/` reconstruit et publie l’image dbt automatiquement dans Artifact Registry, que le Cloud Run Job exécute ensuite.</p><p>Lancez-le vous-même, gratuitement Pas de “croyez-moi, ça marche”. N’importe qui peut cloner le dépôt, lancer un MongoDB factice avec Docker, exécuter le générateur de seed et voir le pipeline traiter les données en local sans aucun compte payant nulle part.</p><p>Qui veut aller plus loin peut brancher sa propre GCP et parcourir le chemin complet jusqu’à BigQuery. Le projet entier a été vérifié de bout en bout sur une vraie GCP, du `extract` dans Mongo jusqu’à `output_clear.v_raw_` dans BigQuery.</p><h3>Ce que j’ai appris:</h3><p>- Le Data Mesh n’est pas que de la théorie. Séparer `internal`/`master`/`output_clear` rend explicite le contrat de chaque couche et simplifie la gouvernance — chaque consommateur ne voit que la vue propre, jamais la donnée brute.</p><p>- Pas de clés, s’il vous plaît. J’ai utilisé Workload Identity Federation pour que GitHub Actions s’authentifie sur GCP sans aucune clé de service account stockée une bonne pratique de sécurité fondamentale.</p><p>- Un opérateur maison apprend plus qu’un outil à clics. Écrire l’ingestion de zéro m’a obligé à comprendre l’idempotence, le partitionnement et l’usurpation d’identité des choses qu’un outil propriétaire masque.</p><p>- dev et prd pour de vrai, avec une porte d’approbation. Un seul `DEPLOY_ENV` bascule tout le pipeline entre les environnements, et la production ne part qu’après un clic humain d’approbation.</p><p>- Reproductible par tous. N’importe qui peut cloner le dépôt, lancer un MongoDB factice avec Docker et voir le pipeline tourner en local gratuitement.</p><h3>Conclusion:</h3><p>Ce projet m’a offert une vision complète du cycle de vie d’un produit de données : de la source opérationnelle aux tables finales, en passant par la sécurité, l’automatisation et la qualité. C’est le genre de projet qui montre non seulement ce que je sais, mais comment je pense l’ingénierie des données.</p><p>Stack : Python · MongoDB · Apache Airflow / Astronomer · dbt · BigQuery ·Google Cloud Storage · Cloud Run · Terraform · GitHub Actions · Docker.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c03a13874b91" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cómo construí un Data Product completo, de MongoDB a BigQuery, al estilo Data Mesh]]></title>
            <link>https://medium.com/@andreretorta046/c%C3%B3mo-constru%C3%AD-un-data-product-completo-de-mongodb-a-bigquery-al-estilo-data-mesh-5613c1594806?source=rss-e3e3b218dbe4------2</link>
            <guid isPermaLink="false">https://medium.com/p/5613c1594806</guid>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[data-mesh]]></category>
            <category><![CDATA[bigquery]]></category>
            <category><![CDATA[dbt]]></category>
            <category><![CDATA[airflow]]></category>
            <dc:creator><![CDATA[Andreretorta]]></dc:creator>
            <pubDate>Fri, 19 Jun 2026 09:45:26 GMT</pubDate>
            <atom:updated>2026-06-19T09:45:26.499Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*VbsK1PQqzVk-1-uutiFL_g.png" /></figure><p>Quise construir un proyecto que mostrara, en la práctica, el ciclo de vida completo de un Data Product del primer byte al último, tal como realmente nace dentro de una empresa que se toma los datos en serio. Sin atajos: ingesta escrita desde cero, orquestación de verdad, transformación por capas, infraestructura como código, seguridad sin claves y un CI/CD que solo despliega a producción tras una aprobación humana.</p><p>El resultado es `music-stream-rawdp`: un Raw Data Product de extremo a extremo construido sobre GCP que parte de un MongoDB operativo y entrega vistas limpias y gobernadas en BigQuery — reproducible por cualquiera, gratis, en un solo `docker compose up`.</p><p><em>&gt; Este proyecto es un clon de portafolio de un data product corporativo real. Toda la stack es open source o tiene capa gratuita, y cada decisión de arquitectura se tomó para parecerse a lo que se ve en producción, no a un tutorial.</em></p><h3>El problema:</h3><p>Imagina una plataforma de streaming de música. Los datos operativos viven en MongoDB: géneros, artistas, pistas y eventos de reproducción (plays). Esos datos son geniales para la aplicación pero pésimos para el análisis esquema flexible, documentos anidados, sin garantía de tipos, sin historial. El equipo de datos necesita transformar ese material en bruto en tablas limpias, tipadas y confiables en el data warehouse, con un contrato claro de quién puede consumir qué. Ese es justamente el trabajo de un Raw Data Product dentro de una arquitectura Data Mesh: el producto es dueño de su fuente, de su transformación y de su contrato de salida.</p><p>Para hacerlo todo reproducible, escribí además un generador de datos sintéticos (`seed/`) que puebla Mongo con volumen realista 15 géneros, 300 artistas, 2.000 pistas y 50.000 eventos de reproducción para que el pipeline tenga algo que procesar desde el primer segundo.</p><h3>La arquitectura:</h3><p>El flujo sigue una arquitectura medallion:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*5iTCYXODV-8JI8gUPw57Cg.png" /></figure><p>En palabras: MongoDB → Airflow (operador propio) → Google Cloud Storage → BigQuery `internal` → dbt → `master` → `output_clear`, con una capa de `monitoring` para la calidad de los datos.</p><p>- Ingesta: escribí un operador de ingesta propio (MongoDB → GCS), sin depender de plataformas propietarias de transferencia de datos.</p><p>- Orquestación: Apache Airflow (ejecutado vía Astronomer/Astro CLI), con un DAG que orquesta la ingesta y la transformación.</p><p>- Transformación: dbt siguiendo el patrón medallion — `internal` (bruto) → `master` (`t_raw_`, curado) → `output_clear` (`v_raw_`, vistas de consumo).</p><p>- Infraestructura como código: Terraform aprovisiona todo en GCP proyectos, IAM, Workload Identity Federation, Secret Manager, buckets, datasets y un Cloud Run Job que ejecuta dbt.</p><p>- CI/CD: GitHub Actions ejecuta lint, pruebas, `dbt parse`, `terraform plan/apply` y reconstruye la imagen de dbt automáticamente.</p><h3>La ingesta: un operador escrito desde cero</h3><p>En lugar de enchufar una herramienta propietaria de transferencia, escribí el `MongoToGCSIngestionOperator` un operador personalizado de Airflow que lee una colección de MongoDB y la escribe en GCS como NDJSON. Hace tres cosas que</p><h3>importan en un escenario real:</h3><p>- Sella cada documento con `airflow_ds` (la partición lógica del día) y un `ingestion_timestamp`, para que cada fila sepa exactamente de qué ejecución proviene.</p><p>- Es idempotente por diseño: el prefijo en GCS se deriva del `ds` de la ejecución, así que reprocesar el mismo día sobrescribe los mismos archivos en lugar de duplicar datos.</p><p>- No lleva claves: usa `impersonation_chain` para asumir la identidad del service account del orquestador, así que ni MongoDB ni GCS necesitan credenciales incrustadas en el contenedor.</p><p>Por entidad, el DAG de ETL ejecuta la secuencia`extract (Mongo → GCS) → gcs_to_bq → delete_gcs_files → transformation (dbt en Cloud Run)`, manteniendo GCS como una zona de aterrizaje efímera.</p><h3>Las capas medallion en la práctica:</h3><p>Cada dataset de BigQuery tiene un papel y un contrato bien definidos:</p><p>- `internal` (`t_raw_`): zona de aterrizaje aprovisionada por Terraform y cargada por `gcs_to_bq`, particionada físicamente por `airflow_ds`. Es el retrato fiel del dato crudo.</p><p>- `master` (`t_raw_`): modelos incrementales de dbt que promueven, tipan y curan el dato. Tras la promoción, un `post_hook` trunca la tabla de aterrizaje en `internal` — así que un `internal` vacío después de dbt es intencional, no un bug.</p><p>- `output_clear` (`v_raw_`): vistas de consumo, expuestas como authorized views sobre `master`. Es el único contrato que ven los consumidores.</p><p>- `monitoring`: modelos de calidad (p. ej. freshness) que vigilan el pipeline.</p><p>Una decisión consciente: el filtro de partición vive solo en el nivel físico de BigQuery, nunca dentro del SQL de los modelos. Los modelos dbt siguen siendo `SELECT`s limpios y legibles, mientras que el particionado es responsabilidad de la infraestructura.</p><h3>Infraestructura como código y seguridad sin claves:</h3><p>Todo en GCP se aprovisiona con Terraform, organizado en módulos reutilizables (service account, workload identity, secret manager, buckets, datasets, tablas, artifact registry, Cloud Run Job). Dos puntos que traté con cuidado de producción:</p><p>- Workload Identity Federation: GitHub Actions se autentica en GCP sin ninguna clave de service account guardada en el repositorio. El OIDC de GitHub está federado directamente con GCP — cero secretos de larga duración que filtrar.</p><p>- dev y prd realmente aislados: cada entorno tiene su propio proyecto, sus propios buckets y su propio backend de state. Un único `DEPLOY_ENV` cambia el pipeline completo entre entornos, y los secretos están acotados por GitHub Environment.</p><h3>CI/CD con aprobación humana para producción:</h3><p>GitHub Actions une el flujo de calidad y despliegue:</p><p>- En cada PR: flake8 + pytest, `dbt parse` y `terraform fmt/validate` se ejecutan como status checks obligatorios. Sin verde, no hay merge.</p><p>- El flujo de ramas es `dev_andre` → PR → `dev` (despliega automáticamente en DEV) → PR → `main` (despliega en PRD).</p><p>- Producción tiene puerta de aprobación: el GitHub Environment `prd` exige un revisor, así que `terraform apply` y el build de la imagen dbt se pausan esperando un “Approve deployment” manual antes de tocar producción.</p><p>- Cualquier cambio en `transformations/dbt/` reconstruye y publica la imagen dbt automáticamente en Artifact Registry, que el Cloud Run Job luego ejecuta.</p><h3>Ejecútalo tú mismo, gratis:</h3><p>Nada de “confía en mí, funciona”. Cualquiera puede clonar el repositorio, levantar un MongoDB falso con Docker, ejecutar el generador de seed y ver el pipeline procesar datos localmente — sin necesidad de cuenta de pago en ningún lado. Quien quiera ir más allá puede enchufar su propia GCP y recorrer el camino completo hasta BigQuery. El proyecto entero fue verificado de extremo a extremo en una GCP real, desde el `extract` en Mongo hasta `output_clear.v_raw_` en BigQuery.</p><h3>Lo que aprendí:</h3><p>- El Data Mesh no es solo teoría. Separar `internal`/`master`/`output_clear` hace explícito el contrato de cada capa y facilita la gobernanza cada consumidor ve solo la vista limpia, nunca el dato crudo.</p><p>- Sin claves, por favor. Usé Workload Identity Federation para que GitHub Actions se autentique en GCP sin ninguna clave de service account almacenada una buena práctica de seguridad fundamental.</p><p>- Un operador propio enseña más que una herramienta de clic. Escribir la ingesta desde cero me obligó a entender idempotencia, particionado e impersonación de identidad cosas que una herramienta propietaria oculta.</p><p>- dev y prd de verdad, con puerta de aprobación. Un único `DEPLOY_ENV` cambia todo el pipeline entre entornos, y producción solo se despliega con un clic humano de aprobación.</p><p>- Reproducible para cualquiera. Cualquiera puede clonar el repo, levantar un MongoDB falso con Docker y ver el pipeline ejecutarse localmente — gratis.</p><h3>Conclusión:</h3><p>Este proyecto me dio una visión completa del ciclo de vida de un producto de datos: desde la fuente operativa hasta las tablas finales, pasando por</p><p>seguridad, automatización y calidad. Es el tipo de proyecto que muestra no solo qué sé, sino cómo pienso la ingeniería de datos.</p><p>Stack: Python · MongoDB · Apache Airflow / Astronomer · dbt · BigQuery ·Google Cloud Storage · Cloud Run · Terraform · GitHub Actions · Docker.</p><p><em>Enlace al repositorio de </em><a href="https://github.com/andreretorta/music-stream-rawdp"><em>GitHub</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5613c1594806" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I built a complete Data Product, from MongoDB to BigQuery, Data Mesh style]]></title>
            <link>https://medium.com/@andreretorta046/how-i-built-a-complete-data-product-from-mongodb-to-bigquery-data-mesh-style-37bd91b7e5cf?source=rss-e3e3b218dbe4------2</link>
            <guid isPermaLink="false">https://medium.com/p/37bd91b7e5cf</guid>
            <category><![CDATA[airflow]]></category>
            <category><![CDATA[data-mesh]]></category>
            <category><![CDATA[bigquery]]></category>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[dbt]]></category>
            <dc:creator><![CDATA[Andreretorta]]></dc:creator>
            <pubDate>Thu, 18 Jun 2026 11:11:37 GMT</pubDate>
            <atom:updated>2026-06-18T11:11:37.147Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*VbsK1PQqzVk-1-uutiFL_g.png" /></figure><p>I wanted to build a project that showed, in practice, the full lifecycle of a Data Product — from the first byte to the last, the way it actually comes to life inside a company that takes data seriously. No shortcuts: ingestion written from scratch, real orchestration, layered transformation, infrastructure as code, keyless security, and a CI/CD pipeline that only ships to production after a human approval.</p><p>The result is `music-stream-rawdp`: an end-to-end Raw Data Product built on GCP that takes an operational MongoDB and delivers clean, governed views in BigQuery — reproducible by anyone, for free, in a single `docker compose up`.</p><p><em>&gt; This project is a portfolio clone of a real corporate data product. The whole stack is open source or has a free tier, and every architectural decision was made to look like what you see in production, not like a tutorial.</em></p><h3>The problem:</h3><p>Picture a music streaming platform. The operational data lives in MongoDB: genres, artists, tracks and playback events (plays). That data is great for the app but terrible for analytics — flexible schema, nested documents, no type guarantees, no history. The data team needs to turn that raw material into clean, typed, reliable tables in the data warehouse, with a clear contract of who can consume what. That’s exactly the job of a Raw Data Product inside a Data Mesh architecture: the product owns its source, its transformation and its output contract.</p><p>To make everything reproducible, I also wrote a synthetic data generator (`seed/`) that populates Mongo with realistic volume — 15 genres, 300 artists, 2,000 tracks and 50,000 playback events — so the pipeline has something to chew on from the very first second.</p><h3>The architecture:</h3><p>The flow follows a medallion architecture:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*5iTCYXODV-8JI8gUPw57Cg.png" /></figure><p>In words: MongoDB → Airflow (custom operator) → Google Cloud Storage → BigQuery `internal` → dbt → `master` → `output_clear`, with a `monitoring` layer for data quality.</p><p>- Ingestion: I wrote a custom ingestion operator (MongoDB → GCS), with no reliance on proprietary data-transfer platforms.</p><p>- Orchestration: Apache Airflow (running via Astronomer/Astro CLI), with a DAG that orchestrates ingestion and transformation.</p><p>- Transformation: dbt following the medallion pattern — `internal` (raw) → `master` (`t_raw_`, curated) → `output_clear` (`v_raw_`, consumption views).</p><p>- Infrastructure as code: Terraform provisions everything on GCP projects, IAM, Workload Identity Federation, Secret Manager, buckets, datasets and a Cloud Run Job that runs dbt.</p><p>- CI/CD: GitHub Actions runs lint, tests, `dbt parse`, `terraform plan/apply` and rebuilds the dbt image automatically.</p><h3>Ingestion: an operator written from scratch</h3><p>Instead of plugging in a proprietary transfer tool, I wrote the `MongoToGCSIngestionOperator`a custom Airflow operator that reads a MongoDB collection and writes it to GCS as NDJSON. It does three things that matter in a real-world scenario:</p><p>- It stamps every document with `airflow_ds` (the logical day partition) and an `ingestion_timestamp`, so each row knows exactly which run it came from.</p><p>- It’s idempotent by design: the GCS prefix is derived from the run’s `ds`, so reprocessing the same day overwrites the same files instead of duplicating data.</p><p>- It carries no keys: it uses `impersonation_chain` to assume the orchestrator service account’s identity, so neither MongoDB nor GCS need credentials baked into the container.</p><p>Per entity, the ETL DAG runs the sequence `extract (Mongo → GCS) → gcs_to_bq → delete_gcs_files → transformation (dbt on Cloud Run)`, keeping GCS as an ephemeral landing zone.</p><h3>The medallion layers in practice:</h3><p>Each BigQuery dataset has a well-defined role and contract:</p><p>- `internal` (`t_raw_`): a landing zone provisioned by Terraform and loaded by `gcs_to_bq`, physically partitioned by `airflow_ds`. It’s a faithful snapshot of the raw data.</p><p>- `master` (`t_raw_`): incremental dbt models that promote, type and curate the data. After promotion, a `post_hook` truncates the landing table in `internal` — so an empty `internal` after dbt is by design, not a bug.</p><p>- `output_clear` (`v_raw_`): consumption views, exposed as authorized views over `master`. It’s the only contract consumers ever see.</p><p>- `monitoring`: quality models (e.g. freshness) that watch the pipeline.</p><h3>One deliberate decision:</h3><p>The partition filter lives only at the physical BigQuery level, never inside the model SQL. The dbt models stay clean,readable `SELECT`s, while partitioning is the infrastructure’s responsibility.</p><h3>Infrastructure as code and keyless security:</h3><p>Everything on GCP is provisioned by Terraform, organized into reusable modules (service account, workload identity, secret manager, buckets, datasets, tables, artifact registry, Cloud Run Job). Two things I handled with production-grade care:</p><p>- Workload Identity Federation: GitHub Actions authenticates to GCP with no service-account keys stored in the repo. GitHub’s OIDC is federated directly with GCP zero long-lived secrets to leak.</p><p>- Truly isolated dev and prd: each environment has its own project, its own buckets and its own state backend. A single `DEPLOY_ENV` switches the whole pipeline between environments, and secrets are scoped per GitHub Environment.</p><h3>CI/CD with a human approval gate for production:</h3><p>GitHub Actions ties the quality and deploy flow together:</p><p>- On every PR: flake8 + pytest, `dbt parse` and `terraformfmt/validate` run as required status checks. No green, no merge.</p><p>- The branch flow is `dev_andre` → PR → `dev` (auto-deploys to DEV) → PR →`main` (deploys to PRD).</p><p>- Production has an approval gate: the `prd` GitHub Environment requires a reviewer, so `terraform apply` and the dbt image build pause waiting for a manual “Approve deployment” before touching production.</p><p>- Any change under `transformations/dbt/` rebuilds and publishes the dbt image automatically to Artifact Registry, which the Cloud Run Job then runs.</p><h3>Run it yourself, for free:</h3><p>No “trust me, it works.” Anyone can clone the repository, spin up a fake MongoDB with Docker, run the seed generator and watch the pipeline process data locally no paid account required anywhere. If you want to go further, plug in your own GCP and run the full path all the way to BigQuery. The whole project was verified end to end on a real GCP, from the Mongo `extract` to `output_clear.v_raw_` in BigQuery.</p><h3>What I learned:</h3><p>- Data Mesh isn’t just theory. Separating `internal`/`master`/`output_clear` makes each layer’s contract explicit and simplifies governance every consumer sees only the clean view, never the raw data.</p><p>- No keys, please. I used Workload Identity Federation so GitHub Actions authenticates to GCP with no service-account keys stored anywhere a fundamental security best practice.</p><p>- A custom operator teaches more than a click tool. Writing ingestion from scratch forced me to understand idempotency, partitioning and identity impersonation things a proprietary tool hides.</p><p>- Real dev and prd, with an approval gate. A single `DEPLOY_ENV` switches the whole pipeline between environments, and production only ships with a human approval click.</p><p>- Reproducible for anyone. Anyone can clone the repo, spin up a fake MongoDB with Docker and watch the pipeline run locally for free.</p><h3>Takeaway:</h3><p>This project gave me a full view of a data product’s lifecycle: from the operational source to the final tables, passing through security, automation and quality. It’s the kind of project that shows not only what I know, but how I think about data engineering.</p><p>Stack: Python · MongoDB · Apache Airflow / Astronomer · dbt · BigQuery ·Google Cloud Storage · Cloud Run · Terraform · GitHub Actions · Docker.</p><p><em>Link to the </em><a href="https://github.com/andreretorta/music-stream-rawdp"><em>GitHub </em></a><em>Repository</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=37bd91b7e5cf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como construí um Data Product completo, do MongoDB ao BigQuery, no estilo Data Mesh]]></title>
            <link>https://medium.com/@andreretorta046/como-constru%C3%AD-um-data-product-completo-do-mongodb-ao-bigquery-no-estilo-data-mesh-595039d0f9e7?source=rss-e3e3b218dbe4------2</link>
            <guid isPermaLink="false">https://medium.com/p/595039d0f9e7</guid>
            <category><![CDATA[dbt]]></category>
            <category><![CDATA[airflow]]></category>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[data-mesh]]></category>
            <category><![CDATA[bigquery]]></category>
            <dc:creator><![CDATA[Andreretorta]]></dc:creator>
            <pubDate>Wed, 17 Jun 2026 11:45:17 GMT</pubDate>
            <atom:updated>2026-06-17T11:45:17.844Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Kd3AQcOUQ-HRcYGlPvlMvA.png" /></figure><p>Quis construir um projeto que mostrasse, na prática, como reproduzir o ciclo de vida completo de um Data Product, do primeiro byte ao último, do jeito que ele realmente nasce dentro de uma empresa que leva dados a sério. Nada de atalhos: ingestão escrita do zero, orquestração de verdade, transformação em camadas, infraestrutura como código, segurança sem chaves e um CI/CD que só libera produção depois de uma aprovação humana.</p><p>O resultado é o `music-stream-rawdp`: um Raw Data Product de ponta a ponta, construído sobre GCP, que sai de um MongoDB operacional e entrega views limpas e governadas no BigQuery reproduzível por qualquer pessoa, de graça, num único `docker compose up`.</p><p><em>&gt; Este projeto é um clone de portfólio de um data product corporativo real. Toda a stack é open source ou tem camada gratuita, e cada decisão de arquitetura foi pensada para parecer com o que se vê em produção, não com um tutorial.</em></p><h3>O problema:</h3><p>Imagine uma plataforma de streaming de música. Os dados operacionais vivem num MongoDB: gêneros, artistas, faixas e eventos de reprodução (plays). Esses dados são ótimos para a aplicação, mas péssimos para análise de schema flexível, documentos aninhados, sem garantia de tipos, sem histórico. O time de dados precisa transformar esse material cru em tabelas limpas, tipadas e confiáveis no data warehouse, com um contrato claro de quem pode consumir o quê.</p><p>Esse é exatamente o trabalho de um Raw Data Product dentro de uma arquitetura Data Mesh: o produto é dono da sua fonte, da sua transformação e do seu contrato de saída.</p><p>Para tornar tudo reproduzível, escrevi também um gerador de dados sintéticos (`seed/`) que popula o Mongo com volume realista: 15 gêneros, 300 artistas, 2.000 faixas e 50.000 eventos de reprodução para que o pipeline tenha o que processar desde o primeiro segundo.</p><h3>A arquitetura:</h3><p>O fluxo segue uma arquitetura medallion:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*5iTCYXODV-8JI8gUPw57Cg.png" /></figure><p>Em palavras: MongoDB → Airflow (operador próprio) → Google Cloud Storage → BigQuery `internal` → dbt → `master` → `output_clear`, com uma camada de `monitoring` para qualidade de dados.</p><p>- Ingestão: escrevi um operador de ingestão próprio (MongoDB → GCS), sem depender de plataformas proprietárias de transferência de dados.</p><p>- Orquestração: Apache Airflow (rodando via Astronomer/Astro CLI), com um DAG que orquestra ingestão e transformação.</p><p>- Transformação: dbt seguindo o padrão medallion — `internal` (cru) →`master` (`t_raw_`, tratado) → `output_clear` (`v_raw_`, views de consumo).</p><p>- Infraestrutura como código: Terraform provisiona tudo na GCP projetos, IAM, Workload Identity Federation, Secret Manager, buckets, datasets e um Cloud Run Job que executa o dbt.</p><p>- CI/CD: GitHub Actions roda lint, testes, `dbt parse`, `terraform plan/apply` e reconstrói a imagem do dbt automaticamente.</p><h3>A ingestão: um operador escrito do zero</h3><p>Em vez de plugar uma ferramenta proprietária de transferência, escrevi o`MongoToGCSIngestionOperator`um operador customizado do Airflow que lê uma coleção do MongoDB e a grava no GCS como NDJSON. Ele faz três coisas que importam num cenário real:</p><p>- Carimba cada documento com `airflow_ds` (a partição lógica do dia) e um `ingestion_timestamp`, para que cada linha saiba exatamente de qual execução veio.</p><p>- É idempotente por design: o prefixo no GCS é derivado do `ds` da execução, então reprocessar o mesmo dia sobrescreve os mesmos arquivos em vez de duplicar dados.</p><p>- Não carrega chaves: usa `impersonation_chain` para assumir a identidade do service account do orquestrador, então nem o MongoDB nem o GCS exigem credenciais embutidas no container.</p><p>O DAG de ETL roda, por entidade, a sequência `extract (Mongo → GCS) → gcs_to_bq → delete_gcs_files → transformation (dbt no Cloud Run)`, mantendo o GCS como uma zona de pouso efêmera.</p><h3>As camadas medallion na prática:</h3><p>Cada dataset do BigQuery tem um papel e um contrato bem definidos:</p><p>- `internal` (`t_raw_`): zona de pouso provisionada pelo Terraform e carregada pelo `gcs_to_bq`, particionada fisicamente por `airflow_ds`. É o retrato fiel do dado cru.</p><p>- `master` (`t_raw_`): modelos incrementais do dbt que promovem, tipam e tratam o dado. Após a promoção, um `post_hook` trunca a tabela de pouso em `internal` — então um `internal` vazio depois do dbt é intencional, não um bug.</p><p>- `output_clear` (`v_raw_`): views de consumo, expostas como authorized views sobre o `master`. É o único contrato que os consumidores enxergam.</p><p>- `monitoring`: modelos de qualidade (ex.: freshness) que vigiam o pipeline.</p><h3>Uma decisão consciente:</h3><p>O filtro de partição vive só no nível físico do BigQuery, nunca dentro do SQL dos modelos. Os modelos dbt permanecem `SELECT`s limpos e legíveis, enquanto o particionamento é responsabilidade da infra.</p><h3>Infraestrutura como código e segurança sem chaves:</h3><p>Tudo na GCP é provisionado por Terraform, organizado em módulos reutilizáveis (service account, workload identity, secret manager, buckets, datasets, tabelas, artifact registry, Cloud Run Job). Dois pontos que tratei com cuidado de produção:</p><p>- Workload Identity Federation: o GitHub Actions se autentica na GCP sem nenhuma chave de service account guardada no repositório. O OIDC do GitHub é federado direto com a GCP — zero segredos de longa duração para vazar.</p><p>- dev e prd isolados de verdade: cada ambiente tem seu próprio projeto, seus próprios buckets e seu próprio backend de state. Um único `DEPLOY_ENV` troca o pipeline inteiro entre os ambientes, e os secrets ficam escopados por GitHub Environment.</p><h3>CI/CD com aprovação humana para produção:</h3><p>O GitHub Actions amarra o fluxo de qualidade e deploy:</p><p>- Em cada PR: flake8 + pytest, `dbt parse` e `terraform fmt/validate` rodam como status checks obrigatórios. Sem verde, não há merge.</p><p>- O fluxo de branches é `dev_andre` → PR → `dev` (deploy automático em DEV) → PR → `main` (deploy em PRD).</p><p>- Produção tem porta de aprovação: o GitHub Environment `prd` exige um revisor, então `terraform apply` e o build da imagem dbt pausam esperando um “Approve deployment” manual antes de tocar produção.</p><p>- Qualquer mudança em `transformations/dbt/` reconstrói e publica a imagem dbt automaticamente no Artifact Registry, que o Cloud Run Job então executa.</p><h3>Rode você mesmo, de graça:</h3><p>Nada de “confie em mim, funciona”. Qualquer pessoa pode clonar o repositório, subir um MongoDB falso com Docker, rodar o gerador de seed e ver o pipeline processar dados localmente sem precisar de conta paga em lugar nenhum. Quem quiser ir além pode plugar a própria GCP e rodar o caminho completo até o BigQuery. O projeto inteiro foi verificado de ponta a ponta numa GCP real, do `extract` no Mongo até a `output_clear.v_raw_` no BigQuery.</p><h3>O que aprendi:</h3><p>Data Mesh não é só teoria. Separar `internal`/`master`/`output_clear` deixa claro o contrato de cada camada e facilita governança — cada consumidor enxerga só a view limpa, nunca o dado cru.</p><p>- Sem chaves, por favor. Usei Workload Identity Federation para que o GitHub Actions autentique na GCP sem nenhuma chave de service account guardada uma boa prática de segurança fundamental.</p><p>- Operador próprio ensina mais que ferramenta de clique. Escrever a ingestão do zero me obrigou a entender idempotência, particionamento e impersonação de identidade coisas que uma ferramenta proprietária esconde.</p><p>- dev e prd de verdade, com porta de aprovação. Um único `DEPLOY_ENV` troca todo o pipeline entre ambientes, e produção só sai do forno com um clique humano de aprovação.</p><p>- Reprodutível para qualquer pessoa. Qualquer um pode clonar o repo, subir um MongoDB falso com Docker e ver o pipeline rodar localmente — de graça.</p><h3>Conclusão:</h3><p>Este projeto me deu uma visão completa do ciclo de vida de um produto de dados: da fonte operacional até as tabelas finais, passando por segurança, automação e qualidade. É o tipo de projeto que mostra não só o que eu sei,mas como eu penso a engenharia de dados.</p><p>Stack: Python · MongoDB · Apache Airflow / Astronomer · dbt · BigQuery ·Google Cloud Storage · Cloud Run · Terraform · GitHub Actions · Docker.</p><p><em>Link do </em><a href="https://github.com/andreretorta/music-stream-rawdp"><em>GitHub </em></a><em>para o repositório</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=595039d0f9e7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Un pipeline analytique complet avec dbt et Snowflake]]></title>
            <link>https://medium.com/@andreretorta046/un-pipeline-analytique-complet-avec-dbt-et-snowflake-1fa3e020dde3?source=rss-e3e3b218dbe4------2</link>
            <guid isPermaLink="false">https://medium.com/p/1fa3e020dde3</guid>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[analytics-engineering]]></category>
            <category><![CDATA[snowflake]]></category>
            <category><![CDATA[dbt]]></category>
            <dc:creator><![CDATA[Andreretorta]]></dc:creator>
            <pubDate>Wed, 17 Jun 2026 10:46:13 GMT</pubDate>
            <atom:updated>2026-06-17T10:46:13.262Z</atom:updated>
            <content:encoded><![CDATA[<p>Ce projet est né d’une question simple : que faudrait-il pour construire un pipeline de données de bout en bout, de la donnée brute jusqu’à la couche prête pour l’analyse ? Pour y répondre, j’ai utilisé un jeu de données Airbnb et j’ai appliqué, couche par couche, des concepts que je vois souvent mentionnés, mais rarement réunis au même endroit : architecture en couches, contrats de données, tests à quatre niveaux, suivi historique avec les SCD et macros pour réutiliser la logique. Tout au long de l’article, je montre comment chaque pièce s’assemble et le raisonnement derrière chaque décision.</p><p>J’ai utilisé un jeu de données Airbnb avec trois sources — annonces (`listings`), hôtes (`hosts`) et avis (`reviews`) — sur Snowflake comme entrepôt de données et dbt comme outil de transformation. Dans cet article, je passe en revue chaque aspect du projet et explique pourquoi chaque décision a été prise.</p><h3>Vue d’ensemble de l’architecture</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*Hvt-R3Za7b9oPhXE_sslog.png" /></figure><p>Le pipeline suit le modèle ELT moderne. Chaque couche a une responsabilité unique, ce qui garantit une propriété essentielle : un changement dans la source de données n’affecte que la couche `src`, protégeant tous les modèles métier en dessous.</p><h3>1. Sources de données (`sources.yml`)</h3><p>Les trois sources résident dans le schéma `RAW` de Snowflake. La source `reviews` a une freshness configurée — un avertissement est émis si les données ne sont pas rafraîchies pendant plus d’une heure :</p><pre>freshness:<br>warn_after: {count: 1, period: hour}</pre><p>C’est important parce que `fct_reviews` est incrémental : des données arrivant en retard dans la source créeraient des trous silencieux dans la table de faits. La freshness transforme un bug invisible en une alerte.</p><h3>2. La couche `src` — Staging (`ephemeral`)</h3><p>La couche `src` est la seule à lire les données brutes via `source()`. Elle standardise les noms (`id → listing_id`, `date → review_date`, `comments → review_text`) et ne sélectionne que les colonnes pertinentes.</p><p>Pourquoi `ephemeral` ? Les modèles ephemeral ne créent aucun objet physique dans l’entrepôt — ils sont compilés en CTE inline dans les modèles qui les référencent. Résultat : zéro table de staging inutile, un coût de stockage réduit, et toute la modularité du code préservée.</p><pre>raw_listings (source) → src_listings (CTE ephemeral) → dim_listings_cleansed (table)</pre><h3>3. La couche `dim` — Dimensions</h3><p>Trois dimensions, chacune avec un objectif clair :</p><p>- `dim_listings_cleansed` — corrige `minimum_nights` (0 → 1) et convertit `price` de string en `NUMBER`.</p><p>- `dim_hosts_cleansed` — remplace les noms nuls par `’Anonymous’` et possède un contrat de données actif.</p><p>- `dim_listing_w_hosts` — dimension dénormalisée (jointure listings + hosts) qui simplifie les requêtes analytiques.</p><p>Contrat de données sur `dim_hosts_cleansed` :</p><pre>config:<br>contract:<br>enforced: true</pre><p>Avec `contract: enforced`, dbt valide à l’exécution que le schéma produit correspond exactement aux types déclarés. Si une migration de la source change un type silencieusement, dbt échoue avant d’écraser la table — une protection contre les breaking changes invisibles.</p><h3>4. La couche `fct` — Faits (`incremental`)</h3><p>`fct_reviews` est la table de faits des avis. À chaque exécution, seuls les enregistrements plus récents que le maximum actuel sont insérés :</p><pre>{% if is_incremental() %}<br>AND review_date &gt; (SELECT MAX(review_date) FROM {{ this }})<br>{% endif %}</pre><p>Pourquoi incrémental ? La table des avis croît sans cesse. Retraiter tout l’historique à chaque exécution serait infaisable en production — tant en temps qu’en coût de calcul sur Snowflake. J’ai aussi ajouté `on_schema_change=’fail’` : si une colonne apparaît ou disparaît dans la source, dbt s’arrête au lieu de créer un schéma incohérent entre anciens et nouveaux enregistrements.</p><h3>5. La couche `mart` — Consommation (`table`)</h3><p>`mart_fullmoon_reviews` est la couche finale pour la BI. Elle joint `fct_reviews` au seed `seed_full_moon_dates` pour classer chaque avis comme `’full moon’` ou `’not full moon’` :</p><pre>ON (TO_DATE(r.review_date) = DATEADD(DAY, 1, fm.full_moon_date))</pre><p>Le `DATEADD(DAY, 1, …)` reflète l’hypothèse métier : le supposé effet de la pleine lune se ferait sentir le lendemain, et non le jour exact.</p><h3>6. SCD Types — les quatre stratégies</h3><p>Les Slowly Changing Dimensions résolvent la question du suivi des changements dimensionnels dans le temps. J’ai implémenté les quatre stratégies classiques sur `dim_listings` :</p><p>- Type 1 (Overwrite) : écrase la valeur. Aucun historique. Bon uniquement pour l’état actuel.</p><p>- Type 2 (Add New Row) : une nouvelle ligne par changement, avec `valid_from` / `valid_to` / `is_current`. Répond à toute question point-in-time. Alimentée par le snapshot.</p><p>- Type 3 (Add New Column) : conserve uniquement la valeur précédente (`previous_price`, `current_price`) avec un indicateur `price_has_changed`. Une ligne par listing.</p><p>- Type 4 (History Table) : se divise en dimension actuelle (légère, rapide) + une table d’historique séparée. Le meilleur compromis entre performance et auditabilité.</p><h3>7. Snapshots — SCD Type 2 natif</h3><p>Les snapshots lisent directement depuis les sources et enregistrent chaque version, en ajoutant `dbt_scd_id`, `dbt_valid_from`, `dbt_valid_to` et `dbt_updated_at`. J’ai utilisé la stratégie `timestamp`, mais le détail décisif était :</p><pre>hard_deletes: invalidate</pre><p>Sans cela, une annonce supprimée d’Airbnb resterait `is_current = TRUE` pour toujours — produisant silencieusement des données incorrectes. Avec `invalidate`, elle est correctement marquée comme invalide.</p><h3>8. Seeds</h3><p>`seed_full_moon_dates.csv` est versionné dans le dépôt lui-même. Pourquoi un seed et non une table ? Les dates de pleine lune sont des données de référence statiques, petites et déterministes. Les versionner garantit la reproductibilité dans n’importe quel environnement — dev, prod ou CI — sans dépendre d’un chargement externe.</p><h3>9. Macros — DRY en SQL</h3><p>Quatre macros Jinja réutilisables éliminent la logique répétée entre les modèles :</p><p>- `safe_divide(num, den)` — division qui renvoie `NULL` au lieu d’une erreur lorsque le dénominateur est 0.</p><p>- `is_weekend(date)` — `TRUE` pour samedi/dimanche. Utile pour l’analyse des schémas de réservation.</p><p>- `clean_whitespace(col)` — `TRIM` + réduction des espaces internes.</p><p>- `no_nulls_in_columns(model)` — génère du SQL qui renvoie les lignes ayant une colonne nulle.</p><p>L’avantage : si la logique de `safe_divide` change, je modifie un seul endroit et tous les modèles sont mis à jour au prochain `dbt compile`.</p><h3>10. Tests — quatre niveaux de confiance</h3><p>J’ai utilisé les quatre types de tests de dbt, chacun couvrant une couche différente :</p><p>- Schema tests → le contrat des données (`not_null`, `unique`, `relationships`).</p><p>- Singular test → une règle métier spécifique (`minimum_nights &gt;= 1`).</p><p>- Generic test personnalisé → j’ai créé un `positive_values` réutilisable sur n’importe quel modèle/colonne.</p><p>- Unit test → teste la logique de `mart_fullmoon_reviews` avec des données simulées, sans toucher à la base de données — validant que `DATEADD(DAY, 1, …)` fonctionne.</p><p>Les échecs sont stockés dans Snowflake lui-même (`store_failures: true`), ce qui me permet d’inspecter exactement quelles lignes ont échoué.</p><h3>11. Analyses</h3><p>`full_moon_no_sleep.sql` est une requête exploratoire qui agrège les avis par `is_full_moon` et `review_sentiment`. Elle n’est pas matérialisée — elle réside dans `analyses/`, participe au DAG (`ref()` fonctionne) et est versionnée. C’est la différence entre un notebook ad hoc et une requête auditable.</p><h3>Le résultat physique dans Snowflake</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/775/1*4p8W-aRGedk_CSQfeTKmvg.png" /></figure><p>L&#39;exécution de `dbt build` transforme les couches logiques en objets physiques : des tables pour les faits, les marts, les snapshots et les seeds ; des vues pour les dimensions « cleansed » ; et un schéma d’audit séparé (`DEV_DBT_TEST__AUDIT`) contenant les échecs de tests persistés. Les couches `src`, étant ephemeral, ne génèrent aucun objet — exactement comme prévu.</p><h3>Leçons apprises</h3><p>Construire comme si c’était de la production — même dans un projet de portfolio — change tout. Les contrats détectent les breaking changes avant qu’ils n’atteignent la consommation. Les tests donnent la confiance nécessaire pour refactoriser. Les macros éliminent la répétition. Et l’architecture en couches rend le pipeline maintenable, et pas seulement fonctionnel.</p><p>Le code complet est sur mon <a href="https://github.com/andreretorta/airbnb-dbt-project">GitHub</a>. Vos retours sont les bienvenus !</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1fa3e020dde3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Un pipeline analítico completo con dbt y Snowflake]]></title>
            <link>https://medium.com/@andreretorta046/un-pipeline-anal%C3%ADtico-completo-con-dbt-y-snowflake-674aaabc1f5c?source=rss-e3e3b218dbe4------2</link>
            <guid isPermaLink="false">https://medium.com/p/674aaabc1f5c</guid>
            <category><![CDATA[snowflake]]></category>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[analytics-engineering]]></category>
            <category><![CDATA[dbt]]></category>
            <category><![CDATA[data-engineering]]></category>
            <dc:creator><![CDATA[Andreretorta]]></dc:creator>
            <pubDate>Tue, 16 Jun 2026 09:55:50 GMT</pubDate>
            <atom:updated>2026-06-16T09:55:50.845Z</atom:updated>
            <content:encoded><![CDATA[<p>Este proyecto nació de una pregunta simple: ¿cómo sería construir un pipeline de datos de extremo a extremo, desde el dato crudo hasta la capa lista para análisis? Para responderla, usé un conjunto de datos de Airbnb y fui aplicando, capa por capa, conceptos que suelo ver mencionados, pero rara vez reunidos en un solo lugar: arquitectura en capas, contratos de datos, pruebas en cuatro niveles, seguimiento histórico con SCDs y macros para reutilizar lógica. A lo largo del artículo, muestro cómo cada pieza encaja y el razonamiento detrás de cada decisión.</p><p>Usé un conjunto de datos de Airbnb con tres fuentes — anuncios (`listings`), anfitriones (`hosts`) y reseñas (`reviews`) — sobre Snowflake como data warehouse y dbt como herramienta de transformación. En este artículo recorro cada aspecto del proyecto y explico por qué se tomó cada decisión.</p><h3>Visión general de la arquitectura</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*Hvt-R3Za7b9oPhXE_sslog.png" /></figure><p>El pipeline sigue el patrón ELT moderno. Cada capa tiene una única responsabilidad, lo que garantiza una propiedad clave: un cambio en la fuente de datos solo afecta a la capa `src`, protegiendo todos los modelos de negocio que están debajo.</p><h3>1. Fuentes de datos (`sources.yml`)</h3><p>Las tres fuentes viven en el esquema `RAW` de Snowflake. La fuente `reviews` tiene freshness configurada — se emite una advertencia si los datos quedan desactualizados por más de una hora:</p><pre>freshness:<br>warn_after: {count: 1, period: hour}</pre><p>Esto importa porque `fct_reviews` es incremental: datos que lleguen tarde a la fuente crearían huecos silenciosos en la tabla de hechos. El freshness convierte un error invisible en una alerta.</p><h3>2. La capa `src` — Staging (`ephemeral`)</h3><p>La capa `src` es la única que lee datos crudos vía `source()`. Estandariza nombres (`id → listing_id`, `date → review_date`, `comments → review_text`) y selecciona solo las columnas relevantes.</p><p>¿Por qué `ephemeral`? Los modelos ephemeral no crean objetos físicos en el warehouse — se compilan como CTEs inline en los modelos que los referencian. El resultado: cero tablas de staging innecesarias, menor costo de almacenamiento, y toda la modularidad del código preservada.</p><pre>raw_listings (source) → src_listings (CTE ephemeral) → dim_listings_cleansed (table)</pre><h3>3. La capa `dim` — Dimensiones</h3><p>Tres dimensiones, cada una con un propósito claro:</p><p>- `dim_listings_cleansed` — corrige `minimum_nights` (0 → 1) y convierte `price` de string a `NUMBER`.</p><p>- `dim_hosts_cleansed` — reemplaza nombres nulos por `’Anonymous’` y tiene un contrato de datos activo.</p><p>- `dim_listing_w_hosts` — dimensión desnormalizada (join de listings + hosts) que simplifica consultas analíticas.</p><p>Contrato de datos en `dim_hosts_cleansed`:</p><pre>config:<br>contract:<br>enforced: true</pre><p>Con `contract: enforced`, dbt valida en runtime que el esquema producido coincide exactamente con los tipos declarados. Si una migración de la fuente cambia un tipo silenciosamente, dbt falla antes de sobrescribir la tabla — protección contra breaking changes invisibles.</p><h3>4. La capa `fct` — Hechos (`incremental`)</h3><p>`fct_reviews` es la tabla de hechos de reseñas. En cada ejecución, solo se insertan los registros más nuevos que el máximo actual:</p><pre>{% if is_incremental() %}<br>AND review_date &gt; (SELECT MAX(review_date) FROM {{ this }})<br>{% endif %}</pre><p>¿Por qué incremental? La tabla de reseñas crece sin parar. Reprocesar todo el histórico en cada ejecución sería inviable en producción — tanto en tiempo como en costo de cómputo en Snowflake. También agregué `on_schema_change=’fail’`: si una columna aparece o desaparece en la fuente, dbt aborta en lugar de crear un esquema inconsistente entre registros antiguos y nuevos.</p><h3>5. La capa `mart` — Consumo (`table`)</h3><p>`mart_fullmoon_reviews` es la capa final para BI. Cruza `fct_reviews` con el seed `seed_full_moon_dates` para clasificar cada reseña como `’full moon’` o `’not full moon’`:</p><pre>ON (TO_DATE(r.review_date) = DATEADD(DAY, 1, fm.full_moon_date))</pre><p>El `DATEADD(DAY, 1, …)` refleja la hipótesis de negocio: el supuesto efecto de la luna llena se sentiría al día siguiente, no en la fecha exacta.</p><h3>6. SCD Types — las cuatro estrategias</h3><p>Las Slowly Changing Dimensions resuelven cómo rastrear cambios dimensionales a lo largo del tiempo. Implementé las cuatro estrategias clásicas sobre `dim_listings`:</p><p>- Type 1 (Overwrite): sobrescribe el valor. Sin histórico. Bueno solo para el estado actual.</p><p>- Type 2 (Add New Row): una fila nueva por cambio, con `valid_from` / `valid_to` / `is_current`. Responde cualquier pregunta point-in-time. Alimentada por el snapshot.</p><p>- Type 3 (Add New Column): mantiene solo el valor anterior (`previous_price`, `current_price`) con un flag `price_has_changed`. Una fila por listing.</p><p>- Type 4 (History Table): se divide en dimensión actual (ligera, rápida) + una tabla de historial separada. El mejor equilibrio entre rendimiento y auditabilidad.</p><h3>7. Snapshots — SCD Type 2 nativo</h3><p>Los snapshots leen directamente de las fuentes y registran cada versión, agregando `dbt_scd_id`, `dbt_valid_from`, `dbt_valid_to` y `dbt_updated_at`. Usé la estrategia `timestamp`, pero el detalle decisivo fue:</p><pre>hard_deletes: invalidate</pre><p>Sin esto, un anuncio eliminado de Airbnb permanecería como `is_current = TRUE` para siempre — generando datos incorrectos de forma silenciosa. Con `invalidate`, se marca correctamente como inválido.</p><h3>8. Seeds</h3><p>`seed_full_moon_dates.csv` está versionado en el propio repositorio. ¿Por qué un seed y no una tabla? Las fechas de luna llena son datos de referencia estáticos, pequeños y deterministas. Versionarlos garantiza reproducibilidad en cualquier entorno — dev, prod o CI — sin depender de una carga externa.</p><h3>9. Macros — DRY en SQL</h3><p>Cuatro macros Jinja reutilizables eliminan la lógica repetida entre modelos:</p><p>- `safe_divide(num, den)` — división que devuelve `NULL` en vez de error cuando el denominador es 0.</p><p>- `is_weekend(date)` — `TRUE` para sábado/domingo. Útil para análisis de patrones de reserva.</p><p>- `clean_whitespace(col)` — `TRIM` + colapso de espacios internos.</p><p>- `no_nulls_in_columns(model)` — genera SQL que devuelve filas con cualquier columna nula.</p><p>La ventaja: si cambia la lógica de `safe_divide`, edito un solo lugar y todos los modelos se actualizan en el próximo `dbt compile`.</p><h3>10. Pruebas — cuatro niveles de confianza</h3><p>Usé los cuatro tipos de prueba de dbt, cada uno cubriendo una capa diferente:</p><p>- Schema tests → el contrato de los datos (`not_null`, `unique`, `relationships`).</p><p>- Singular test → una regla de negocio específica (`minimum_nights &gt;= 1`).</p><p>- Generic test personalizado → creé un `positive_values` reutilizable en cualquier modelo/columna.</p><p>- Unit test → prueba la lógica de `mart_fullmoon_reviews` con datos simulados, sin tocar la base de datos — validando que `DATEADD(DAY, 1, …)` funciona.</p><p>Los fallos se almacenan dentro del propio Snowflake (`store_failures: true`), así puedo inspeccionar exactamente qué registros fallaron.</p><h3>11. Analyses</h3><p>`full_moon_no_sleep.sql` es una consulta exploratoria que agrega reseñas por `is_full_moon` y `review_sentiment`. No se materializa — vive en `analyses/`, participa en el DAG (`ref()` funciona) y está versionada. Esa es la diferencia entre un notebook ad-hoc y una consulta auditable.</p><h3>El resultado físico en Snowflake</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/775/1*4p8W-aRGedk_CSQfeTKmvg.png" /></figure><p>Al ejecutar `dbt build`, las capas lógicas se convierten en objetos físicos: tablas para hechos, marts, snapshots y seeds; vistas para las dimensiones “cleansed”; y un esquema de auditoría separado (`DEV_DBT_TEST__AUDIT`) con los fallos de prueba persistidos. Las capas `src`, al ser ephemeral, no generan ningún objeto — exactamente como se diseñó.</p><h3>Lecciones aprendidas</h3><p>Construir como si fuera producción — incluso en un proyecto de portafolio — lo cambia todo. Los contratos detectan breaking changes antes de que lleguen al consumo. Las pruebas dan la confianza para refactorizar. Las macros eliminan la repetición. Y la arquitectura en capas hace el pipeline mantenible, no solo funcional.</p><p>El código completo está en mi <a href="https://github.com/andreretorta/airbnb-dbt-project">GitHub</a>. ¡Los comentarios son muy bienvenidos!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=674aaabc1f5c" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>