<?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 Heptio Advocacy on Medium]]></title>
        <description><![CDATA[Stories by Heptio Advocacy on Medium]]></description>
        <link>https://medium.com/@transplain?source=rss-158602cec861------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*MeVShPtLZ-0qmoRRDz0dHA.png</url>
            <title>Stories by Heptio Advocacy on Medium</title>
            <link>https://medium.com/@transplain?source=rss-158602cec861------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 03:32:12 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@transplain/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[The Kubernetes Cluster API]]></title>
            <link>https://medium.com/heptio-blog/the-kubernetes-cluster-api-de5a1ff870a5?source=rss-158602cec861------2</link>
            <guid isPermaLink="false">https://medium.com/p/de5a1ff870a5</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[cluster-api]]></category>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[infrastructure]]></category>
            <dc:creator><![CDATA[Heptio Advocacy]]></dc:creator>
            <pubDate>Tue, 04 Dec 2018 18:38:42 GMT</pubDate>
            <atom:updated>2018-12-04T18:38:42.275Z</atom:updated>
            <content:encoded><![CDATA[<p>I’ve been working with Kubernetes since filing my first commit in October 2016. I’ve had the chance to collaborate with the community on Kops, Kubicorn, and Kubeadm, but there’s one gap that has been nagging me for years: how to to create the right abstraction for bringing up a Kubernetes cluster and managing it once it’s online. As it turned out, I wasn’t alone. So begins the story of Cluster API.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MtJFkhIIMUU2PhLd656XoQ.png" /></figure><p>In 2017 I spent an afternoon enjoying lunch at the Google office in Seattle’s Fremont neighborhood meeting with Robert Bailey and Weston Hutchins. We had connected via open source and shared a few similar ideas about <strong>declarative infrastructure</strong> built on new primitives in Kubernetes. Robert Bailey and Jacob Beacham began to spearhead the charge from Google. We slowly began to start formalizing an effort to create a system for bootstrapping and managing a Kubernetes cluster in a declarative way. I remember the grass roots nature of the project. Google began work on evangelizing these ideas within the Kubernetes community.</p><p>Following an<a href="https://groups.google.com/forum/#!topic/kubernetes-sig-cluster-lifecycle/ibVxgdLkeiM"> email to the Kubernetes mailing list sig cluster lifecycle</a>, the Cluster API working group was born. The group rapidly discovered other projects such as <a href="https://github.com/kubeup/archon">archon</a> and work from Loodse that also had similar ideas. It was clear we were all thinking of a brighter future with <strong>declarative infrastructure</strong>.</p><p>We started brainstorming what a declarative Kubernetes cluster might look like. We each consulted Kubernetes “elders” at our respective companies. The engineers at Google consulted Tim Hockin while I talked this over with Joe Beda, co-founder of Kubernetes and my long time colleague. Tim suggested we start building tooling and playing with abstractions to get a feel for what would work or not. At the time of this “sandbox” stage, we started prototyping in the <a href="http://github.com/kubernetes/kube-deploy">kube-deploy</a> repository. We needed a place to start hacking on the code and being that this feature was originally intentionally called out of scope finding a home was challenging. Later we were able to move out of that kube-deploy repository to <a href="http://github.com/kubernetes-sigs/cluster-api">cluster-api</a> which is where the code lives today.</p><p>Now “Cluster API,” which is short for “Cluster Management API,” is a great example of a bad name. As Tim St. Clair (Heptio) suggested, a better name for this layer of software is probably “cluster framework”. The community is still figuring out how we plan on dealing with this conundrum.</p><p>One of the first decisions the working group made was in regard to the scope of the API itself. In other words, what would our new abstraction be responsible for representing, and what would our abstraction intentionally ignore. We landed on two primary new resources, Clusters, and Machines. The Cluster resource was intended to map cleanly to the official Kubernetes bootstrap tool kubeadm, and the Machine resource was intended to be a simple representation of some compute load in a cloud (EC2 Instances, Google Virtual Machines, etc) or a physical machine. We explicitly decided to keep the new Machine resource separate from the existing node resource, as we could munge the two together later if necessary. According to Jacob Beacham, “the biggest motivation being that this was the only way to build the functionality outside of core, since the Node API is already defined in core.” Each Cluster resource would be mapped to a set of Machine resources, and ultimately all of these combined would represent a single Kubernetes cluster.</p><p>We later looked at implementing higher level resources to manage the Machine resource, in the same way deployments and ReplicaSets manage pods in Kubernetes today. Following this logic we modeled MachineDeployment after Deployment and MachineSet after ReplicaSet. These would allow unique strategy implementations for how various controllers would manage scaling and mutating underlying Machines.</p><p>We also decided early on that “how” a controller reconciles one of these resources is unique to the controller. In other words, the API should, by design, never include bash commands or any logic that suggests “how” to bring a cluster up, only “what” the cluster should look like after it’s been stood up. Where and how the controller reasons about what it needs to do is in scope for the controller and out of scope for the API. For example, Cluster API would define what version of Kubernetes to install, but would never define how to install that version.</p><p>With ClusterAPI, we hope to solve for many of the technical concerns in managing Kubernetes clusters, by drawing upon the lessons we’ve learned from Kubeadm, Kops, Kubicorn, and Kube-up, Gardener, etc.. So we set out to build ClusterAPI with the following goals in mind:</p><p><strong>Facilitate Atomic Transactions</strong></p><p>While keeping the spirit of planning for failure and mitigating hazards in our software, we knew we wanted to build software that would make it possible to <strong>guarantee</strong> a successful infrastructure mutation or no mutation at all. We learned this from Kops, when a cluster upgrade or create would fail partially through and we would orphan costly infrastructure in a cloud account.</p><p><strong>Enabling Cluster Automation</strong></p><p>With Cluster API we find that cluster level configuration is now declared through a common API, making it easy to automate and build tooling to interface with the new API. Tools like the cluster autoscaler now are liberated from having to concern themselves with <strong>how</strong> a node is created/destroyed. This simplifies the tooling and enables new tooling to be crafted around updating the cluster definition based on arbitrary business needs. This will change how operators think about managing a cluster.</p><p><strong>Keep infrastructure resilient</strong></p><p>Kops, Kubicorn, and Kube-up all have a fatal flaw. They run only for a finite amount of time. They all have some concept of accomplishing a task, and then terminating the program. This was a good starting point, but it didn’t offer the goal seeking and resilient behavior users are used to with Kubernetes. We needed a controller, to reconcile state over time. If a machine goes down, we don’t want to have to worry about bringing it back up.</p><p><strong>Create a better user experience</strong></p><p>Standing up a Kubernetes cluster is hard. Period. We hoped to build tooling that would go from 0 to Kubernetes in a friendly way, that made sense to operators. Furthermore, we hoped the API abstractions we created would also resonate with engineers so we could encourage them to build tooling around these new abstractions. For example, if the abstraction was user-friendly, we could port the upstream autoscaler over to using the new abstraction so it no longer had to concern itself with implementation — simply updating a record in Kubernetes.</p><p><strong>Provide a solution for cluster upgrades</strong></p><p>We wanted a turnkey solution to upgrades. Upgrading a Kubernetes cluster is tedious and risky, and having a residual controller in place not only solved the implementation of <em>how</em> to upgrade a Kubernetes cluster but it also gave us visibility into the state of the current upgrade.</p><p><strong>Bring the community together</strong></p><p>As it stands every Kubernetes installer to date represents a cluster in a different way, and the user experience is fragmented. This diminishes Kubernetes adoption and frankly pisses users off. We hoped to reduce this fragmentation and provide a solution to defining “what” a cluster looks like, and provide tooling to jumpstart implementations that solve “how” to bring a cluster to life.</p><p>All of these lessons and more are starting to sing in the Cluster API repositories. We are on the verge of alpha and beta releases for clouds like AWS and GCP. We hope that the community driven API becomes a standard teams can count on, and we hope that the community can start to offer an arsenal of controller implementations that bring these various variants of clusters to life.</p><p><strong>Going Further</strong></p><p>Learn More about the Cluster API from Kris Nova (Heptio) and Loc Nguyen (VMware) <a href="https://j.hept.io/cluster-api-kubecon-2018">live at Kubecon 2018</a> during their presentation on the topic. The talk will be recorded in case you can’t make it. We will upload the video to our advocacy site as soon as we can.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=de5a1ff870a5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/heptio-blog/the-kubernetes-cluster-api-de5a1ff870a5">The Kubernetes Cluster API</a> was originally published in <a href="https://medium.com/heptio-blog">Heptio</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[“Cloud Native Infrastructure”, a Free O’Reilly eBook]]></title>
            <link>https://medium.com/heptio-blog/i-still-remember-the-first-time-i-logged-into-a-production-server-over-ssh-and-telling-myself-i-53ab1d1e7f46?source=rss-158602cec861------2</link>
            <guid isPermaLink="false">https://medium.com/p/53ab1d1e7f46</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[ebooks]]></category>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[books]]></category>
            <category><![CDATA[infrastructure]]></category>
            <dc:creator><![CDATA[Heptio Advocacy]]></dc:creator>
            <pubDate>Tue, 27 Mar 2018 17:51:52 GMT</pubDate>
            <atom:updated>2018-03-27T19:54:00.230Z</atom:updated>
            <content:encoded><![CDATA[<p>I still remember the first time I logged into a production server over SSH. I remember telling myself how cautious I needed to be while working on the filesystem. Years later I have learned a lot about managing infrastructure. In our book “Cloud Native Infrastructure” myself and my co-author Justin Garrison talk about the patterns for managing infrastructure that we believe to be the most powerful.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/381/1*xqL4Yr_APkjpb9pA3hxuoA.png" /><figcaption>Andy O’Connor — The Andean Condor</figcaption></figure><p>In the book we talk about managing infrastructure in the cloud, and learn how infrastructure operators are now full fledged software engineers. We look at patterns that have evolved from my contributions to Terraform, Kubernetes, Kops, Kubeadm, Kubicorn and various other open source infrastructure tools. The lessons in the book are battle tested, and are used widely in production today.</p><p>I am excited that Heptio has decided to sponsor our work, and is offering a free download of our book. We worked hard on it, and hope you enjoy learning about ways to manage your infrastructure.</p><p>Get your <a href="http://go.heptio.com/cloud-native-infrastructure">free copy</a> of “Cloud Native Infrastructure” today!</p><p>Learn more about Heptio at <a href="http://www.heptio.com">heptio.com</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=53ab1d1e7f46" width="1" height="1" alt=""><hr><p><a href="https://medium.com/heptio-blog/i-still-remember-the-first-time-i-logged-into-a-production-server-over-ssh-and-telling-myself-i-53ab1d1e7f46">“Cloud Native Infrastructure”, a Free O’Reilly eBook</a> was originally published in <a href="https://medium.com/heptio-blog">Heptio</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is a monolithic application?]]></title>
            <link>https://medium.com/heptio-blog/what-is-a-monolithic-application-e375f5ad5ecb?source=rss-158602cec861------2</link>
            <guid isPermaLink="false">https://medium.com/p/e375f5ad5ecb</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Heptio Advocacy]]></dc:creator>
            <pubDate>Fri, 02 Feb 2018 17:33:18 GMT</pubDate>
            <atom:updated>2018-02-02T17:36:44.698Z</atom:updated>
            <content:encoded><![CDATA[<h4>The first step in the journey to moving monolithic apps to Kubernetes</h4><p>Throughout my career of software engineering one of the most valuable questions I’ve learned to ask a colleague is “What does $something mean to you?”. It forces the other engineer to evaluate their implications of using a certain word. Following up on the first <a href="https://blog.heptio.com/moving-monolithic-apps-e8f7483938db">Moving Monolithic Applications to Kubernetes</a> call, I wanted to spend a few minutes talking about what a monolithic application is. Or at least, what it means to me.</p><p>This is an interesting space that needs some attention. While operating a stateless microservice on Kubernetes is relatively easy, operating a large stateful application still has a long way to go. Understanding what a monolithic application is will be the first step in making the migration process easier.</p><p>In order to define a monolithic application we need to first understand the components of an application that we care about. The three components we are interested in will be the <strong>user interface</strong>, the <strong>data access layer</strong>, and the <strong>data store</strong>.</p><p>The user interface is the <strong>entry point</strong> of the application, and is also the point of the program that a user will interact with. This could be a main() function, website, web service, or various other entry points.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/901/1*zmzrlP9xH3Pg8KEB3U-c2Q.png" /></figure><p>The <strong>data access layer </strong>is the layer of the program that will wrap a <strong>data store</strong>. Typically the data access layer will handle concerns like authenticating with a <strong>data store</strong>, and sanitizing data before it’s persisted in the <strong>data store</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/805/1*cxAm5c_ifV-fCpFhIyO5gg.png" /></figure><p>The <strong>data store</strong> is the most fundamental part of the system, and is responsible for storing arbitrary information (data) and retrieving it. This component is commonly just a database.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/864/1*tJYFSfwBjok7rLIRcTUTDQ.png" /></figure><p>These three components make up a very common type of application called a <strong>stateful application</strong>. Which means, that the application stores and manipulates data over time. Therefore we say that the application has <strong>state</strong>. More importantly, that the <strong>state</strong> of the application can change over time.</p><p>In the case of a monolithic application, we commonly observe multiple layers of the application <strong>tightly coupled</strong> together. In the example below we can see that the <strong>user interface</strong> and the <strong>data access layer</strong> are grouped together. This is usually done via a large code repository, and both of these layers will probably depend on the other to be in place in order to run. Furthermore the <strong>user interface</strong> and <strong>data access </strong>layers typically are bundled into the same process at runtime. Meaning they communicate on the same system, using system resources (memory and compute cycles) to interact with other parts of the system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P77UokfGbaoskUmhlJ-gIw.png" /></figure><p>On the contrary, a <strong>microservice based </strong>application would be composed of small modular components that can easily be switched out. This offers a concept of <strong>composability</strong> for an operator and is a sign that you are working with <strong>microservices</strong> instead of a monolithic application. The example below demonstrates a flexible and modular application. Note that in this model we can run the smaller components independently and use a network to connect our system together. This approach is much more scalable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PWTMn8W9Y41lYgnmq3W82A.png" /></figure><p>So what is a <a href="https://en.wikipedia.org/wiki/Monolithic_application">monolithic application</a>? It’s a single-tiered software application in which the user interface and data access code are combined into a single program on a single platform. It’s also an application that runs multiple components in the same process, on the same system.</p><p>Moving forward we seek to understand the nuances of migrating monolithic applications to Kubernetes, and hope this is a valuable first step in our journey. As the process is relatively undocumented, we plan on sharing the lessons learned, so everyone can benefit.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e375f5ad5ecb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/heptio-blog/what-is-a-monolithic-application-e375f5ad5ecb">What is a monolithic application?</a> was originally published in <a href="https://medium.com/heptio-blog">Heptio</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Heptio Community Call]]></title>
            <link>https://medium.com/heptio-blog/moving-monolithic-apps-e8f7483938db?source=rss-158602cec861------2</link>
            <guid isPermaLink="false">https://medium.com/p/e8f7483938db</guid>
            <category><![CDATA[heptio]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Heptio Advocacy]]></dc:creator>
            <pubDate>Fri, 19 Jan 2018 17:16:48 GMT</pubDate>
            <atom:updated>2018-01-19T20:37:21.674Z</atom:updated>
            <content:encoded><![CDATA[<p>In enterprise software we have many hands at the keyboard over many years, thus it is all too common to find large applications running on mysterious systems.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*No67XCZQ_BO9W73kIQAMEA.png" /></figure><p>Migrating these applications to a distributed orchestration environment like Kubernetes is challenging, and can be overwhelming for engineers starting on the journey. Traditionally there are many mysterious components of a monolithic application built by engineers who have long since moved on from a particular codebase. Even discovering these unknown components alone can be daunting, let alone trying to learn an entirely new ecosystem of cloud native orchestration technologies at the same time. I decided to reach out and see what the rest of the open source Kubernetes community had to say about the matter.</p><p>In December of 2017 I (as Senior Developer Advocate — <em>Heptio</em>) started a <a href="https://twitter.com/Kris__Nova/status/943496609110749184">Twitter conversation</a> that ultimately produced an <a href="https://www.youtube.com/watch?v=4yD6e8r6zGs&amp;t=2s">impromptu community call</a> with other engineers looking to move monolithic applications to Kubernetes. The meeting had over 80 confirmed attendees, was recorded, and is now <a href="https://www.youtube.com/watch?v=4yD6e8r6zGs">hosted on YouTube</a>. The raw notes from the meeting are also <a href="https://docs.google.com/document/d/1hfOUrMso9vlC9HXHqyxAyolPdcrqBPtNLNwPnSEoM0o/edit">publically available in a Google Document</a>.</p><p>The meeting was informative, and presented new ideas and questions in the space. We were also able to call out a number of action items to benefit the community moving forward.</p><p>Introducing a new Heptio Community Call — <em>Moving Monolithic Applications to Kubernetes.</em></p><p>At Heptio, we have decided to start sponsoring this open, community- driven program aimed at sharing efforts, thoughts, ideas, and experiences for moving large and clunky applications into discreet microservices running in Kubernetes.</p><p>How to participate:</p><p>We have created a<a href="https://groups.google.com/forum/#!forum/monolithic-apps-to-k8s"> public mailing list</a> that <strong>everyone is welcome to join</strong> for open discussion on the topic. By joining the mailing list you will implicitly get a calendar invitation for the <strong>bi-weekly</strong> call that occurs <strong>every other week at 1pm Pacific Time</strong>. We will host a <strong>recorded </strong><a href="https://zoom.us/j/538875715">zoom call</a> with the recordings posted in our YouTube channel “<a href="https://www.youtube.com/playlist?list=PLvmPtYZtoXOG4dgpYIU2OJuDryMhEYyPw">Moving Monolithic Applications to Kubernetes</a>” and work out of a <a href="https://docs.google.com/document/d/1hfOUrMso9vlC9HXHqyxAyolPdcrqBPtNLNwPnSEoM0o/edit">publicly available Google Document</a> for minutes and notetaking.</p><p><strong>Debrief from the original call</strong></p><p>We started the call with a quick round of introductions, then jumped into defining what<strong> </strong>a <strong>monolithic application</strong> meant to us. We discovered that most monoliths are built from a single source tree and small components of the application interact using system resources at runtime. We suggested that <strong>network traversal might be a clue in defining a monolithic vs non-monolithic application</strong>. That is to say that smaller components of a monolithic application use system resources from a single system like compute cycles and memory to interact with each other while smaller microservice based applications will likely use a network as the mesh to combine small components to form a larger application. We also called out how entry points into monolithic applications are usually a nuisance and will likely need to be adjusted as the application is broken into smaller pieces.</p><p>We spent a large portion of the call discussing monitoring and observability in Kubernetes. Particularly about what users are doing today with their monolithic applications, and what the ideal setup in Kubernetes looks like. The primary takeaway from this discussion was the problem with host-centric tooling that is used today. Primarily that if a <strong>tool assumes it will be able to take ownership of a node, it will usually not work as intended in Kubernetes</strong>. This is evident in monitoring as scheduling multiple monitoring pods on the same node might be a waste of resources and might introduce erroneous data. We took an action item to follow up with user experiences on ways others have solved this.</p><p>The last major topic was bringing up how moving a monolithic application is different than moving a smaller application already structured for orchestration. The glaring issue was a need to audit the systems running the monoliths. Even discovering what dependencies are needed on the host system was a large amount of effort for engineering teams. After ensuring that all dependencies were met and being tracked somewhere a user could then begin to audit the application itself to ensure it would behave as expected in Kubernetes. One of the examples brought up was what if an application was <strong>mostly</strong> working and the process did not exit despite their being data loss or corruption along the way. Kubernetes would ensure the pod is healthy, and take no action on a pod desperately needing to be restarted. These are all concerns a user looking to migrate a monolithic application might face that others would not.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F4yD6e8r6zGs%3Fstart%3D10%26feature%3Doembed%26start%3D10&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D4yD6e8r6zGs&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F4yD6e8r6zGs%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/da19efea36bc5927d9b7ce5c042470be/href">https://medium.com/media/da19efea36bc5927d9b7ce5c042470be/href</a></iframe><p>As with the original call, this is a community resource effort that is designed to help the broader health of the Kubernetes open source community. The call is a technical call, and is open to anyone with an interest in the topic, all experience levels are welcome.</p><p>For questions or comments please feel to reach out to me knova@heptio.com.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e8f7483938db" width="1" height="1" alt=""><hr><p><a href="https://medium.com/heptio-blog/moving-monolithic-apps-e8f7483938db">Heptio Community Call</a> was originally published in <a href="https://medium.com/heptio-blog">Heptio</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>