decorative image for blog on kubernetes
December 8, 2020

What Is Kubernetes?

Open Source

Kubernetes is a tool for elegant orchestration of complex business requirements, such as highly-available microservices, and is one of the enabling technologies of the 12-factor application.

Kubernetes, as the most popular container orchestration platform, plays an integral role in orchestrating many enterprise applications. For those considering Kubernetes, it's good to have a basic understanding of how Kubernetes works, and why it has managed to claim such a large market share. Let's start with a comparison.

Kubernetes Is...NASCAR?

The definition of Kubernetes we listed at the start of the blog is well known in many business technology communities. However, a second statement (while less recognized) is just as important:

Kubernetes is NASCAR.

I should clarify that I don’t mean Kubernetes is NASCAR in the same way that Kubernetes SIG Security co-chair, CNCF Ambassador, and chaotic goose Ian Coldwater means this, which is that there are so many logos vying for eyes in the Cloud Native landscape that it would make even the ghost of Ol’ Dale Earnhart blush.

What I mean by this statement is that the architecture of Kubernetes is all about these steps:

  1. Go really fast.
  2. Make a left.
  3. Do it all over again, at breakneck speed, as fast as possible, not stopping the race for crashes.

So, in essence, Kubernetes is NASCAR.

Kubernetes Platform Overview (Going Really Fast, Making a Left)

Everything (!) in how Kubernetes is implemented comes down to GoLang goroutines. If you’re not from a team that’s doing Go(lang), you might be more familiar with the now-ubiquitous programming model of Node.JS’s event-loop architecture for web, except goroutines are way more performant.

Why does Kubernetes need a performant concurrency system? Because Kubernetes, as a platform, orchestrates the events required to reach an eventually consistent (read: future) state described in YAML or JSON by the Kubernetes API.

Let’s take a look at the basic unit of Kubernetes, the Pod:

screenshot of code for kubernetes pod

If I send this API object to Kubernetes, the responsibility of Kuberenetes will be to ensure that the state described in the API object is represented in the system. In this case, that there’s a Pod (collection of containers) named ‘postgres’ running the ‘postgres’ image and listening for that traffic on port 5432, checking that the port is listening after 5 seconds, and every five seconds thereafter, and finally running the command ‘pg_isready’ to ensure that, at the application level, postgres is ready to handle requests on that listening port.

Lots of work to do! And that there might be thousands of these pods, and thousands more still of other API objects such as Deployments, ReplicaSets, Persistant Volume Claims, Services, and more? To think that all of this state management can happen on much smaller virtual (!) hosts than you might expect.

The Kubernetes Control Plane () takes care of this at breakneck speed, asynchronously firing off events to other parts of the system, which process these requests in order. If the previously instantiated postgres container crashes (into a barrier wall, to the cheer of the crowd)? The Kubernetes Control Plane immediately (without remorse, or pause for reflection, the trophy in glinting in their eyes) fires off an event to begin working towards rebuilding the state requested.

Kubernetes in one thought? Eventually-consistent orchestration of containers and supporting elements by a fast event loop. In one word? NASCAR.

Is Kubernetes Free?

Kubernetes is a free and open source software derived from Google’s Borg code, with an initial release in June of 2014
image showing event-loop for resource lifecycle in kubernetes control plane
The original event-loop still used to describe the lifecycle of any resource in the Kubernetes Control Plane via

Kubernetes is free to use for all organizations, and uses the is released under the Apache 2.0 license. There are many contributors and a plethora of vibrant communities supporting it. As enterprise-grade software build for the enterprise, there’s quite a few players participating and vying for attention in the marketplace (see NASCAR).

What Is Kubernetes Used For?

Kubernetes is used for orchestrating server resources to be highly available and up to date. It is, after all, cluster management software at it’s core.

However, the original intention behind Kubernetes was to fulfil large organizations' desires to implement concepts like DevOps and the 12-Factor Application without having to re-invent the wheel. It’s an open source standard for accomplishing the architectural patterns required to do both DevOps and 12-Factor.

How Does Kubernetes Container Orchestration Work?

Kubernetes, specifically the Kubernetes Control Plane, is composed of a component services following the event-loop architecture:

image showing event loop architecture in Kubernetes Control Plane
Image via
  1. kube-api-server
  2. kube-controller-manager
  3. kube-scheduler
  4. kubelet
  5. kube-proxy
  6. kube-dns
  7. etcd

All together, they’re responsible for ensuring that any API objects we send the kube-api-server get implemented as running containers and component services.

Kubernetes Features and Benefits

If you’re asking yourself why you might want to use Kubernetes, ask yourself instead how you’re supposed to achieve all of this at once:


Kubernetes Feature

Dump the big-iron mainframe!

Runs on commodity hardware in any public or private cloud

Reduce cloud costs!

Improves elasticity of resources

Keep my CISO happy!

Security quality gates for deployed software, rolling patching of deployments

Keep my developers happy!

One of the most in-demand technologies and skills

Keep my QAC team sane!

Enables CI/CD and DevOps practices at scale

Achieve web-scale!

Horizontal Pod Autoscaling scales with sensors like CPU use, (autoscaling/v1) or whatever you choose (autoscaling/v2beta2)

Future-proof my storage strategy while capitalizing on existing investments!

Persistent Volume Claims, and auto-provisioning of SAN resources, like Trident for NetApp

Final Thoughts

Kubernetes is here to stay, and will be relevant for a long, long time. It’s only going to get more important as architectures change to ARM in the datacenter: concurrency is king.

With as many logos on it’s jacket as we’ve shown, it’s going to be very important to a lot of people. Yes, more important than NASCAR.

Get Expert Guidance and Support for Kubernetes

If you're considering Kubernetes for your application, OpenLogic can help plan and support your journey. Talk to an expert today to see how OpenLogic can help.


Additional Resources

Looking for additional reading on Kubernetes, containers, or container orchestration? These resources are worth your time: