<?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[Microservices Practitioner Articles - Medium]]></title>
        <description><![CDATA[Technical posts about adopting microservices architectures - Medium]]></description>
        <link>https://medium.com/adopting-microservices-architecture?source=rss----f91e5869b775---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Microservices Practitioner Articles - Medium</title>
            <link>https://medium.com/adopting-microservices-architecture?source=rss----f91e5869b775---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 15:16:05 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/adopting-microservices-architecture" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Towards a better service development story]]></title>
            <link>https://medium.com/adopting-microservices-architecture/towards-a-better-service-development-story-c2fb9bdda6aa?source=rss----f91e5869b775---4</link>
            <guid isPermaLink="false">https://medium.com/p/c2fb9bdda6aa</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Dylan Scott]]></dc:creator>
            <pubDate>Fri, 27 Apr 2018 18:36:30 GMT</pubDate>
            <atom:updated>2018-04-27T18:36:30.163Z</atom:updated>
            <content:encoded><![CDATA[<h4>How Ironclad moved from monolith to microservices without sacrificing developer experience</h4><p>Ironclad began as a monolithic Node application deployed on Heroku. For a small team without much time to devote to DevOps, Heroku was a great solution and made it very easy to automatically build and deploy from GitHub. As our team and application grew, we began to want to split portions of our application into separate services. We decided it was time to move off of Heroku, with the hope that we could keep the ease of development and deployment largely intact.</p><p>We ultimately settled on deploying our application with Kubernetes, hosting on Google’s own Kubernetes Engine offering. With this approach we build a Docker image for each of our services, and have Kubernetes handle scheduling these containers on a cluster. We can simply tell Kubernetes how many replicas of each service we want running, and it takes care of running and restarting containers as needed, and load balancing traffic across replicas. Deploying on Kubernetes is a breeze. We build and push service images in CI and deploy with a simple kubectl apply invocation.</p><p>We’ve gone through a couple of iterations of our service development environment, and have gotten to a place we’re pretty happy with. In the Heroku days development was pretty straightforward. We ran a local development database and a development build of the monolith. With multiple services, we wanted to avoid developers having to manually orchestrate multiple development builds.</p><h3>First pass: Docker Compose</h3><p>Our initial approach after migrating to Docker and Kubernetes was to develop using Docker’s <a href="https://docs.docker.com/compose/overview/">Compose</a> tool. With Compose we could configure a development Docker build for each of our services, including any required environment variables and links to other services. Critically for development, Compose also allows you to <a href="https://docs.docker.com/storage/bind-mounts/#start-a-container-with-a-bind-mount">“bind mount”</a> local source directories into the running containers, so that each service can rebuild/restart to reflect local changes.</p><p>This was a solid setup, and it served us well for a time. As we used it and our codebase grew, we began to experience several pain points with it.</p><ol><li><strong>Build Performance</strong><br>As mentioned above, we used bind mounts of our local source directories so that development services could reflect local changes. We found that bind mounts in Docker for Mac imposed a significant performance overhead for our builds. It sounds like Docker has done a lot of work on <a href="https://docs.docker.com/docker-for-mac/osxfs/">osxfs</a> performance since we moved away from Compose, but at the time we were seeing our initial development builds take several times longer inside the containers than out.</li><li><strong>Unnecessary Builds</strong><br>Typically when developing, we would only be changing one or maybe two services at a time. When we started the stack with Compose however, we would have to do an initial Docker build for every service. This could be somewhat mitigated with Dockerfiles that do a good job of utilizing the <a href="https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#build-cache">build cache</a>. But this was tedious to maintain and often made more difficult by some of the limitations of the Dockerfile language, like a lack of globbing for ADD and COPY commands.</li><li><strong>Configuration Duplication</strong><br>Our Compose configuration had to specify which environment information each service needed, and which ports it listened on. But we already had to supply this information to Kubernetes to configure our services in production. This wasn’t a huge deal, but was an annoying source of duplication.</li></ol><h3>Minikube + Telepresence</h3><p>We initially focused on pain point #2. It seemed wasteful to spend time building services you weren’t going to change. We already built and pushed images for each service from CI, so perhaps we could use these instead of building from scratch. This line of investigation lead us to <a href="https://kubernetes.io/docs/getting-started-guides/minikube/">Minikube</a>, which is a tool maintained by the Kubernetes team that makes it easy to run a single-node Kubernetes cluster in a VM on your local machine. With this tool it was very easy to use our existing configurations to stand up a local Ironclad stack running the same images we deploy to production.</p><p>This was promising, but we needed to figure out a way to develop on individual services when needed. Luckily, we happened to stumble on a tool called <a href="https://www.telepresence.io/">Telepresence</a>. With Telepresence, you can swap out services running in a (local or remote) Kubernetes cluster with ones running locally. It works by swapping the service image in Kubernetes with a proxy image that forwards requests to your local service, and similarly proxies requests from your local service into the cluster. This seemed like exactly what we were looking for, so we started prototyping with it.</p><h4>Speed bump: SIP</h4><p>One problem we ran into along the way has to do with how Telepresence proxies requests from your local process back into the Kubernetes cluster. Their <a href="https://www.datawire.io/code-injection-on-linux-and-macos/">main approach</a> works by injecting shared libraries into the local process using the LD_PRELOAD/DYLD_INSERT_LIBRARIES environment variables, allowing it to intercept system calls like getaddrinfo. This works in many cases, but we ran into trouble with how it interacts with a macOS feature introduced in El Capitan called <a href="https://en.wikipedia.org/wiki/System_Integrity_Protection">System Integrity Protection</a>. The long story short is that recent versions of macOS implement special protections for executables stored in certain distinguished locations like /bin and /usr. These protections include purging the aforementioned dynamic linker variables for these protected binaries, and are in effect even when running as root.</p><p>Telepresence does what it can to work around SIP. It makes a temporary copy of some of these protected directories and prepends them to the $PATH of your local process. Unfortunately, we found that in practice it was <em>very</em> difficult to ensure that our development build processes did not at some point indirect through a process affected by SIP. Many build tools internally use shell scripts that directly reference /bin/sh or /usr/bin/env. For example, in the Node world most build tools are executable scripts starting with #!/usr/bin/env node (including the npm and yarn CLIs).</p><p>Our solution to this problem isn’t particularly elegant, but it works. If we can’t rely on Telepresence’s proxying to make our local services seem like they’re inside the cluster, we’ll just have to make our whole development machine seem like it’s inside the cluster. It works like this: In development, we configure our services to allocate a <a href="https://kubernetes.io/docs/concepts/services-networking/service/#type-nodeport">NodePort</a> equal to their service port. This makes those services accessible from outside the cluster, on the IP bound by the Minikube VM. Separately, we have a development script we run when we start the stack. This script does some nice things like use <a href="https://github.com/johanhaleby/kubetail">kubetail</a> to tail the logs of all running services. But more importantly, it queries the Kubernetes cluster to get an up-to-date list of all services and the ports they’re listening on, and updates a block in your /etc/hosts file to map each service name to $(minikube ip). This certainly feels like a hack, but it’s been a surprisingly robust solution.</p><p>We’ve been using Minikube and Telepresence for our development environment for about 6 months now and have been pretty happy with it. It provides a quick and easy way to get a full stack running locally, and each service’s development build can be fast and simple.</p><p><em>Dylan Scott is a software engineer at Ironclad. Join his team by applying at </em><a href="https://ironcladapp.com/careers">https://ironcladapp.com/careers</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c2fb9bdda6aa" width="1" height="1" alt=""><hr><p><a href="https://medium.com/adopting-microservices-architecture/towards-a-better-service-development-story-c2fb9bdda6aa">Towards a better service development story</a> was originally published in <a href="https://medium.com/adopting-microservices-architecture">Microservices Practitioner Articles</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Developer Workflow Trail for Cloud Native Applications (Request for Feedback)]]></title>
            <link>https://medium.com/adopting-microservices-architecture/developer-workflow-trail-for-cloud-native-applications-request-for-feedback-a9365b64c790?source=rss----f91e5869b775---4</link>
            <guid isPermaLink="false">https://medium.com/p/a9365b64c790</guid>
            <category><![CDATA[learning-microservices]]></category>
            <category><![CDATA[developer-experience]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Daniel Bryant]]></dc:creator>
            <pubDate>Fri, 20 Apr 2018 15:56:02 GMT</pubDate>
            <atom:updated>2018-05-15T21:04:34.239Z</atom:updated>
            <content:encoded><![CDATA[<p>As part of my work with <a href="https://www.datawire.io/">Datawire</a>, I’ve been working with the team around the idea of defining an effective developer workflow when building “cloud native” applications. I shared our initial discussions in a TheNewStack article “<a href="https://thenewstack.io/kubernetes-paas-force-developer-experience-workflow/">Kubernetes and PaaS: The Force of Developer Experience and Workflow</a>”, and this article is a request for feedback on our attempts to expand on this.</p><p>For the majority of organisations (at least those looking to embrace cloud native principles) the keys to competitive advantage are speed and stability. These aren’t just my thoughts, I’m standing on the shoulders of giants such as <a href="https://www.youtube.com/watch?v=BeNrVl2_nyI">Adrian Cockcroft</a> and <a href="https://www.youtube.com/watch?v=OLmi2_TEOog">Steve Smith</a>. Just this morning I opened up Twitter and saw a great tweet from Fintan Ryan of Redmonk, echoing the same concepts from his recent experiences at the Cloud Foundry Summit.</p><h3>Fintan Ryan on Twitter</h3><p>Homeward bound from #CFSummit - my biggest takeaway is the focus of endusers and what they are trying to do. Everyone we spoke with talked about increasing developer velocity &amp;amp; helping devs to deliver business value above all else. Business outcomes, not technology outcomes.</p><p>Fintan mentions about “developer velocity”, which is a key part of the developer experience, and runs the gamut from developers being aligned with business goals, to having appropriate tooling and processes from build to operations.</p><p>The Cloud Native Computing Foundation’s (CNCF) <a href="https://github.com/cncf/landscape#trail-map">Cloud Native Trail Map</a> is a good attempt to describe the steps an engineering team may take when exploring cloud native technologies, although it is rather infrastructure (and hence, operations) focused.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/943/1*IsN1oUPr-ww-DY2X3fj-og.png" /><figcaption>The CNCF <a href="https://github.com/cncf/landscape#trail-map">Cloud Native Trail Map</a></figcaption></figure><p>I’ve tried to capture some of my learnings of the steps an organisation typically takes when embracing cloud native principles like microservices, public cloud and containers, and have placed this in a publicly accessible Google doc (with comments open) titled “<a href="https://docs.google.com/document/d/1Sf5mymRvV2rj6GQRFMUXMESOpqQp7ocqh5Luf6pPhew/edit?usp=sharing">Developer Workflow Trail for Cloud Native Applications</a>”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/679/1*iuxhsUZzyq5MPrUmGXCNfQ.png" /><figcaption>First thoughts around the <a href="https://docs.google.com/document/d/1Sf5mymRvV2rj6GQRFMUXMESOpqQp7ocqh5Luf6pPhew/edit?usp=sharing">Cloud Native Developer Workflow</a> (more details via the public Google doc)</figcaption></figure><p>Please do let me know what you think in the <a href="https://docs.google.com/document/d/1Sf5mymRvV2rj6GQRFMUXMESOpqQp7ocqh5Luf6pPhew/edit">Google doc</a>! I plan to make this look at little nicer in the future, but at the moment it would be good to here whether you think this makes sense, or whether your experiences have been vastly different!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a9365b64c790" width="1" height="1" alt=""><hr><p><a href="https://medium.com/adopting-microservices-architecture/developer-workflow-trail-for-cloud-native-applications-request-for-feedback-a9365b64c790">Developer Workflow Trail for Cloud Native Applications (Request for Feedback)</a> was originally published in <a href="https://medium.com/adopting-microservices-architecture">Microservices Practitioner Articles</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[In Search of an Effective Developer Experience with Kubernetes]]></title>
            <link>https://medium.com/adopting-microservices-architecture/in-search-of-an-effective-developer-experience-with-kubernetes-9ef0d7a144e7?source=rss----f91e5869b775---4</link>
            <guid isPermaLink="false">https://medium.com/p/9ef0d7a144e7</guid>
            <category><![CDATA[adopting-microservices]]></category>
            <category><![CDATA[devex]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[continuous-delivery]]></category>
            <dc:creator><![CDATA[Daniel Bryant]]></dc:creator>
            <pubDate>Thu, 15 Feb 2018 17:26:05 GMT</pubDate>
            <atom:updated>2018-02-15T17:26:04.900Z</atom:updated>
            <content:encoded><![CDATA[<p>At <a href="https://www.datawire.io/">Datawire</a> we are helping many organisations with <a href="https://www.datawire.io/faster/">deploying applications</a> to Kubernetes. Often our most important input is working closely alongside development teams helping them to build effective continuous integration and continuous delivery (CI/CD) pipelines. This is primarily because creating an effective <a href="https://www.datawire.io/faster/dev-workflow-intro/">developer workflow</a> on Kubernetes can be challenging — the ecosystem is still evolving, and not all the platform components are plug-and-play — and also because many engineering teams fail to realise that in order to “close the loop” on business ideas and hypotheses, you also need to instrument applications for observability. We often argue that the first deployment of an application into production through the pipeline is only the start of the continuous delivery process, not the end as some think.</p><p>All of us are creating software to support the <a href="https://itrevolution.com/book/the-art-of-business-value/">delivery of value</a> to our customers and to the business, and therefore the <a href="https://www.infoq.com/news/2017/07/remove-friction-dev-ex">“developer experience” (DevEx)</a> — from idea generation to running (and observing) in production — must be fast, reliable and provide good feedback. As we have helped our customer create effective continuous delivery pipelines for Kubernetes (and the associated workflows), we have seen several patterns emerge. We are keen to share our observations on these patterns, and also explain how we have captured some of best patterns within a <a href="https://www.datawire.io/reference-architecture/">collection of open source tools</a> for deploying applications to Kubernetes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8FpfuqMA686Q7MWV.png" /></figure><h3>From Idea to (Observable) Value</h3><p>Everything we do as engineers begins with an idea. From this idea a hypothesis emerges — for example, modifying the layout of a web form will improve conversion, or improving the site’s p99 latency will result in more revenue — and we can extract appropriate metrics for observation — conversion and page load latency in our example.</p><h3>Building and Packaging for Kubernetes</h3><p>Once we have agreed our hypothesis and metrics we can then begin to write code and package this ready for deployment on Kubernetes. We have created the open source <a href="https://forge.sh/">Forge</a> framework to assist with the entire development process, from automatically creating and managing boilerplate Kubernetes configuration, to allowing us to parameterise runtime properties and resources that can facilitate deploying applications to Kubernetes with a <a href="https://forge.sh/docs/tutorials/quickstart#deploy-a-service">single CLI instruction</a>.</p><p>If we are working on a hypothesis that requires “exploration” — for example, refactoring existing functionality, or solving a technical integration issue — we often whiteboard ideas and begin coding using techniques like Test-Driven Development (TDD), taking care to design observability (business metrics, monitoring and logging etc) in as we go. If we are working on a hypothesis that requires “experimentation” — for example, a new business feature — we typically define Behaviour-Driven Development (BDD)-style tests in order to help keep us focused towards building functionality “outside-in”.</p><h3>Removing Friction from the Code-Deploy-Experiment Cycle</h3><p>We attempt to develop within environments that are as production-like as possible, and so frequently we build local services that interact with a more-complete remote Kubernetes cluster deployment. We have created the open source tool <a href="https://www.telepresence.io/">Telepresence</a> that allows us to execute and debug a local service that acts as if it is part of the remote environment (effectively two-way proxying from our local development machine to the remote Kubernetes cluster).</p><p>We like to “release early, and release often”, and so favour running tests in production using <a href="https://www.getambassador.io/about/microservices-api-gateways#testing-and-updates">canary and dark launches</a>. This way we can expose new functionality to small amounts of real users, and observe their behaviour in relation to our hypothesis. As with any deployment to a production environment, there is obvious a certain amount of risk, and we mitigate this by introducing alerting and automated rollbacks when serious issues are detected. We have created the open source API gateway <a href="https://www.getambassador.io/">Ambassador</a> for this purpose.</p><h3>Smart Routing and Monitoring with Ambassador API Gateway</h3><p>Ambassador is built using the popular <a href="https://www.envoyproxy.io/">Envoy proxy</a> that emerged from the work by <a href="https://twitter.com/mattklein123?lang=en">Matt Klein</a> and <a href="https://eng.lyft.com/envoy-7-months-later-41986c2fd443">his team at Lyft</a>. Ambassador allows “smart routing” of traffic when deploying applications to Kubernetes, and the underlying technology has been proven to operate at-scale within Lyft. Once an application is receiving production traffic we can observe metrics based on our earlier hypothesis. We typically use <a href="https://prometheus.io/">Prometheus</a> to collect data and <a href="https://grafana.com/">Grafana</a> to display the results via dashboards. We’ve created the open source <a href="https://github.com/datawire/prometheus-ambassador">prometheus-ambassador</a> project to enable the easy export of metrics from Ambassador, for example latency and the number of 5xx HTTP responses codes returned.</p><h3>And the Cycle Begins Again</h3><p>Once we have analysed our metrics the development cycle can begin again, either iterating on our existing solution and running additional canary experiments, or if we have proven (or disproven) our original hypothesis we can generate another new idea and hypothesis.</p><p><em>This article originally appeared as part of the </em><a href="https://www.datawire.io/faster"><em>Code Faster Guides</em></a><em> on </em><a href="https://www.datawire.io/"><em>Datawire.io</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9ef0d7a144e7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/adopting-microservices-architecture/in-search-of-an-effective-developer-experience-with-kubernetes-9ef0d7a144e7">In Search of an Effective Developer Experience with Kubernetes</a> was originally published in <a href="https://medium.com/adopting-microservices-architecture">Microservices Practitioner Articles</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A development workflow for Kubernetes services]]></title>
            <link>https://medium.com/adopting-microservices-architecture/a-development-workflow-for-kubernetes-services-10ee017d752a?source=rss----f91e5869b775---4</link>
            <guid isPermaLink="false">https://medium.com/p/10ee017d752a</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[adopting-microservices]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Ambassador Labs]]></dc:creator>
            <pubDate>Thu, 16 Nov 2017 21:28:09 GMT</pubDate>
            <atom:updated>2017-11-16T21:39:59.584Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JsbjpBYQU1Dnucn63ZcDTA.jpeg" /></figure><p>A basic development workflow for Kubernetes services lets a developer write some code, commit it, and get it running on Kubernetes. It’s also important that your development environment be as similar as possible to production, since having two different environments will inevitably introduce bugs. In this tutorial, we’ll walk through a basic development workflow that is built around Kubernetes, Docker, and Envoy/Ambassador.</p><h3>Your cloud infrastructure</h3><p>This tutorial relies on two components in the cloud, Kubernetes and Ambassador. If you haven’t already, go ahead and set them up.</p><ul><li><a href="https://kubernetes.io/">Kubernetes</a></li><li><a href="https://www.getambassador.io/">Ambassador</a>, a self-service API Gateway for Kubernetes</li></ul><h3>1. A development environment for Kubernetes services</h3><p>You need a development environment for Kubernetes services. We recommend the following approach:</p><ul><li>A containerized <em>build/runtime</em> environment, where your service is always run and built. Containerizing your environment helps insure environmental parity across different development and production environments. It also simplifies the onboarding process for new developers.</li><li>Developing your microservice locally, outside of the cluster. You want a fast code/build/test cycle. If you develop remotely, the additional step of deploying to a Kubernetes cluster introduces significant latency.</li><li>Deploying your service into Kubernetes once you need to share your service with others (e.g., canary testing, internal development, etc.).</li></ul><p>You’ll need the following tools installed on your laptop:</p><ul><li>git, for source control</li><li>Docker, to build and run your containers</li><li>kubectl, to manage your deployment</li><li><a href="https://forge.sh/">Forge</a>, for deploying your service into Kubernetes</li><li><a href="https://www.telepresence.io/">Telepresence</a>, for locally developing your service</li></ul><p>Go ahead and install them now, if you haven’t already.</p><h3>2. Deploy service to Kubernetes</h3><p>In a traditional application, the release / operations team manages the deployment of application updates to production. In a microservices architecture, the team is responsible for deploying service updates to production.</p><p>We’re going to deploy and publish a microservice, from source, into Kubernetes.</p><ol><li>We’ve created a simple Python microservice that you can use as a template for your service. This template includes:</li></ol><ul><li>a Dockerfile that specifies how your development environment and runtime environment are configured and built.</li><li>a service.yaml file that customizes deployments for different scenarios (e.g., production, canary, development).</li><li>a Kubernetes manifest (k8s/deployment.yaml) that defines how the service is run in Kubernetes. It also contains the annotations necessary to configure Ambassador for the given service.</li></ul><pre>git clone https://github.com/datawire/hello-world-python</pre><p>2. We’re going to use Forge to automate and template-ize the deployment process. Run the Forge configuration process:</p><pre>forge setup</pre><p>3. The process of getting a service running on a Kubernetes cluster involves a number of steps: building a Docker image, pushing the image to a repository, instantiating a Kubernetes manifest to point to the image, and applying the manifest to the cluster. Forge automates this entire process of deployment:</p><pre>cd hello-world-python<br>forge deploy</pre><p>4. Now, we’re going to test the service. Get the external IP address of Ambassador:</p><pre>kubectl get services ambassador<br>NAME         CLUSTER-IP      EXTERNAL-IP      PORT(S)        AGE<br>ambassador   10.11.250.208   35.190.189.139   80:31622/TCP   4d</pre><p>5. Access the service via Ambassador:</p><pre>curl 35.190.180.139/hello/<br>Hello World (Python)! (up 0:03:13)</pre><h3>3. Live coding</h3><p>When developing, you want a fast feedback cycle. You’d like to make a code change, and immediately be able to build and test your code. The deployment process we just went through adds latency into the process, since building and deploying a container with your latest changes takes time. Yet, running a service in Kubernetes lets that service access other cloud resources (e.g., other services, databases, etc.).</p><p><a href="https://www.telepresence.io/">Telepresence</a> lets you develop your service locally, while creating a bi-directional proxy to a remote Kubernetes cluster.</p><ol><li>You’d like for your development environment to be identical to your runtime environment. We’re going to do that by using the exact same Dockerfile we use for production to build a development image. Make sure you’re in the hello-world-python directory, and type:</li></ol><pre>docker build . -t hello-world-dev</pre><p>2. Now, we can swap the existing hello-world service on Kubernetes for a version of the same service, running in a local container.</p><pre>telepresence --swap-deployment hello-world-stable --docker-run \<br>   --rm -it -v $(pwd):/service hello-world-dev:latest</pre><p>(Note that Forge has automatically appended a stable suffix to the deployment name to indicate that the service has been deployed with the stable profile specified in the service.yaml.)</p><p>3. Telepresence invokes docker run to start the container. It also mounts the local filesystem containing the Python source tree into the container. Change the &quot;Hello World&quot; message in app.pyto a different value:</p><pre>def root():<br>  return &quot;Hello World via Telepresence! (up %s)\n&quot; % elapsed()</pre><p>4. Now, if we test our service via Ambassador, we’ll see that we’re now routing to the modified version of our service.</p><pre>curl 35.190.189.139/hello/<br>Hello World via Telepresence! (up 0:04:13)</pre><h3>Want to learn more?</h3><p>This article originally appeared in <a href="https://www.datawire.io/">Datawire’s</a> <a href="https://www.datawire.io/faster">Code Faster Guides</a>. Check out the other tutorials in this series:</p><ul><li><a href="https://www.datawire.io/faster/why-workflow/">Why your development workflow is so important for microservices</a></li><li><a href="https://www.datawire.io/faster/canary-workflow/">Canary deployments, A/B testing, and microservices</a></li><li><a href="https://www.datawire.io/faster/shared-dev/">Shared development models and multi-service applications</a></li></ul><p>Or try out the open source projects mentioned in this tutorial for yourself:</p><ul><li><a href="https://kubernetes.io/">Kubernetes</a></li><li><a href="https://www.getambassador.io/">Ambassador</a></li><li><a href="https://forge.sh/">Forge</a></li><li><a href="https://www.telepresence.io/">Telepresence</a></li><li><a href="https://www.docker.com/">Docker</a></li><li><a href="https://git-scm.com/">Git</a></li></ul><p>If you have any questions, reach out to us on <a href="https://gitter.im/datawire/home">Gitter</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=10ee017d752a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/adopting-microservices-architecture/a-development-workflow-for-kubernetes-services-10ee017d752a">A development workflow for Kubernetes services</a> was originally published in <a href="https://medium.com/adopting-microservices-architecture">Microservices Practitioner Articles</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[This Month in Microservices: October 2017]]></title>
            <link>https://medium.com/adopting-microservices-architecture/this-month-in-microservices-october-2017-9de0b608bc84?source=rss----f91e5869b775---4</link>
            <guid isPermaLink="false">https://medium.com/p/9de0b608bc84</guid>
            <category><![CDATA[learning-microservices]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Ambassador Labs]]></dc:creator>
            <pubDate>Tue, 31 Oct 2017 19:47:55 GMT</pubDate>
            <atom:updated>2017-10-31T19:47:45.109Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*suAoq6mCq_-lfn37R6CW4g.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/photos/w7gqF92AL2A?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Tim Mossholder</a> on <a href="https://unsplash.com/?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>This month in microservices, <a href="https://thenewstack.io/">The New Stack</a> covered how AirBnB deploys 3,500 microservices per week, <a href="https://codeship.com/">Codeship</a> shared their best practices for documenting microservices, we differentiated between microservices API gateways and traditional API gateways, the engineers at <a href="https://tabbdrink.com/">TabbDrink</a> shared their experiences moving to microservices, and more!</p><p>Check out these most popular articles from the weekly <a href="https://www.microservices.com/brief/?utm_source=medium&amp;utm_medium=social&amp;utm_campaign=octmsvroundup">Microservices Practitioner’s Brief</a> for the month of October.</p><h3>Case Study</h3><p><a href="https://thenewstack.io/airbnbs-10-takeaways-moving-microservices/">Airbnb&#39;s 10 Takeaways from Moving to Microservices - The New Stack</a></p><p>Airbnb deploys 3500 microservices per week, with a total of 75,000 production deploys per year. This post covers what they learned on the journey from monolith to microservices.</p><h3>Tutorial</h3><p><a href="https://blog.codeship.com/documenting-microservices/">Tools and Practices for Documenting Microservices - via @codeship</a></p><p>This article walks through best practices for documenting microservices and application architectures that use the pattern.</p><h3>Case Study</h3><p><a href="https://www.getambassador.io/about/microservices-api-gateways">Microservices API Gateways · Ambassador: API Gateway for microservices and Kubernetes</a></p><p>Microservices API gateways focus on accelerating the development workflow as opposed to traditional API gateways which focus on the challenges of managing APIs. This post discusses how this difference in business objective (productivity vs. management) results in a very different API gateway.</p><h3>The Industry</h3><p><a href="https://blog.newrelic.com/2017/10/09/popular-programming-languages-2017/">Most Popular Programming Languages of 2017</a></p><p>An interesting article on the most popular / in-demand programming languages of 2017, and how the increasing popularity of microservices has affected the landscape.</p><h3>Case Study</h3><p><a href="https://hackernoon.com/microservices-are-hard-an-invaluable-guide-to-microservices-2d06bd7bcf5d">Microservices are hard — an invaluable guide to microservices.</a></p><p>The engineers at TabbDrink have been building their platform over the last 18 months. This post covers why they decided to move to microservices, the challenges they faced along the way, and what technical decisions they made around their platform.</p><h3>Open Source Project</h3><p><a href="https://github.com/GoogleCloudPlatform/distroless">GoogleCloudPlatform/distroless</a></p><p>“Distroless” images contain only your application and its runtime dependencies. They do not contain package managers, shells, or any other programs you would expect to find in a standard Linux distribution. Restricting what’s in your runtime container to precisely what’s necessary for your app is a proven best practice.</p><h3>Open Source Project</h3><p><a href="https://github.com/jaegertracing/jaeger">GitHub - jaegertracing/jaeger: CNCF Jaeger, a Distributed Tracing Platform</a></p><p>Jaeger is an open source distributed tracing system released by Uber and hosted by the CNCF. It can be used for monitoring microservice-based architectures: distributed context propagation, distributed transaction monitoring, root cause analysis, service dependency analysis, performance / latency optimization.</p><h3>Non-Sequitur</h3><p><a href="https://robertheaton.com/2017/10/09/tracking-friends-and-strangers-using-whatsapp/">Tracking friends and strangers using WhatsApp | Robert Heaton</a></p><p>An entertaining article that gives an interesting perspective on the real-world privacy impact of the apps you use every day.</p><h3>Can’t get enough?</h3><p><a href="https://www.microservices.com/brief/?utm_source=medium&amp;utm_medium=social&amp;utm_campaign=octmsvroundup">Subscribe to the Microservices Practitioner Brief </a>and get the biggest news in microservices in your inbox every Tuesday morning.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9de0b608bc84" width="1" height="1" alt=""><hr><p><a href="https://medium.com/adopting-microservices-architecture/this-month-in-microservices-october-2017-9de0b608bc84">This Month in Microservices: October 2017</a> was originally published in <a href="https://medium.com/adopting-microservices-architecture">Microservices Practitioner Articles</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Developing Resilient Microservices with Kubernetes and Envoy]]></title>
            <link>https://medium.com/adopting-microservices-architecture/developing-resilient-microservices-with-kubernetes-and-envoy-5cab13639b27?source=rss----f91e5869b775---4</link>
            <guid isPermaLink="false">https://medium.com/p/5cab13639b27</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[adopting-microservices]]></category>
            <dc:creator><![CDATA[Ambassador Labs]]></dc:creator>
            <pubDate>Wed, 25 Oct 2017 15:11:52 GMT</pubDate>
            <atom:updated>2017-10-25T15:11:38.332Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FImGzqam-s5leA2ynv1XTw.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/photos/QvPRGI8LfOc?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Heidi Sandstrom.</a> on <a href="https://unsplash.com/?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>Earlier this month we gave a 3 hour tutorial at the <a href="https://conferences.oreilly.com/software-architecture/sa-eu">O’Reilly Software Architecture Conference</a> in London. We wanted to share the slides and a summary of our talk.</p><h3>Summary</h3><p>Microservices are an increasingly popular approach to building cloud-native applications, and dozens of new technologies that streamline adopting microservices development, such as <a href="https://www.docker.com/">Docker</a>, <a href="https://kubernetes.io/">Kubernetes</a>, and <a href="https://envoyproxy.github.io/">Envoy</a>, have been released over the past few years. In this tutorial, we will walk you through actually using these technologies to develop, deploy, and run microservices. We discussed the evolution of the microservices stack, key things to keep in mind when adopting microservices, and how to tune and evolve your microservices architecture. This tutorial covered:</p><p><strong>Essentials: development and deployment</strong></p><ul><li>How to get a microservice running in your Kubernetes cluster quicly</li><li>How to set up a development environment for your microservice, including testing and fast iteration cycles</li></ul><p><strong>Resilience and monitoring</strong></p><ul><li>Advanced deployment; blue-green, canary deployments in Kubernetes</li><li>How to deploy Lyft Envoy with your service to add observability and resilience</li></ul><p><strong>Adapting these techniques to your organization</strong></p><h3>Slides</h3><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.slideshare.net%2Fslideshow%2Fembed_code%2Fkey%2FjeURQxQtyh7Ra0&amp;url=https%3A%2F%2Fwww.slideshare.net%2Fdatawire%2Fbuilding-resilient-microservices-with-kubernetes-docker-and-envoy-81198560&amp;image=https%3A%2F%2Fcdn.slidesharecdn.com%2Fss_thumbnails%2Fkubernetesenvoydockertraininglondon-171025150536-thumbnail-4.jpg%3Fcb%3D1508943997&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=slideshare" width="600" height="500" frameborder="0" scrolling="no"><a href="https://medium.com/media/00f9024ff3d4711ee160fb20c2ffe2e0/href">https://medium.com/media/00f9024ff3d4711ee160fb20c2ffe2e0/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5cab13639b27" width="1" height="1" alt=""><hr><p><a href="https://medium.com/adopting-microservices-architecture/developing-resilient-microservices-with-kubernetes-and-envoy-5cab13639b27">Developing Resilient Microservices with Kubernetes and Envoy</a> was originally published in <a href="https://medium.com/adopting-microservices-architecture">Microservices Practitioner Articles</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[This Month in Microservices: September 2017]]></title>
            <link>https://medium.com/adopting-microservices-architecture/this-month-in-microservices-september-2017-a5275e24959?source=rss----f91e5869b775---4</link>
            <guid isPermaLink="false">https://medium.com/p/a5275e24959</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[learning-microservices]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Ambassador Labs]]></dc:creator>
            <pubDate>Fri, 29 Sep 2017 18:01:51 GMT</pubDate>
            <atom:updated>2017-09-29T18:02:16.972Z</atom:updated>
            <content:encoded><![CDATA[<p>This month in microservices, <a href="https://envoyproxy.github.io/">Envoy</a>, a popular open source edge and service proxy joined the <a href="https://www.cncf.io/">CNCF</a>, <a href="https://buffer.com/">Buffer</a> wrote about their experiences transitioning to <a href="https://kubernetes.io/">Kubernetes</a>, and <a href="https://codersociety.com/">Coder Society</a> shared how they run processes locally in Kubernetes with <a href="https://www.telepresence.io/">Telepresence</a>. Check out these most popular articles from the weekly Microservices Practitioner’s Brief for the month of September.</p><h3>Case Study</h3><p><a href="https://overflow.buffer.com/2017/08/31/buffer-deploy-code-kubernetes/">How Does Buffer Deploy Code to Kubernetes</a></p><p>Ever since Buffer started using Kubernetes 1 year ago they have been on a mission to streamline the deployment experience. This article covers how they began manually deploying services to Kubernetes, their transition to a more consistent deployment experience from monolith architecture to k8s and their push for team-wide adoption.</p><h3>Open Source Project</h3><p><a href="https://github.com/Yelp/dumb-init/blob/master/README.md">Yelp/dumb-init</a></p><p>dumb-init is a simple process supervisor and init system designed to run as PID 1 inside minimal container environments, like Docker. It is deployed as a small, statically-linked binary written in C.</p><h3>Tutorial</h3><p><a href="https://blog.codersociety.com/run-a-local-process-in-kubernetes-with-telepresence-dc16bd593b52">Run a local process in Kubernetes with Telepresence</a></p><p>A thorough walk-through on how Coder Society uses Telepresence in their Kubernetes development stack.</p><h3>Industry</h3><p><a href="https://eng.lyft.com/envoy-joins-the-cncf-dc18baefbc22">Envoy joins the CNCF</a></p><p>Envoy announced that it was joining the Cloud Native Computing Foundation as its 11th hosted project.</p><h3>Non-Sequitur</h3><p><a href="https://codewithoutrules.com/2017/09/18/when-startups-pay-less/">Join our startup, we&#39;ll cut your pay by 40%!</a></p><p>Why you shouldn’t be okay with being expected to work 70+ hours a week.</p><h3>Can’t get enough?</h3><p><a href="https://www.microservices.com/brief/?utm_source=medium&amp;utm_medium=social&amp;utm_campaign=septmsvroundup">Subscribe to the Microservices Practitioner Brief </a>and get the biggest news in microservices in your inbox every Tuesday morning.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a5275e24959" width="1" height="1" alt=""><hr><p><a href="https://medium.com/adopting-microservices-architecture/this-month-in-microservices-september-2017-a5275e24959">This Month in Microservices: September 2017</a> was originally published in <a href="https://medium.com/adopting-microservices-architecture">Microservices Practitioner Articles</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Debug a Kubernetes Service Locally with Telepresence]]></title>
            <link>https://medium.com/adopting-microservices-architecture/debug-a-kubernetes-service-locally-with-telepresence-675eb6e94b09?source=rss----f91e5869b775---4</link>
            <guid isPermaLink="false">https://medium.com/p/675eb6e94b09</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[debugging]]></category>
            <category><![CDATA[adopting-microservices]]></category>
            <dc:creator><![CDATA[Ambassador Labs]]></dc:creator>
            <pubDate>Tue, 15 Aug 2017 16:27:22 GMT</pubDate>
            <atom:updated>2017-09-20T20:06:36.739Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/200/1*EA--ho-HrsVwpjqkBpopzA@2x.png" /></figure><h3>Install Telepresence with Homebrew/apt/dnf</h3><p>You will need the following available on your machine:</p><ul><li>kubectl command line tool (here’s the <a href="https://kubernetes.io/docs/tasks/tools/install-kubectl/">installation instructions</a>).</li><li>Access to your Kubernetes cluster, with local credentials on your machine. You can test this by running kubectl get pod - if this works you’re all set.</li><li>To install <a href="https://www.telepresence.io/">Telepresence</a>, follow the instructions <a href="https://www.telepresence.io/reference/install">here</a>.</li></ul><h3>Debugging a service locally with Telepresence</h3><p>Imagine you have a service running in a staging cluster, and someone reports a bug against it. In order to figure out the problem you want to run the service locally… but the service depends on other services in the cluster, and perhaps on cloud resources like a database.</p><p>In this tutorial you’ll see how Telepresence allows you to debug your service locally. We’ll use the telepresencecommand line tool to swap out the version running in the staging cluster for a debug version under your control running on your local machine. Telepresence will then forward traffic from Kubernetes to the local process.</p><p>You should start a Deployment and publicly exposed Service like this:</p><pre>$ <strong>kubectl</strong> run hello-world --image=datawire/hello-world --port=8000<br>$ <strong>kubectl</strong> expose deployment hello-world --type=LoadBalancer --name=hello-world</pre><p><strong>If your cluster is in the cloud</strong> you can find the address of the resulting Service like this:</p><pre>$ <strong>kubectl</strong> get service hello-world <br>NAME          CLUSTER-IP     EXTERNAL-IP       PORT(S)          AGE hello-world   10.3.242.226   104.197.103.123   8000:30022/TCP   5d</pre><p>If you see &lt;pending&gt; under EXTERNAL-IP wait a few seconds and try again. In this case the Serviceis exposed at <a href="http://104.197.103.123:8000/">http://104.197.103.123:8000/</a> .</p><p><strong>On</strong> <strong>minikube you should instead</strong> do this to find the URL:</p><pre>$ <strong>minikube</strong> service --url hello-world <br>http://192.168.99.100:12345/</pre><p>Once you know the address you can store its value (don’t forget to replace this with the real address!):</p><pre>$ <strong>export</strong> HELLOWORLD=http://104.197.103.13:8000</pre><p>And you send it a query and it will be served by the code running in your cluster:</p><pre>$ <strong>curl</strong> $HELLOWORLD/<br>Hello, world!</pre><h3>Swapping your deployment with Telepresence</h3><p><strong>Important:</strong> Starting telepresence the first time may take a little while, since Kubernetes needs to download the server-side image.</p><p>At this point you want to switch to developing the service locally, replace the version running on your cluster with a custom version running on your laptop. To simplify the example we’ll just use a simple HTTP server that will run locally on your laptop:</p><pre>$ <strong>mkdir</strong> /tmp/telepresence-test<br>$ <strong>cd</strong> /tmp/telepresence-test<br>$ <strong>echo</strong> &quot;hello from your laptop&quot; &gt; file.txt<br>$ <strong>python3</strong> -m http.server 8001 &amp;<br>[1] 2324<br>$ <strong>curl</strong> http://localhost:8001/file.txt<br>hello from your laptop<br>$ <strong>kill</strong> %1</pre><p>We want to expose this local process so that it gets traffic from Kubernetes, replacing the existing hello-worlddeployment.</p><p><strong>Important:</strong> you’re about to expose a web server on your laptop to the Internet. This is pretty cool, but also pretty dangerous! Make sure there are no files in the current directory that you don’t want shared with the whole world.</p><p>Here’s how you should run telepresence (you should make sure you’re still in the /tmp/telepresence-test directory you created above):</p><pre>$ <strong>cd</strong> /tmp/telepresence-test<br>$ <strong>telepresence</strong> --swap-deployment hello-world --expose 8000 \<br>               --run python3 -m http.server 8000 &amp;</pre><p>This does three things:</p><ul><li>Starts a VPN-like process that sends queries to the appropriate DNS and IP ranges to the cluster.</li><li>--swap-deployment tells Telepresence to replace the existing hello-world pod with one running the Telepresence proxy. On exit, the old pod will be restored.</li><li>--run tells Telepresence to run the local web server and hook it up to the networking proxy.</li></ul><p>As long as you leave the HTTP server running inside telepresence it will be accessible from inside the Kubernetes cluster. You’ve gone from this…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/850/1*j-w7Bln7tpGs6s9tEUW1jg.png" /></figure><p>…to this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P7vkn2o76emb8ccr8KdTLg.png" /></figure><p>We can now send queries via the public address of the Service we created, and they’ll hit the web server running on your laptop instead of the original code that was running there before. Wait a few seconds for the Telepresence proxy to startup; you can check its status by doing:</p><pre>$ <strong>kubectl</strong> get pod | grep hello-world<br>hello-world-2169952455-874dd   1/1       Running       0          1m<br>hello-world-3842688117-0bzzv   1/1       Terminating   0          4m</pre><p>Once you see that the new pod is in Running state you can use the new proxy to connect to the web server on your laptop:</p><pre>$ <strong>curl</strong> $HELLOWORLD/file.txt<br>hello from your laptop</pre><p>Finally, let’s kill Telepresence locally so you don’t have to worry about other people accessing your local web server by bringing it to the background and hitting Ctrl-C:</p><pre>$ <strong>fg</strong><br>telepresence --swap-deployment hello-world --expose 8000 --run python3 -m http.server 8000<br>^C<br>Keyboard interrupt received, exiting.</pre><p>Now if we wait a few seconds the old code will be swapped back in. Again, you can check status of swap back by running:</p><pre>$ <strong>kubectl</strong> get pod | grep hello-world</pre><p>When the new pod is back to Running state you can see that everything is back to normal:</p><pre>$ <strong>curl</strong> $HELLOWORLD/file.txt<br>Hello, world!</pre><blockquote><strong><em>What you’ve learned:</em></strong><em> Telepresence lets you replace an existing deployment with a proxy that reroutes traffic to a local process on your machine. This allows you to easily debug issues by running your code locally, while still giving your local process full access to your staging or testing cluster.</em></blockquote><p>Now it’s time to clean up the service:</p><pre>$ <strong>kubectl</strong> delete deployment,service hello-world</pre><p><a href="https://www.telepresence.io/">Telepresence</a> can do much more than this: see the <a href="https://www.telepresence.io/discussion/why-telepresence">reference section of the documentation</a> for details.</p><p><strong>Still have questions? Ask in our </strong><a href="https://gitter.im/datawire/telepresence"><strong>Gitter chatroom</strong></a><strong> or </strong><a href="https://github.com/datawire/telepresence/issues/new"><strong>file an issue on GitHub</strong></a><strong>.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=675eb6e94b09" width="1" height="1" alt=""><hr><p><a href="https://medium.com/adopting-microservices-architecture/debug-a-kubernetes-service-locally-with-telepresence-675eb6e94b09">Debug a Kubernetes Service Locally with Telepresence</a> was originally published in <a href="https://medium.com/adopting-microservices-architecture">Microservices Practitioner Articles</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The 2017 Cloud Trends — From DevOps to NoOps]]></title>
            <link>https://medium.com/adopting-microservices-architecture/the-2017-cloud-trends-from-devops-to-noops-1d12fa85d433?source=rss----f91e5869b775---4</link>
            <guid isPermaLink="false">https://medium.com/p/1d12fa85d433</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[adopting-microservices]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Vijay Rayapati]]></dc:creator>
            <pubDate>Thu, 02 Mar 2017 19:12:58 GMT</pubDate>
            <atom:updated>2017-03-02T19:12:58.075Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*5Ein6EkDDaj6XejscKwjOQ.png" /><figcaption><strong>The NoOps Philosophy</strong></figcaption></figure><p>I believe, 2017 will be an exciting year ahead for DevOps engineers with the rise of containers, adoption of microservice architectures and proliferation of machine intelligence for solving their everyday problems. We have been watching the trend of manual operations to DevOps over the last 7 years while the trend of going from DevOps to NoOps is now gaining the momentum with the rise of machine intelligence for solving operational problems.</p><blockquote>In a nutshell, NoOps is a logical progression of DevOps with the philosophy of: <strong>Humans should solve new problems and the Machines should solve known problems!</strong></blockquote><p>The easiest way to think about the difference between DevOps and NoOps is the difference between scripted automation and intelligent operations. Most of the DevOps tooling is powered by the scripted automation like building an application, deploying the code into machines and provisioning infrastructure through series of steps that are programmed to work.</p><p>The NoOps is an era of using intelligent automation for your operational tasks so you can eliminate the need for humans to manage operations, save precious engineering time and solve known problems as the machines can make decisions on known problems and can provide diagnostic information for the new problems to reduce the operational overhead for engineers.</p><p>Below are the top 5 trends that will power NoOps adoption in 2017:</p><ol><li><strong>Serverless Programming: </strong>With the adoption of Function-as-a-Service with cloud provider offerings like AWS Lambda, the early adopters are already moving their simple APIs, scripted tasks, and quick jobs to serverless function deployment paradigm, so they don’t need to manage schedulers and worry about underlying infrastructure for their specific tasks.</li></ol><blockquote>This is a new programming and deployment paradigm that will significantly eliminate the DevOps requirement for provisioning and configuration management. As all cloud vendors mature their serverless offering, we will only see a growth trajectory for NoOps movement.</blockquote><p><strong>2. Containerisation: </strong>The containers have ruled the cloud world in 2016, and we will see increased adoption for all the new application deployments in the Cloud being powered by Containers like Docker, etc. As businesses adopt cloud as the mainstream infrastructure platform, it will further increase the rise of Containers for handling the diversity and variety of dependencies across enterprise applications in the companies.</p><blockquote>The containers will further abstract the dependencies and resource sharing between different components by leveraging cluster management and orchestration solutions like Kubernetes, Mesos, ECS, Nomad, etc. to provide a common view of underlying infrastructure.</blockquote><p><strong>3. Microservices Architecture: </strong>While a variety of applications are already deployed on Cloud, the true power of Cloud will only be realised with the adoption of micro services architecture pattern for building new applications and deploying the existing applications. This will help engineers and companies to decouple the complexity of monolithic systems into small yet manageable components handling specific responsibility, with the adoption of containers, the abstraction of dependencies and packing is already become simple.</p><blockquote>The raise of Microservice Architecture requires intelligent build and deployment approach rather than a plain vanilla CI/CD that most people use today. The microservices architecture will see a rapid adoption as containerisation becomes standard way of deploying components in the cloud.</blockquote><p><strong>4. Intelligent and Unified Operations: </strong>The engineers responsible for managing the production operations (from ITOps to DevOps era) have been frustrated with the static tooling that’s mostly not intelligent. With the rise of machine intelligence and adoption of deep learning, we will see more of dynamic tooling that can help them in day to day operations.</p><blockquote>Like Intelligent Monitoring (with no static thresholds for alerts instead of dynamic alerts), Intelligent Deployment (with cluster management tooling), Intelligent APM (not just what’s happening but why it’s happening), Intelligent Log Management (real time streaming of log events and auto detection of relevant events based on application stack) and Intelligent Incident Management (suppression of noise from different alerting systems and providing diagnostics for engineers to get to the root cause faster).</blockquote><p><strong>5. Self Healing and Auto Remediation: </strong>With the adoption of DevOps, the engineers have already taken over the production operations and applying the principles of programming for solving day to day tasks. However, the DevOps world was limited to build, deployment and provisioning while the day to day operations are still handled in a manual or semi-automated fashion. In 2017, we will see the adoption of intelligent operations for managing cloud applications and microservice architectures paving the way for self healing and auto remediation of production components and infrastructure becoming a reality.</p><blockquote>This will be accelerated by the adoption of containers and cluster management solutions for deploying applications at scale with auto-replacement of failed components, failover support, auto pull of new releases, auto rollback if new deployment fails and built-in recovery for known problems, etc.</blockquote><p>We are excited to be in 2017 as a player in the cloud ecosystem focused on solving everyday problems using technology intelligently and will be working hard to deliver the promise of NoOps for engineers through <a href="https://www.botmetric.com/cloud-ops-automation/"><strong>Botmetric DevOps and Automation</strong></a> offering.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1d12fa85d433" width="1" height="1" alt=""><hr><p><a href="https://medium.com/adopting-microservices-architecture/the-2017-cloud-trends-from-devops-to-noops-1d12fa85d433">The 2017 Cloud Trends — From DevOps to NoOps</a> was originally published in <a href="https://medium.com/adopting-microservices-architecture">Microservices Practitioner Articles</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Better Way of Visualizing Microservice Architecture]]></title>
            <link>https://medium.com/adopting-microservices-architecture/an-alternative-way-of-visualizing-microservice-architecture-837cbee575c1?source=rss----f91e5869b775---4</link>
            <guid isPermaLink="false">https://medium.com/p/837cbee575c1</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[scaling-microservices]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[Vlad Holubiev]]></dc:creator>
            <pubDate>Thu, 02 Mar 2017 19:12:39 GMT</pubDate>
            <atom:updated>2017-03-02T19:12:38.669Z</atom:updated>
            <content:encoded><![CDATA[<p>I’ve been using <a href="https://www.draw.io/">draw.io</a> pretty much all the time for any kind of UML diagrams, charts or graphs. It gives a fair compromise between feature richness and manual control.</p><p>But I’m going to show you how to automate some boring mouse clicking ;)</p><h3>Avoid mistakes from the beginning</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/638/0*WhNMHk0PH6uSRsHN." /><figcaption>A slide from <a href="https://www.slideshare.net/danveloper/microservices-the-right-way">“Microservices: The Right Way” presentation </a>from Daniel Woods</figcaption></figure><p>This wouldn’t be so funny if it wasn’t so true. It’s better to have a clear picture of relationships and responsibilities. Or you’ll end up with the picture above ;)</p><p>The trick is you’re much less likely to build something so bad while constantly acknowledging how wrong it looks.</p><p>When you draw — you are giving yourself a report on how things will interact, what is the domain, context, boundaries, etc.</p><blockquote>“Plans are worthless, planning is invaluable.”</blockquote><blockquote><em>― </em>Winston Churchill</blockquote><h3>Getting hands dirty</h3><p>Imagine a simple social app. This a simplistic setup, but you may notice amount of connections present.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kkj0L5oCNR2cNFSQ2ZhSzw.png" /></figure><p><strong>Client-side: </strong>Front-end App and Browser Extension.</p><p><strong>API Gateways: </strong>Auth API and Main API</p><p><strong>Microservices: </strong>Photos, Chats and Friends Microservices</p><p>I spent quite a while arranging boxes, drag and dropping arrows and stuff. And only because I wanted to align them in a more readable way.</p><p>Can you believe how tedious it is with 50 ones? 100? And then I remove one? I bet you drop this task and go back to coding.</p><h3>In ❤ with <a href="http://www.graphviz.org/">Graphviz</a></h3><p>I got my inspiration from <a href="https://www.terraform.io/">Terraform</a> — a tool for creating and maintaining your production infrastructure. It allows you to setup everything from AWS EC2 instances to clusters and load balancers from 50 cloud providers.</p><p>It has an interesting <a href="https://www.terraform.io/docs/commands/graph.html">terraform graph</a> command which generates a visual representation of your config.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/658/0*7LSABJtqnEbfy068.png" /><figcaption>Example output from <a href="https://www.terraform.io/docs/commands/graph.html">‘terraform graph’</a> command</figcaption></figure><p>So I decided to apply same technique but on a bit higher level of Microservice Architecture.</p><p>This is a config written in DOT language for Graphviz.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/84cf5d1050f0122ad6108adb1222fe13/href">https://medium.com/media/84cf5d1050f0122ad6108adb1222fe13/href</a></iframe><p>All you need is to render this into a <em>.png</em>. You can use <a href="http://dreampuf.github.io/GraphvizOnline/">online editor</a> or render on your machine. I created a <a href="https://github.com/vladgolubev/docker-graphviz-png-cli">docker image</a> to keep my system clean:</p><pre>cat file.dot | docker container run --rm -i vladgolubev/dot2png &gt; file.png</pre><p>With this simple code in 2 minutes you get such an amazing output!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/785/1*0MpH3zXStFU13QDw0RpIlA.png" /><figcaption>Tip: you can copy-paste the code into online-editor at <a href="http://dreampuf.github.io/GraphvizOnline/">http://dreampuf.github.io/GraphvizOnline/</a></figcaption></figure><p>So the idea is that adding a new dependency between microservices was never so easy. All I do is add a new line of code and Graphviz takes care of putting stuff together beautifully.</p><p>And as a final touch, I like to add colors. So you immediately see:</p><ul><li>Green — node.js</li><li>Red — api gateway</li><li>Yellow — front-end</li><li>Blue — storage, database</li><li>Grey — 3rd-party API</li></ul><p>Not the best color coding, but you got the idea ;) Believe me, it’s so much easier with huge graphs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/872/1*5q4FO_Ss5e42XyJI71EnLw.png" /><figcaption>Full code at <a href="https://gist.github.com/vladgolubev/80c5523336ddec3859c0e90d9a070882">https://gist.github.com/vladgolubev/80c5523336ddec3859c0e90d9a070882</a></figcaption></figure><h3>Conclusion</h3><p>I had a problem with introducing frequent changes into a microservices graph. Every change imposed a manual tinkering with arrows. Now I can experiment and see how new microservices fit into my system.</p><p>You can go beyond and put this into VCS to have a history diff of your architecture changes!</p><p>But it’s up to you. Choose the best tool for your needs. Google for <a href="https://www.google.com/search?q=microservice+visualization"><em>microservice visualization</em></a> and you’ll be bombarded with tons of commercial solutions.</p><blockquote>Design for visibility to make inspection and debugging easier.</blockquote><blockquote>― <a href="http://www.faqs.org/docs/artu/ch01s06.html">Basics of the Unix Philosophy</a></blockquote><p><em>P.S. If you survived reading upon this point, press ❤ and subscribe for new tidbits ☺</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=837cbee575c1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/adopting-microservices-architecture/an-alternative-way-of-visualizing-microservice-architecture-837cbee575c1">A Better Way of Visualizing Microservice Architecture</a> was originally published in <a href="https://medium.com/adopting-microservices-architecture">Microservices Practitioner Articles</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>