<?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 Salma Amr on Medium]]></title>
        <description><![CDATA[Stories by Salma Amr on Medium]]></description>
        <link>https://medium.com/@salmaumr?source=rss-acf76ee62351------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*jp6GMkX4Ov7eWASow-DYhA.jpeg</url>
            <title>Stories by Salma Amr on Medium</title>
            <link>https://medium.com/@salmaumr?source=rss-acf76ee62351------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 08:03:40 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@salmaumr/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[Data Apps: From Local to Live in 10 Minutes]]></title>
            <link>https://medium.com/talabat-tech/data-apps-from-local-to-live-in-10-minutes-a886d5453c7?source=rss-acf76ee62351------2</link>
            <guid isPermaLink="false">https://medium.com/p/a886d5453c7</guid>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[streamlit]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[gcp]]></category>
            <dc:creator><![CDATA[Salma Amr]]></dc:creator>
            <pubDate>Mon, 04 Apr 2022 09:42:33 GMT</pubDate>
            <atom:updated>2022-04-04T09:42:33.569Z</atom:updated>
            <content:encoded><![CDATA[<p>In a typical Data Science workflow, it is quite common to build prototypes in the form of scripts (e.g. in Python). This applies to anything from analysis visualization tools to sophisticated algorithms or Machine Learning models. Prototype development takes a significant portion of Data Scientists’ time and effort. Hence, an easy way to deploy a prototype in a form of web apps is much needed. This would allow business users to interact with these models and analyses, collect feedback, and iterate, all before rushing into productization.</p><p>At Talabat, we have three common ways of bridging our data products to interface with the business and product teams:</p><ul><li>Data Apps</li><li>Tables on our Data Platform (facts, dimensions, aggregates …)</li><li>Direct integration with Engineering services (S3, GCS, API …)</li></ul><p>This post explains how the Talabat Machine Learning Ops team built this simple yet elegant pipeline that brings our Machine Learning models and analyses live in a few minutes with the least possible effort required by Data Scientists. This is made possible by turning their scripts into shareable web apps to be exposed and used by all business owners. Let’s explore how this can be done.</p><h3>Design Principles</h3><p>We’ve developed this approach with the following five principles in mind:</p><ul><li>Versatility: Can host any kind of application including public web applications, APIs, and webhooks as well as private internal micro-services, data transformations, background jobs, potentially triggered asynchronously by Pub/Sub events or Cloud Tasks.</li><li>Seamlessness: Has minimal development effort, smooth Data Scientists experience, and a seamless CI/CD process.</li><li>Consistency: Having consistent results across the development and production environments.</li><li>Scalability: Scaling up and down depending on the usage.</li><li>Security: Highly secure.</li></ul><h3>Tools</h3><p>We use the following tools in our approach:</p><ul><li><a href="https://docs.streamlit.io/"><strong>Streamlit</strong></a><strong>:</strong> An open-source Python framework for building web apps for Machine Learning and Data Science. You can instantly develop web apps and deploy them easily using Streamlit. Streamlit allows you to create an app the same way you write a Python script. Streamlit makes it seamless to work on the interactive loop of coding and viewing results in the web app. You can definitely use other frameworks that develop python-based web apps, for example, <a href="https://github.com/gradio-app/gradio">gardio</a> which gained popularity in 2021. You can also use <a href="https://plotly.com/dash/">Dash</a> or <a href="https://ipywidgets.readthedocs.io/en/latest/">ipywidgets</a>. Streamlit combined the best of both worlds of having more control yet being easy to develop in general, especially the UI.</li><li><a href="https://www.docker.com/"><strong>Docker</strong></a><strong>:</strong> Builds container images to be deployed at scale.</li><li><a href="https://cloud.google.com/run"><strong>Cloud Run</strong></a><strong>: </strong>A managed serverless compute platform provided by GCP that enables you to run containers that are invocable via requests or events, and abstracts away all infrastructure management. Our Data infrastructure is mainly built on top of Google Cloud Platform (GCP). You can use your own server to host your app.</li></ul><h3>End-to-end Flow</h3><p>To have a seamless app hosting experience, that minimized overhead on our end-users, i.e. Data Scientists, we designed the following process. The first two steps are straightforward and the only ones that need to be done by the user:</p><ul><li><strong>Create</strong> a GitHub repo following a specific structure (more details below).</li><li><strong>Push</strong> the app code merging with the branch designated for deployment.</li></ul><p>This triggers the pipeline which then automatically:</p><ul><li><strong>Dockerizes</strong> the app and pushes the latest container image to the container registry.</li><li><strong>Transfers</strong> dependent data files (if any).</li><li>Finally, <strong>deploys</strong> the app on cloud run.</li></ul><p>Voila, the app gets deployed on a secured load-balancer and a few minutes later it can be accessed through a given URL, which we then add Apps Directory Portal, to be accessed by relevant stakeholders. Below is the high-level solution architecture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ETt4oNfBhLPwZ79tsEsEdA.png" /><figcaption>Data Apps high-level solution architecture of the pipeline flow</figcaption></figure><p>Let’s dig deeper into each component separately.</p><h4>1. Application Development</h4><p>The first step is the actual development of the application itself. Every app has its own logic and code resting in a separate GitHub repository. It is important that we keep the same repo structure among all of our Data Apps GitHub repositories, following the best practices of coding and documentation. This makes it easy for anyone to debug the application. Below is our repo structure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/255/1*JhEVhvwuVrEbi048DGw1hQ.png" /><figcaption>Data Apps repo structure</figcaption></figure><h4>2. Application Dockerization</h4><p>To proceed with Dockerizing the application, note that the Dockerfile must have the following steps:</p><p><strong>1. Define the base image with FROM</strong></p><p>Every Dockerfile must start with the FROM instruction. We need a starting point to build the image. We can start FROM scratch, where <em>scratch</em> is an explicitly empty image on the Docker store that is used to build base images like Alpine, Debian, etc. We can start Docker images from any valid image pulled from public registries. The image we start from is called the base image. In our case let’s add <strong>FROM python:3.7</strong> to our Dockerfile.</p><p><strong>2. Install image tools and set app environment</strong></p><p>Adding any dependencies to be installed, updating all app or system required tools (such as Python), seting the time zone, adding user and set permissions:</p><ul><li>Install python dependencies from requirements.txt file.</li><li>Add any environment variables needed.</li><li>Specifying run.sh which runs the app inside the container.</li></ul><p>The sample Dockerfile below describes the build steps of the environment mentioned above, to build the image from the Dockerfile and start up the containers.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c123d1475e4055166a1ca76a11eb7317/href">https://medium.com/media/c123d1475e4055166a1ca76a11eb7317/href</a></iframe><p>Then we can launch the Docker container using the following command:</p><pre>streamlit run --server.baseUrlPath /apps --server.enableCORS=false app.py</pre><p>More on building your own Dockerfile can be found <a href="https://takacsmark.com/dockerfile-tutorial-by-example-dockerfile-best-practices-2018/#dockerfile-example">here</a>.</p><h4>3. CI/CD Configuration</h4><p>A CI/CD pipeline is a series of steps that must be performed to automate the delivery of a new version of software. There are tools available to setup a CI/CD process e.g. CircleCI. Feel free to pick whatever you feel comfortable with. In our case, we chose <a href="https://cloud.google.com/functions/docs/concepts/events-triggers">Cloud Trigger</a>.</p><p>To set up the CI/CD pipeline, we need to:</p><ol><li>Create the trigger action event on GCP.</li><li>Add the config file cloudbuild.yaml to the repo.</li></ol><p>At Talabat, we manage our infrastructure using Terraform but for completeness, we will show how to create the trigger from the UI.</p><p>This can be done from the Cloud Build UI in the relevant GCP project, as per the screenshots below, by specifying the trigger name, description, branch name, and any possible environment variable to be resolved from within cloudbuild.yaml. Cloud Build provides default variables substitutions which can be found <a href="https://cloud.google.com/build/docs/configuring-builds/substitute-variable-values?authuser=1&amp;_ga=2.90958424.-396596194.1614636884">here</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JTMGtkrlpb-Q64_l4hGXZQ.png" /><figcaption>Trigger event config part 1</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BP1EVvHMKu-gRb_K_geW9Q.png" /><figcaption>Tigger event config part 2</figcaption></figure><p>As for cloudbuild.yaml:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ed18b4cbe7c597ab830c644168ae43c2/href">https://medium.com/media/ed18b4cbe7c597ab830c644168ae43c2/href</a></iframe><p>This executes four main steps:</p><ol><li>Transfers the data to a storage bucket. Cloud Run also supports CloudSQL, in case data operations get heavier.</li><li>Builds the container image using the Dockerfile.</li><li>Pushes the image in Google container registry.</li><li>Pushes the new app revision by deploying the image to Cloud Run.</li></ol><blockquote>Note: It’s important to grant the Cloud Run app service account permission to access the created storage bucket. When using the default account, it will use an account that looks like this:<br><a href="/service/mailto:598981094185-compute@developer.gserviceaccount.com">012345678901-compute@developer.gserviceaccount.com</a></blockquote><p>Once we’re done creating the trigger event and pushing cloudbuild.yaml to the repo, we can easily deploy new docker revisions of the app itself to Google container registry by simply merging the development feature branch to master.</p><p>We’ve generalized this pipeline to be our default way of hosting apps at Talabat. We have our own portal that lists a directory of all our data apps.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yThdf9gj4CgEpLTv2qRltg.png" /><figcaption>Talabat Data Apps directory</figcaption></figure><h3>Acknowledgments</h3><p>This process has proven to be very effective in enabling our Data Scientists to deliver their Data Products seamlessly. Thanks to <a href="https://www.linkedin.com/in/edzo-b-8a2338102/">Edzo</a> for the development efforts behind this approach and for <a href="https://www.linkedin.com/in/fadi-nader/">Fadi</a> for being an early tester and adopter.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a886d5453c7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/talabat-tech/data-apps-from-local-to-live-in-10-minutes-a886d5453c7">Data Apps: From Local to Live in 10 Minutes</a> was originally published in <a href="https://medium.com/talabat-tech">talabat Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A step-by-step guide deploying Amundsen on Google Cloud Platform]]></title>
            <link>https://medium.com/talabat-tech/a-step-by-step-guide-deploying-amundsen-on-google-cloud-platform-ee4ef20d81f5?source=rss-acf76ee62351------2</link>
            <guid isPermaLink="false">https://medium.com/p/ee4ef20d81f5</guid>
            <category><![CDATA[metadata]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[google-cloud-platform]]></category>
            <category><![CDATA[amundsen]]></category>
            <dc:creator><![CDATA[Salma Amr]]></dc:creator>
            <pubDate>Tue, 03 Nov 2020 10:11:00 GMT</pubDate>
            <atom:updated>2020-11-03T10:11:00.282Z</atom:updated>
            <content:encoded><![CDATA[<h3>What is Amundsen?</h3><p>Amundsen is Lyft’s Data Discovery Platform and metadata engine. In 2019, Lyft officially announced they are open sourcing Amundsen <a href="http://amundsen/">https://github.com/lyft/amundsen</a>. It is named after Roald Amundsen, a Norwegian explorer and the first person to discover the South Pole.</p><p>Think of it as the “Google Search” for data in your organization. It powers page-rank style search, leveraging usage patterns. For example: highly queried tables show up earlier than less queried tables.</p><p>It works by indexing all different data sources, dashboards and streams; ranking results based on relevance and query activity. It keeps track of the most up-to-date definition of every feature/table/set, and therefore improves the productivity and efficiency of all data platform users all over the organization, not just the data scientist.</p><h3>Why Amundsen?</h3><p>There are two main questions often asked within every data team:</p><p><strong><em>Where</em></strong><em> is this data source?<br></em><strong><em>What</em></strong><em> does this field mean?</em></p><p>Data Scientists spend lots of time in the “Data Discovery” phase; trying to understand what data exists, where it resides, who owns it, who uses it, and how to request access. Amdunsen helps the data team to be more productive by saving time spent in the discovery phase — less time searching, more time finding.</p><h3>Challenges to solve</h3><p>Think of all the different and various projects in which you have encountered:</p><ul><li>Different data sources</li><li>You can’t fit all the data in one single model; a data resource could be a table, dashboard, Airflow DAG</li><li>Every data source is being extracted differently; each data set metadata is stored and fetched differently</li></ul><p>These are the types of challenges we were facing and so needed to find a solution to resolve them all.</p><h3>Amundsen Architecture</h3><p>Amundsen is built on top of <strong>five</strong> different micro-services and each needs to be deployed/maintained separately.</p><ol><li><strong>Frontend</strong> <strong>service</strong>: The frontend service serves as web UI portal for users to interact with. It is a Flask-based web app with a representation layer, built with React with Redux, Bootstrap, Webpack, and Babel.</li><li><strong>Metadata</strong> <strong>service</strong>: A thin proxy layer to interact with the graph database; currently Neo4j is the default option for the graph backend engine. After being open-sourced there has been community collaboration to support Apache Atlas. Also, it supports REST APIs for other services to push or pull metadata directly</li><li><strong>Neo4j: </strong>a graphical backend server that saves all metadata extracted from different sources. The metadata is represented as a graph model.</li><li><strong>Databuilder</strong>: Amundsen provides a data ingestion library for building the metadata and uses Apache Airflow to orchestrate Databuilder jobs.</li><li><strong>Search</strong> <strong>service</strong>: A thin proxy layer to interact with the search backend functionality (or Apache Atlas’s search API, if that’s the backend you picked) and provides a RESTful API to serve search requests from the frontend service. Supports different search patterns:</li></ol><ul><li><em>Normal Search:</em> match records based on relevancy.</li><li><em>Category Search:</em> match records first based on data type, then relevancy.</li><li><em>Wildcard Search:</em> run a search with missing words.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cST9Kqg1s47sWE-kaaiayQ.png" /><figcaption>Amundsen’s architecture</figcaption></figure><p>It provides a huge amount of flexibility and several ways of deployment, and since part of the appeal of Amundsen is its flexibility, there’s no one ‘right way’ to install it.</p><h3>Setup Guide</h3><p>After thinking of different approaches and trying out several of them I am going to demonstrate an easy way to deploy Amundsen using it’s default settings, on a GCP cloud machine (you can use linux as well!) and then build an Airflow DAG that orchestrates updating the metadata from different sources.</p><h3>Setup overview</h3><p>This guide assumes you have both Airflow on a google composer environment and a GCP machine up and running.</p><p>Our setup went as follows:</p><ol><li>Wrap four of the services in one <a href="https://github.com/SalmaAmrAhmed/amundsen-metadata-extractor/blob/main/dependencies/docker-amundsen.yml">docker-compose</a> file to be able to install it all at once, on one machine instead of installing and maintaining each service independently.</li><li>Install this docker-compose file on GCP.</li><li>Verify the installation of <strong>five</strong> docker images, each image holds one of the main micro-services (frontend, metadata, neo4j, search, elastic search).</li><li>Build the metadata DAG file extractor and orchestrate it using airflow.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/811/1*ek20bRLpN8DXWC4yCD0JDg.png" /><figcaption>Our deploying setup of Amundsen at Talabat</figcaption></figure><h3>How to install Amundsen’s default version on GCP?</h3><ol><li>Make sure that docker is installed on the machine.</li><li>On the cmd prompt, head to the target directory you want to install Amundsen in and clone the repo together with it’s sub-modules by running the following:<br>$ git clone --recursive git@github.com:amundsen-io/amundsen.git</li><li>Enter the cloned directory and run:<br>$ docker-compose -f docker-amundsen.yml up</li></ol><p>The later cmd installs and runs <strong>five</strong> docker images using the default settings of each container, each image holds one of the main micro-services that Amundsen use. To verify that all five images are being installed and working correctly, run:<br>$ docker ps</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uL_QU2nrXZsuG8SCxvEpig.png" /><figcaption>Five docker images for each service</figcaption></figure><p><strong>Troubleshooting:</strong></p><p>In some cases, the docker container might not have enough heap memory for Elastic Search, thus “es_amundsen”, the elastic search component, will fail during docker-compose. To fix it, you’ll need to increase the memory.</p><p>The error:</p><pre>es_amundsen | [1]: max virtual memory areas vm.max_map_count [65530] is too low, increase to at least [262144]</pre><p>To solve it:</p><ol><li>Edit file “/etc/sysctl.conf”</li><li>Make entry “vm.max_map_count=262144”. Save and exit.</li><li>Reload settings “$ sysctl -p”</li><li>Restart “docker-compose”</li></ol><p>Generally, for any issues:</p><ul><li>Check if all 5 Amundsen related containers are running with “docker ps”</li><li>Can you connect to the Neo4j UI at <br><a href="http://localhost:7474/browser/">http://{{machine ip address}}:7474/browser/</a> and the raw ES API at <a href="http://localhost:9200/">http://{{machine ip address}}:9200</a>?</li><li>Do Docker logs reveal any serious issues?</li></ul><h3>Setup Verification</h3><h3>Amundsen databuilder/Neo4j service</h3><p>You can verify dummy data has been ingested into Neo4j by by visiting</p><p><a href="http://localhost:7474/browser/">http:/</a><a href="http://localhost:9200/">{{machine ip address}}</a><a href="http://localhost:7474/browser/">:7474/browser/</a> and in the query box run:</p><pre>MATCH(n:Table) RETURN n LIMIT 25</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eu1MxrdGjqYX5_M4FbVTvA.png" /><figcaption>Snippet of Neo4j (graphical database) interface up and running</figcaption></figure><h3>Amundsen metadata service</h3><p>In a different terminal, verify getting HTTP/1.0 200 OK</p><pre>$ curl -v &lt;http://{{machine ip address}}:5002/healthcheck&gt;</pre><h3>Amundsen frontend service</h3><p>You can verify the data has been loaded into the metadataservice by hitting</p><p><a href="http://localhost:5000/">http://{{machine ip address}}:5000/</a> in your browser.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3s7j15eeKqecIeJ5RvZ8oA.png" /><figcaption>Snippet of Amundsen’s frontend service</figcaption></figure><h3>Airflow environment setup</h3><p>Now, let’s use amundsendatabuilder library for building our metadata graph and search index. First, let’s run our data-ingestion example using an airflow DAG. You’ll have to install some extra PYPI packages on your air-flow environment. This <a href="https://github.com/SalmaAmrAhmed/amundsen-metadata-extractor/blob/main/dependencies/requirements.txt">requirements.txt</a> holds all dependencies needed.</p><pre>$ pip3 install -r requirements.txt</pre><p>If you are hosting airflow on google composer; in your gcloud console type:</p><pre>gcloud composer environments update {{environment name}} --location={{machine location}} --update-pypi-packages-from-file={{.../amundsen/amundsendatabuilder/requirements.txt}} --project={{project name}}</pre><h3>Airflow DAG definition</h3><p>This DAG example fetches dataset schemas, tables, columns, descriptions, labels and pretty much all related metadata available from a <strong>Google Bigquery</strong> meta store, then publishes this metadata to Neo4j. It saves the data in two .csv files; one holding the nodes, and the other holding the relationships between the nodes.</p><p>If you are pulling data from various sources, each distinct metadata source should be fetched through a different databuilder job. Each databuilder job will be an individual task within the DAG. Each type of data resource will have a separate DAG since it may have to run with a different schedule.</p><ul><li>Step 1: Define imports, DAG arguments and setup config.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d6c36c9ca0568db69ac70ae6dc428c04/href">https://medium.com/media/d6c36c9ca0568db69ac70ae6dc428c04/href</a></iframe><ul><li>Step 2: Create bigquery tables extraction job using <br>BigQueryMetaDataExtractor()</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fc0400d8829e7cae04850756f9e58183/href">https://medium.com/media/fc0400d8829e7cae04850756f9e58183/href</a></iframe><ul><li>Step 3: Create the index job that updates the graph index after every new data pull</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/039f0b229a7260990c8c91f1cd8c8995/href">https://medium.com/media/039f0b229a7260990c8c91f1cd8c8995/href</a></iframe><ul><li>Step 4: Create the publisher function job which is called several times updating tables, users, and dashboard indexes; depending on the passed arguments “kwargs”</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1704dbf1d6fd5cf701ec957b33ff42fd/href">https://medium.com/media/1704dbf1d6fd5cf701ec957b33ff42fd/href</a></iframe><ul><li>Step 5: Finally, define and call the DAG routine</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4d925324efe50b4d00cdf27793d4598f/href">https://medium.com/media/4d925324efe50b4d00cdf27793d4598f/href</a></iframe><p>Below, is the graph view of the defined DAG. You’ll notice how the function “create_es_publisher_sample_job” is called three times in the DAG routine, creating a different indexing job according to the passed arguments.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YxXbvJdLTbNac_XtCwqcPA.png" /><figcaption>Complete DAG</figcaption></figure><p>You can find the complete code <a href="https://github.com/SalmaAmrAhmed/amundsen-metadata-extractor/blob/main/dags/bigquery_data_loader_dag.py">here</a>.</p><h3>Running From a Python Script</h3><p>In the previous example, I showed how to use Airflow to update the metadata, you can also use a <a href="https://github.com/SalmaAmrAhmed/amundsen-metadata-extractor/blob/main/python-extractor/bigquery_data_loader.py">python script</a> that does the same purpose and update it regularly by registering it on a cron job. Make sure to set your credentials if your application runs outside Google Cloud environments. More about authentication <a href="https://cloud.google.com/docs/authentication/getting-started">here</a>.</p><h3>Final thoughts</h3><p>In my next post, I am going to show how to customize Amundsen and will show some of the awesome hidden features and how to leverage them. Making it more configurable means you’ll need to deploy and maintain each micro-service independently, in which we’ll do in an easy way too!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ee4ef20d81f5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/talabat-tech/a-step-by-step-guide-deploying-amundsen-on-google-cloud-platform-ee4ef20d81f5">A step-by-step guide deploying Amundsen on Google Cloud Platform</a> was originally published in <a href="https://medium.com/talabat-tech">talabat Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>