Understanding Kubernetes’ value
From Virtual Hosts to Virtual Machines to Containers and Kubernetes.
(Originally published 2019 January 24, on Medium)
Over the last couple of years, Kubernetes has been one of the few new technologies that established itself as the de facto standard in its field. To understand why Kubernetes is such a transformative evolution, let’s take a little journey down virtualization memory lane. For the sake of brevity, we will over-simplify the various architecture types to highlight their core characteristics and evolutions.
One to One
At the beginning of microcomputers, physical hardware was mostly used with one and only one operating system, and most applications such as databases, web servers, and websites usually had a single end-user application purpose, at least in production.
This meant that when a business needed to deliver or host a “pet.com” and a “food.com” end-user applications, the common production architecture was to have a dedicated server(s) for each application. As the end-application load requirement increased, horizontal layers were split apart in their own servers; but overall, the one-to-one relationships still remained.
Dedicated ServersWhile this worked relatively well for bigger, simple three-tier architecture applications, the low service granularity (i.e., dedicated server(s) per application) made resource utilization sub-optimal and scaling slow and costly, as adding new resources could take days and oversizing hardware resources were common practice to mitigate handling peak demand. In short, those were the costly days of building internet services.
“Application Virtualization” (e.g., Virtual Host)
To increase service granularity, most infrastructure applications, such as web servers and databases, offered some sort application compartmentalization capabilities, allowing one infrastructure application process to support multiple front-end applications. In the web server world, this is called virtual hosts, where one web server can serve multiple websites based on domain names, whereas in the database realm, a single database server could offer completely isolated logical database instances on the same server/port.
Those application virtualization capabilities allowed many businesses to deploy logically isolated applications, or at least provide the illusion of isolation while utilizing the same physical resources.
Anecdote: In my early Netscape days - the late 90s - Apache Virtual Hosts support was one of its killer features compared to Netscape Enterprise Server, which could serve only one site per port. Apache ate our lunch in the web site service providers’ space.
As in the previous model, when throughput requirements increased, each of the horizontal layers were split out in their own server while still serving multiple applications. Some applications, such as databases, started to offer more advanced horizontal scaling with their clustering capabilities, allowing one logical database to span across multiple hardware resources, enabling further hardware specialization and more optimum resource utilization.
While these techniques increased service granularity and improved resource utilization, it came at the cost of software architecture and deployment complexity. That added complexity and inter-dependencies made scaling service more of an art exercise than a good engineering one. Although early hosting companies did manage to offer web hosting as a service, it did not come without some serious elbow grease.
In other words, these were the days in which the internet was complex and brittle.
Virtual Machine
As Linux gained more popularity on the server, so did operating system virtualization, which allowed a single hardware to host multiple operating systems. With this new model, each system or application could have its own operating system and environment while still sharing the same hardware resources.
Note: Technically, virtual machine techniques were pioneered in the 60s by IBM; but in this context, it is fair to state that Linux (and Windows, in some respect) popularized the concept of full OS virtualization.
This new model maximized resource utilization and simplified application architecture back to their original form by removing inter-system dependency, but the most transformative consequence of these new capabilities was the formation of new IT operations driven by the Amazon Web Service and the like, which abstracted all of the hardware provisioning and networking complexity to offer a connected internet operating system as a service. With these new hosted or on-premise services, software organizations could then focus on what they knew best; software, and let the few hardware and networking experts build and scale the backbone of those services.
However, as hosted infrastructure services got more sophisticated, so did applications, which started to move from their traditional three-tier monolith architectures to multi-service ones (e.g., micro-service), and designing, deploying, and managing scalable multi-service applications in a cost-effective manner became relatively complex and highly cloud-specific.
Containers
The industry resolved the virtual machine model limitation for micro-service architecture with a rather ancient Linux capability that allowed operating system processes to be boxed into a subset of the operating system resources on a single operating system; and so, the next chapter in virtualization, containerization, was born and mostly won by the now ubiquitous Docker container format.
With containerization, applications could now be architected with the optimum set of services for their needs while trusting that the technology will compartmentalize those services in the most efficient manner. What used to take days in the old physical hardware era and minutes in the virtual machine days, are now only taking sub-seconds with a minimal (i.e. reasonable) memory footprint.
While containerization dramatically improved service granularity (i.e., resource utilization), optimized sophisticated application architectures, and normalized service runtime across development and production, the sheer volume of those new parts added significant deployment management complexity and configuration challenges. Scaling a production system still required cloud-specific techniques to scale the underlying virtual machines with the added complexity of deciding where and when to create new service containers.
In summary, containerization was instrumental but needed something else to realize the true value proposition.
Kubernetes
This is where Kubernetes came in and completed the puzzle. Based on containers, Kubernetes is a service (sometimes called “engine”) that provides a way to describe, manage, and run a complete system with all of its parts (i.e. micro-services), interactions, and scaling rules in a standard and environment-portable manner.
Whereas previously the development, staging, and production environments heavily differed, Kubernetes’ new approach normalized and streamlined how a complete system could be described, ran, and scaled which dramatically reduced the cost of building and managing multi-service system.
Note: Google Cloud Platform, creator of Kubernetes, has a state-of-the-art implementation of Kubernetes, and while Kubernetes has become a very well-supported de facto standard on all major cloud platforms such as Amazon Web Service, Azure, and IBM, getting started with Google Cloud often provides the best learning experience. For example, Google Kubernetes Engine provides excellent support for node auto-scaling.
It is important to understand that all of those technological milestones have been evolutive and additive and typically used in concert with one another. From a purely technical point of view, the revolution is in the evolution and not in the disruption. Containers typically run on virtual machines (although they can run on bare metal as well), virtual machines still run on a main operating system (called a host) running on a physical server, and many infrastructure applications such as databases, web servers, and caches still provide useful and sometimes critical application-specific clustering and compartmentalization capabilities.
Putting all of the scorecards together, we can see how all the virtualization technologies stack up.
While Kubernetes has been the result of an evolution rather than disruption, its business values are nonetheless transformative.
Here are the key business values of Kubernetes:
Normalize Dev to Ops: Since Kubernetes is infrastructure-independent (i.e. it can run on the cloud, on-premise, or even on a laptop), it provides a very robust and flexible way to normalize the development and operations environment, which is probably one of the most important attributes in a high-velocity development methodology.
Eliminate multi-service overhead: Just a couple of years ago, moving from monolith architecture to the micro-service one, while the right architectural move, did come with significant development and operational setup frictions. Kubernetes is designed from the ground up to tackle these requirements in an exhaustive and relatively simple way, and used correctly, completely eliminates that overhead. For example, at BriteSnow, all our new architecture are now multi-service from the get-go, even though we often start a new “big app” with a relatively “small team.”
Maximize Cloud portability: One of the most impressive accomplishments of Kubernetes is that in just a few years, it took the industry by storm and made everybody, from the major cloud providers to hybrid cloud technology providers, race to add their support in the new standard. This has put Kubernetes as the cornerstone of cloud portability and allows most of the modern cloud applications to express 80% to 90% of their system and scalability topology in a cloud-portable manner.
Trivialize and standardize scalability: Part of the value of cloud portability is the standardization of common and custom scaling rules that make scaling a multi-service system exponentially simpler while still providing the customization hook when needed.
I am usually very cautious about jumping onto the latest “trendy” technology bandwagons, as more often than not, while exhilarating, they tend to be relatively ephemeral. However, once a while, a technology becomes “trendy” for of all of the right reasons, and Kubernetes is one of the few that is being cemented as foundational technology like Linux, OS virtualization, and Git once were in their own field.
In short, Kubernetes is probably the safest investment any cloud application development organization could make today and one that, if applied right, can dramatically increase the speed and quality of development and delivery.