<?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 Ankur Dahiya on Medium]]></title>
        <description><![CDATA[Stories by Ankur Dahiya on Medium]]></description>
        <link>https://medium.com/@ankurd?source=rss-47fdf5b021e0------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*CFnPOOuBWx216JPcTjaGpw.png</url>
            <title>Stories by Ankur Dahiya on Medium</title>
            <link>https://medium.com/@ankurd?source=rss-47fdf5b021e0------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 23:37:32 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ankurd/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[Fastest way to deploy a Static Web Application to AWS]]></title>
            <link>https://blog.runx.dev/fastest-way-to-deploy-a-static-web-application-to-aws-e2c760c512ae?source=rss-47fdf5b021e0------2</link>
            <guid isPermaLink="false">https://medium.com/p/e2c760c512ae</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[cdn]]></category>
            <category><![CDATA[scaling]]></category>
            <dc:creator><![CDATA[Ankur Dahiya]]></dc:creator>
            <pubDate>Mon, 03 Jan 2022 23:34:49 GMT</pubDate>
            <atom:updated>2022-01-03T23:34:49.193Z</atom:updated>
            <content:encoded><![CDATA[<p>Static Web Applications are really popular these days but deploying them can still be a challenge. The user needs to ensure scaling, distribution, object storage, SSL and zero downtime deployment. This can be achieved on AWS using S3, Cloudfront and Route53, but they all require proper configuration.</p><p>In this post, I’d like to demonstrate how we can simplify this process by using the open source project <a href="https://github.com/run-x/opta">Opta</a>.</p><p>Opta is an Infrastructure as Code framework where a user specifies their needs at a high level of abstraction and Opta generates the terraform/helm required to achieve these goals. With Opta, users don’t need to be Cloud/Infrastructure experts as it includes robust, production-ready modules for most cloud services and enables the users to quickly compose their ideal Infrastructure stack.</p><p>We will be creating a production-ready Static Web Application setup — in less than 10 minutes!</p><h3>Architecture</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mZVNUD7oyFR9abMfC9CrpA.png" /></figure><p>As described above, our users will hit Cloudfront which will fetch the assets from S3. For our deployment target, we’ll be using this <a href="https://github.com/gabrielecirulli/2048">fun 2048 clone</a>!</p><h3>Opta Configuration</h3><p>First, let’s check out the 2048 project:</p><pre>git clone <a href="https://github.com/gabrielecirulli/2048.git">https://github.com/gabrielecirulli/2048.git</a></pre><p>You control Opta by writing yaml configuration files. For this particular example, we need a Cloudfront and an S3 module. So create the following file and name it opta.yaml</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/37947fb7fa956a9b9ace18771ea0e500/href">https://medium.com/media/37947fb7fa956a9b9ace18771ea0e500/href</a></iframe><blockquote>Make sure you use the correct path to the checked out 2048 codebase.</blockquote><p>Note how simple it is in Opta to set up Cloudfront and S3. An equivalent setup in the AWS console or via Terraform might take hours!</p><p>Once this file is ready, we can install Opta and run apply.</p><p><strong>Installation</strong>:</p><pre>/bin/bash -c &quot;<strong>$(</strong>curl -fsSL https://docs.opta.dev/install.sh<strong>)</strong>&quot;</pre><p><a href="https://docs.opta.dev/installation/">More detailed instructions</a>.</p><p><strong>Apply</strong>:</p><pre>opta apply -c opta.yaml</pre><p>That’s all! You can get the cloudfront_domain by running opta output and the website should be visible there!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jZBN5CN_S8ik2FWy22qxTw.png" /><figcaption>opta output</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-TqAiXZw12jWdQWzNd5CXQ.png" /><figcaption>End result in the browser</figcaption></figure><h3><strong>Adding a domain</strong></h3><p>To add Domain + SSL to this setup, you need to follow a few more steps:</p><ol><li><a href="https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html">Request a certificate in ACM</a> for the domain name. We are using 2048.runx.dev but you can pick any domain that you own.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3rm4bH_hD4MVp4gavP1_Ig.png" /></figure><p>2. Follow the instructions given by ACM to verify domain ownership by creating a CNAME record. (<a href="https://support.google.com/a/answer/47283">Instructions for Google domains</a>)</p><p>3. Update opta.yaml to specify the Certificate ARN and the domain name.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0d7d0da8532a1379dc35fb4aaf74947a/href">https://medium.com/media/0d7d0da8532a1379dc35fb4aaf74947a/href</a></iframe><p>4. Add a CNAME record to make your domain (2048.runx.dev) point to the cloudfront_domain (the one you get via opta output). (<a href="https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resource-record-sets-creating.html">Instructions for Route53</a>)</p><p>That’s all! Now your website should be available at the domain name!</p><h3>What’s next</h3><p>This was a quick overview of how we can use <a href="https://github.com/run-x/opta/">Opta</a> to deploy a Static Web Application to AWS. We were able to get a robust production-ready environment set up with minimal work!</p><p>Make sure to check out the <a href="https://docs.opta.dev/reference/aws/service_modules/cloudfront-distribution/">docs</a> for further configuration.</p><p>Opta can do a lot more than this! Check out these <a href="https://github.com/run-x/opta-examples">examples</a> or the <a href="https://docs.opta.dev/">docs website</a>. If you run into any problems or have suggestions for what else you’d like to use Opta for, please let us know in the comments or in our <a href="https://slack.opta.dev/">slack</a> :))</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e2c760c512ae" width="1" height="1" alt=""><hr><p><a href="https://blog.runx.dev/fastest-way-to-deploy-a-static-web-application-to-aws-e2c760c512ae">Fastest way to deploy a Static Web Application to AWS</a> was originally published in <a href="https://blog.runx.dev/">Run[X]</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Infrastructure as Code — for everyone]]></title>
            <link>https://blog.runx.dev/infrastructure-as-code-for-everyone-7dad6b813cbc?source=rss-47fdf5b021e0------2</link>
            <guid isPermaLink="false">https://medium.com/p/7dad6b813cbc</guid>
            <category><![CDATA[terraform]]></category>
            <category><![CDATA[infrastructure]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[infrastructure-as-code]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Ankur Dahiya]]></dc:creator>
            <pubDate>Mon, 08 Nov 2021 19:27:01 GMT</pubDate>
            <atom:updated>2021-11-08T19:27:01.995Z</atom:updated>
            <content:encoded><![CDATA[<h3>Infrastructure as Code — for everyone</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*rEcz3-pnnXVCn-vVe3SymA.png" /></figure><p>Today, every DevOps practitioner strongly recommends “Infrastructure as code” (IaC). It has rapidly become the standard for provisioning and managing Infrastructure and for the right reasons! But the leading IaC tools are still complicated to use and require deep Cloud/Infrastructure expertise. In this post, we’d like to introduce a new alternative — Opta. Opta is IaC, designed for everyone. It helps you run in the cloud with an automated, secure and scalable setup — but without becoming an Infrastructure expert yourself!</p><h3>Advantages of Infrastructure as Code</h3><p>With the recent explosion in Cloud complexity, it has become critical to have a better process in place than tweaking things in the AWS UI or with a series of terminal commands. That’s where IaC comes in.</p><p>IaC has a lot of advantages, primarily:</p><ul><li><strong>Auditability</strong>: Easily accessible trail of who changed what configurations.</li><li><strong>Repeatability</strong>: Ability to replicate changes from one environment (like staging) to another (like production). This makes it drastically easier to maintain environment consistency.</li><li><strong>Better security</strong>: Every configuration change can be code reviewed by multiple people and you can also run static analysis tools to validate security and compliance requirements.</li><li><strong>Fewer knowledge silos</strong>: Anyone can suggest configuration changes and it becomes easy for folks to share knowledge — as everything is written down in code.</li></ul><h3>Leading IaC tool — Terraform</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/377/1*AaNQuTLns9CKUaA26mcsfg.png" /></figure><p>As of 2021, the leading IaC platform is Terraform. It’s a very advanced piece of software and frankly an amazing innovation in Cloud development! But it is infamous for requiring deep Cloud/Infrastructure expertise and requires the users to do low level tasks like managing network CIDR or modifying route tables; even managing the Terraform state is a complicated beast. It’s akin to doing memory management manually in C!</p><p>It can be difficult to use Terraform effectively without ending up as a full time Terraform developer.</p><p>A lot of us have often wondered why there isn’t a “high level” counterpart to Terraform — where is the Python to Terraform’s C? Alternatives to Terraform exist but they require similar steep learning curves or lack the ability to deploy most real-world stacks.</p><p>That’s the question we at RunX have been exploring for the last one year — and Opta is the end result!</p><h3>Enter Opta</h3><p>Opta is a new kind of Infrastructure-As-Code framework where you work with high-level constructs instead of getting lost in low level cloud configuration. Imagine just being able to say that you want an autoscaling docker container that talks to a RDS database — instead of figuring out the details of VPC, IAM, Kubernetes, Elastic Load Balancing etc — that’s what Opta does! And best of all — it’s completely <a href="https://github.com/run-x/opta">Open Source</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/717/1*KvqUpt_5V1WvT3hqsuH8tw@2x.png" /></figure><p>In Opta, modules are a first class citizen. There are modules for all the common resources that one might need — like EKS, RDS, DynamoDB, GKE, Cloud SQL, etc and even third party services like Datadog. All these modules are designed by Infrastructure experts — so they follow all the best security practices and are production grade. Plus they are designed to work really well with each other. The end result is a “Build Your Own Infra Stack” framework — that works for everyone and not just Cloud/Infrastructure experts.</p><p>Opta is designed with the principle of Progressive Configurability in mind. It starts you off with sane defaults and 90% of users wouldn’t need to touch them. But for the other 10%, Opta allows you to dive deeper and tweak as many knobs as you need. Thus it gives you a platform that can scale as your needs get more complex.</p><p>Majority of Opta’s users are early stage startups who are using it for their dev, staging and production environments. These teams have been able to achieve so much with Opta over the last few months that it’s really mind blowing to see!</p><h3>Get started with Opta</h3><p>The best way to Get Started is join our <a href="https://slack.opta.dev/">slack</a> and say hi!</p><p>You can also check out the <a href="https://docs.opta.dev/getting-started/">Getting Started</a> guide or explore some <a href="https://github.com/run-x/opta/tree/main/examples">example deployments</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7dad6b813cbc" width="1" height="1" alt=""><hr><p><a href="https://blog.runx.dev/infrastructure-as-code-for-everyone-7dad6b813cbc">Infrastructure as Code — for everyone</a> was originally published in <a href="https://blog.runx.dev/">Run[X]</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fastest way to deploy Airflow to AWS or GCP]]></title>
            <link>https://blog.runx.dev/fastest-way-to-deploy-airflow-to-aws-or-gcp-e438d5ae2b98?source=rss-47fdf5b021e0------2</link>
            <guid isPermaLink="false">https://medium.com/p/e438d5ae2b98</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[gcp]]></category>
            <category><![CDATA[terraform]]></category>
            <dc:creator><![CDATA[Ankur Dahiya]]></dc:creator>
            <pubDate>Wed, 23 Jun 2021 21:01:30 GMT</pubDate>
            <atom:updated>2021-11-02T19:13:59.576Z</atom:updated>
            <content:encoded><![CDATA[<p><a href="https://airflow.apache.org/">Airflow</a> is one of the most popular tools for running workflows. It’s a really powerful software with a bunch of moving parts — which makes the production deployment complicated.</p><p>In this post, I’d like to demonstrate how we can simplify this process by using a new open source project called <a href="https://github.com/run-x/opta">Opta</a>. We will be creating a production-ready setup for Airflow — in under 30min!</p><p>About Opta: It is an infrastructure-as-code solution that aims to abstract away the complexity of cloud providers and Kubernetes — providing a clean cloud agnostic interface to deploy and run workloads.</p><p><em>Disclaimer: I’m one of the main people behind Opta but I’ll try to keep the bias to a minimum :)</em></p><h3>Airflow Architecture</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/730/1*6GtWbj9TEWuH0EVj0VuGQA.png" /></figure><p>This is the Airflow architecture that we’ll be trying to create (<a href="https://airflow.apache.org/docs/apache-airflow/stable/concepts/overview.html">relevant airflow docs</a>). There’s three types of pods that run inside Kubernetes and then there is a SQL database and a Redis instance (we’ll be using the underlying cloud services for these).</p><p>We’ll be using the <a href="https://github.com/apache/airflow/tree/main/chart">official Airflow chart</a> to configure the pods — and the rest will be set up by Opta.</p><h3>Why not Helm directly</h3><p>A brief aside on why we’re using Opta here — we already have the Airflow helm chart — don’t we?</p><p>Note that the helm chart only manages resources running inside Kubernetes. And we don’t want to run Postgres/Redis inside K8s as that’s not efficient/robust — the cloud services for these services are way more performant!</p><p>Additionally, we’d need to set up:</p><ul><li>Ingress to route traffic to the pods</li><li>Network configuration</li><li>Security groups</li><li>Kubernetes provisioning and configuration</li></ul><p>And we need to make sure this is all done securely so we don’t introduce unnecessary vulnerabilities! That’s why Opta is a good fit here — it sets up all these resources for us with a very robust <a href="https://docs.opta.dev/architecture/">architecture</a>.</p><h3>Opta configuration for Airflow</h3><p>To deploy airflow with Opta, we need to do 2 things:</p><ul><li>Set up the environment (this will set up Ingress, Kubernetes, Network etc)</li><li>Set up the Airflow “service” (this will create the Postgres and Redis resources and configure the Airflow helm chart)</li></ul><p>Opta is an infrastructure-as-code (..as-config?) solution. So the first step is to write a config file for the environment. Here’s the one we will be using:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/586b84249ebb7982f4114aab7b5a7de2/href">https://medium.com/media/586b84249ebb7982f4114aab7b5a7de2/href</a></iframe><p>Here we are selecting AWS as the cloud provider (we’ll look at GCP later in the article). Make sure to replace region and account— with the appropriate values.</p><p>Additionally, we are configuring some Opta modules — this is where the magic happens! More details about these can be found in the <a href="https://docs.opta.dev/modules-reference/environment-modules/aws/">docs</a>.</p><p>Once this file is ready, we can install Opta and run apply.</p><p><a href="https://docs.opta.dev/installation/">Installation</a>:</p><pre>/bin/bash -c &quot;<strong>$(</strong>curl -fsSL https://docs.opta.dev/install.sh<strong>)</strong>&quot;</pre><blockquote>Note that Opta is completely open source. So do check out the <a href="https://github.com/run-x/opta">code</a> first if you’re suspicious of running things from the internet (which you should be ;))</blockquote><p>Apply:</p><pre>opta apply --config &lt;filename&gt;</pre><p><strong>Next step</strong></p><p>Next is setting up the Airflow “service”. Again, we need to write a configuration file for it and then run Apply.</p><p>Here’s the file we’ll be using:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d92e9bb6d04c493708cd5c426a49c3d7/href">https://medium.com/media/d92e9bb6d04c493708cd5c426a49c3d7/href</a></iframe><p>We’re creating the Postgres DB (backed by <a href="https://aws.amazon.com/rds/">RDS</a>) and Redis (backed by <a href="https://aws.amazon.com/elasticache/">ElasticCache</a>). And then we’re instantiating the <a href="https://github.com/apache/airflow/tree/main/chart">Airflow helm chart</a>. Make sure to update the env file path (which we created in the previous step).</p><p>As you can see, Opta allows us to connect Postgres/Redis pretty seamlessly with the helm chart! The helm chart has quite a few <a href="https://airflow.apache.org/docs/helm-chart/stable/parameters-ref.html">configuration options</a> and Opta also supports a lot more <a href="https://docs.opta.dev/modules-reference/service-modules/aws/">resources</a>- so feel free to play around with this :)</p><p>Once the file is ready, we just need to run apply:</p><pre>opta apply --config &lt;filename&gt;</pre><p>Once Opta finishes, run opta output and note down load_balancer_raw_dns. Now you can access the airflow UI at http://&lt;load_balancer_raw_dns&gt; . The default username and password are admin and admin.</p><blockquote>To put this behind a domain name and use SSL, please follow the dns delegation steps <a href="https://docs.opta.dev/miscellaneous/ingress/">here</a>.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZofsCvthsQkz_8RJ.png" /></figure><blockquote>We can run a particular DAG by turning it on and then triggering a run. Then we can browse the logs for that run and make sure it ran successfully!</blockquote><h3>Debugging</h3><p>To debug things or explore the underlying containers, opta enables you to use <a href="https://kubernetes.io/docs/reference/kubectl/overview/">kubectl</a>.</p><p>Just run opta configure-kubectl and it will set up the appropriate config for kubectl. Now you can run kubectl get pods -n airflow to look at all the pods we are running and kubectl exec -it -n airflow pod/&lt;pod-name&gt; to ssh into a pod and explore the environment.</p><h3>Running on GCP</h3><p>Running this same example on GCP is pretty straightforward — as Opta is (mostly) cloud agnostic! We just need to update the env file to point to our GCP project and run apply.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/433e723a994aa26eb88b544c9496d77f/href">https://medium.com/media/433e723a994aa26eb88b544c9496d77f/href</a></iframe><p>The “service” yml file doesn’t need to be changed as it’s completely cloud agnostic! Note that Postgres will be provisioned via <a href="https://cloud.google.com/sql">Cloud SQL</a> and Redis via <a href="https://cloud.google.com/memorystore">Memorystore</a>.</p><h3>Running a custom DAG</h3><p>This example just enables the example DAGs that come with Airflow. To use a custom DAG, you’d need to <a href="https://airflow.apache.org/docs/docker-stack/build.html#dag-embedding-example">compile a docker image with your DAGs</a>, <a href="https://airflow.apache.org/docs/helm-chart/stable/parameters-ref.html#images">specify that in the opta yml</a> and run opta apply.</p><h3>What’s next</h3><p>This was a quick overview of how we can use <a href="https://github.com/run-x/opta/">Opta</a> to deploy Airflow to AWS or GCP. We were able to get a robust environment set up with minimal work!</p><p>All this code can be found on our <a href="https://github.com/run-x/opta/tree/main/examples">github</a>. Make sure to check out the <a href="https://airflow.apache.org/docs/helm-chart/stable/parameters-ref.html">Airflow docs</a> and the <a href="https://docs.opta.dev/">Opta docs</a> — for further configuration.</p><p>If you run into any problems or have suggestions for what else you’d like to use Opta for, please let us know in the comments or in our <a href="https://join.slack.com/t/opta-group/shared_invite/zt-r1p9k1iv-4MP1IMZCT9mwwwdJH0HRyA">slack</a> :))</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e438d5ae2b98" width="1" height="1" alt=""><hr><p><a href="https://blog.runx.dev/fastest-way-to-deploy-airflow-to-aws-or-gcp-e438d5ae2b98">Fastest way to deploy Airflow to AWS or GCP</a> was originally published in <a href="https://blog.runx.dev/">Run[X]</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Microservices Transition — why, what, how]]></title>
            <link>https://blog.runx.dev/microservices-transition-why-what-how-f78b856508ea?source=rss-47fdf5b021e0------2</link>
            <guid isPermaLink="false">https://medium.com/p/f78b856508ea</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[infrastructure]]></category>
            <dc:creator><![CDATA[Ankur Dahiya]]></dc:creator>
            <pubDate>Fri, 02 Apr 2021 17:52:40 GMT</pubDate>
            <atom:updated>2021-04-02T17:55:20.257Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Microservices Transition — why, what, how</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N1RKLcD75I3mqgDH4Mnofg.jpeg" /></figure><p>The Microservices architecture has become increasingly popular lately. Especially with the rise of Kubernetes, it has gained mainstream attention and a lot of organizations are weighing this transition as they run into scaling limits. In this post, we’ll try to summarize the current set of industry best practices that define the why/what/how of such a transition.</p><h3>Why do we need Microservices?</h3><p>As an application/codebase grows, it starts running into scaling challenges. Two different challenges, to be exact:</p><ul><li>Throughput scaling: Data models become complex, queries slow down, dependencies get intractable. All this leads to the application becoming clunky and slow — and throughput (requests per minute) starts leveling out.</li><li>Organizational scaling: For the same reasons described above, teams start getting intertwined and feature delivery slows down. Changes in one part of the codebase lead to errors in other unrelated parts. Additionally, teams can’t make the technology choices that are best for their needs. Everyone is tied to the codebase/framework decisions that were probably made years ago!</li></ul><p>These challenges can grow to become an existential threat for the organization. Customers start becoming dissatisfied with the performance problems and engineers start getting annoyed by the productivity obstacles. Therefore, it is critical to realize these signs and take decisive action — sooner rather than later.</p><h3>What are Microservices?</h3><p>The most recommended solution for the problems described above is (surprise surprise) Microservices Transition. Basically, the big/clunky application(s) should be broken up into smaller isolated pieces — which can be designed and scaled independently. Each team should focus on one (or maybe a few) service(s) for most of their work — that way they can deliver things on their own cadence and not be hampered by issues in other parts of the org.</p><p>There are a lot of considerations that need to be kept in mind while embarking on this transition. Bad decisions can plague the org for years to come and end up ameliorating the benefits or worse — create bigger problems than before. In the next section, we will try to cover some of the biggest ones.</p><h3>How to build a Microservices architecture?</h3><h4>Principles</h4><p>The organization should align on a set of guiding principles for this transition. These can be utilized whenever important architectural decisions need to be made and thus help evolve the architecture in a coherent manner.</p><ul><li>A service should be a <strong>logical independent component</strong> and ideally, each service should be owned by a single team (although a team could have multiple services).</li><li>The primary goal of this transition should be to <strong>provide teams autonomy</strong>. They should be able to control their own destiny while sharing the infrastructure substrate with the rest of the org.</li><li>It is important to <strong>empower the Platform/Infra team</strong> and clarify their responsibilities (primary one being the design of the substrate where all the Microservices will run).</li></ul><h4>Tooling</h4><p>It’s really important to pick a coherent toolset early and get the whole organization to adopt it. Otherwise, teams will be reinventing the wheel every time they run into these standard issues.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*_4Dm37AQMio5KQQg6xQRxQ.png" /></figure><ul><li>Workload Orchestration: The most popular options these days are Serverless and Containerization (it’s possible to mix and match!).</li><li>For Serverless, we recommend the excellent <a href="https://www.serverless.com/">serverless</a> framework.</li><li>For containers, the recommended options are ECS or Kubernetes or Nomad (Kubernetes being the most popular). Support systems like service mesh and Ingress also need to be set up — as they provide a lot of critical features. (We’re going to cover these in future blog posts!)</li><li>Monorepo or not. This <a href="http://www.gigamonkeys.com/mono-vs-multi/">excellent article</a> covers the pros and cons on this but multiple repos are usually much simpler to start with.</li><li>Use a deployment orchestration tool to streamline software delivery. Also, consider encouraging teams to employ continuous deployment.</li><li>Security, Network and Account policies. This is one of the hardest things to get right but doing this early is much better than trying to retrofit. Additionally, it’s critical if the business needs compliance certifications like SOC2 or HIPAA.</li><li>Pick an Observability platform with good Microservices support (multiple languages, containerized workloads, distributed tracing, etc). We’re big fans of Datadog and highly recommend them. The other popular option is on-prem software like prometheus — but it can turn out to be quite challenging to manage.</li><li>Decide how many environments will be supported and how will teams access/use each of them.</li><li>Figure out the tooling needed to manage/operate the services. Every team shouldn’t have to figure this out from scratch so creating some centralized tooling is highly recommended.</li></ul><h3>Conclusion</h3><p>Microservices architecture can seem daunting to get right but it is an excellent investment for the long term. It will help the org scale to the next level while also making engineers more productive and happier.</p><p>We’d love to hear about your Microservices journey or any feedback you might have on this post — please leave comments below! Good luck!</p><h4><em>Editor’s Note</em></h4><p><em>At RunX, our goal is to help companies accelerate the transition to Microservices while automating most of the Devops and setup work.</em></p><p><em>Building and running a robust cloud architecture with all the best practices and security considerations is a daunting task. Our platform makes it easy! RunX runs on your AWS or GCP account and simplifies the configuration, deployment, and management of Microservices while abstracting away the complexity of Kubernetes, networking, secrets, IAM, observability, and other critical components. All of the tooling mentioned in the previous section — comes built in!</em></p><p><em>If this sounds interesting, you can sign up for early access </em><a href="https://share.hsforms.com/1kePuj-lWQAW981hcADZ7iwbnr6h"><em>here</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f78b856508ea" width="1" height="1" alt=""><hr><p><a href="https://blog.runx.dev/microservices-transition-why-what-how-f78b856508ea">Microservices Transition — why, what, how</a> was originally published in <a href="https://blog.runx.dev/">Run[X]</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>