What is Kubernetes, and why should I learn it?

Kubernetes (K8s) is one of the top tech skills worth learning in 2023, with the number of open jobs calling for K8s experience jumping by 11% last year. In this article, Kubernetes expert and best-selling author Nigel Poulton answers some common questions about this platform, its benefits and limitations, and what learning resources you can use to get started.

• What is Kubernetes?
• A brief history of Kubernetes
• What is a Kubernetes cluster?
• What is a Kubernetes node?
• What is “managed Kubernetes”?
• What is kubectl?
• What are the benefits of Kubernetes?
• What are the limitations of Kubernetes?
• What is Kubernetes used for?
• What's the difference between Kubernetes & Docker?
• What do I need to know to start learning Kubernetes?
• What Kubernetes certifications are available?
• Where can I learn Kubernetes?

Kubernetes is an open-source platform for deploying and managing containerized applications. At a high-level, Kubernetes is two things:

    1. A cluster

    2. An orchestrator

A Kubernetes cluster has one or more machines that provide CPU, memory and other things required to run applications. The orchestration element implements the intelligence to manage applications.

Kubernetes started life inside of Google where it was designed as a container orchestrator building on lessons learned from other internal Google technologies such as Borg and Omega.

Kubernetes was released to the community as an open-source project in the summer of 2014.

In March 2018, Kubernetes became the first project to graduate from the Cloud Native Computing Foundation (CNCF). Graduation signifies strong project governance, maturity, and that a project is considered ready for production.

Kubernetes is now a mature technology that averages three releases per year. Releases are backwards-compatible with well-established policies for adding and deprecating features.

2020 was a major year for Kubernetes adoption. Most of the major clouds offered managed Kubernetes services designed to make it as easy as possible for individuals and organizations to get started with Kubernetes.     

As a side note, the original founders of Kubernetes wanted to call it "Seven of Nine" after the Borg drone from Star Trek Voyager. However, due to copyright restrictions, the founders decided to call it "Kubernetes" based on the Greek word for helmsman. However, they gave the Kubernetes wheel logo seven spokes, instead of the traditional six or eight, as a subtle reference to "Seven of Nine."

A Kubernetes cluster is one or more nodes working together to run containerised applications. Control plane nodes implement intelligence such as scheduling, self-healing, and auto-scaling. Worker nodes provide the CPU, memory and networking required to execute user apps.

Kubernetes is a cluster of nodes that host user applications. Nodes are either control plane nodes that implement Kubernetes intelligence, or worker nodes that host user applications. Both types can be physical servers, virtual machines, cloud instances, and even things like Raspberry Pis.

Control plane nodes (formerly called masters) run the control plane services, which can be thought of as the brain of Kubernetes. These services include the scheduler, the API server, and the cluster store. You should deploy three or five control plane nodes and spread them across fault domains for high availability.

Worker nodes are where user applications run. The size and number of worker nodes in a cluster will depend on application requirements. However, you should also spread them across fault domains so that application high availability can be maintained.

Every Kubernetes cluster implements a special network called the pod network. This is a large flat network, often a VXLAN overlay network, that spans all nodes in the cluster. Every application pod is deployed to the pod network, meaning every application pod can talk to every other application pod. Out-of-the-box the pod network is usually wide open with no security. In production environments you should use Kubernetes network policies and other technologies to secure it.

A Pod is the smallest unit of deployment in Kubernetes. For example, if you have a web container that you need to deploy to Kubernetes, you have to deploy it inside a Pod. If you need to scale the web service up or down, you add or remove pods. The simplest Pods run a single containerised app, however, more complex patterns exist where a single pod runs multiple complimentary containers.

Building your own Kubernetes clusters can be hard. For example, you have to size them for high availability and application performance. You also have to take care of day-to-day operational tasks such as updates, patching, certificate management and more.

Managed Kubernetes is a model where a cloud provider hides all of this complexity from you and provides you with a secure API endpoint for you to just use your cluster.

You pay a premium for managed Kubernetes, but it's as close to zero-effort Kubernetes as you'll get.

Kubectl is the official Kubernetes command-line utility. It's used to manage elements of Kubernetes infrastructure as well as deploy and manage user applications. It's available on Windows, Linux, macOS, and other platforms and is typically installed on a machine outside the cluster such as an admin laptop.

Kubernetes is often referred to as the "OS of the cloud". This is because it abstracts infrastructure in much the same way as a traditional OS like Linux or Windows. There are a lot of benefits to running Kubernetes, including infrastructure abstraction, orchestration at scale and a common API.    

Consider how an operating system works. Developers can write applications to run on Windows without having to care about the specifics of underlying server hardware. Servers and VMs can even be upgraded or swapped out without the app developer having to change the app.    

It's much the same with Kubernetes. As long as apps are designed to run on Kubernetes, it's possible to change the underlying cloud or hardware platform without having to change the app. This abstraction of underlying infrastructure can simplify the process of migrating apps from one cloud to another.

Kubernetes also implements features such self-healing and dynamic auto-scaling that enable management of containers at scale.

The popularity of Kubernetes has created an environment where many new products and technologies come to Kubernetes first and are often designed specifically for Kubernetes. These are often exposed via the Kubernetes API so they strongly resemble native Kubernetes features.

Two of the most common limitations associated with Kubernetes are the steep on-ramp and its container-centric view.

Kubernetes is notorious for having a steep learning curve and on-ramp. Still, Kubernetes has become significantly simpler in recent years. The core Kubernetes project itself is easier to install and maintain, while major cloud platforms and their managed services take much of the effort out of using Kubernetes.

While Kubernetes can orchestrate virtual machine workloads, serverless workloads, and WebAssembly workloads, much of its DNA is tuned to work with containers. For example, WebAssembly workloads start incredibly fast and enable true scale-to-zero event-driven architectures. However, Kubernetes was built to manage containers that have significantly longer start times and aren't well-suited to scale-to-zero or true cold starts. 

That said, Kubernetes is under constant development and there's no reason to believe it won't adapt to be better suited to new technologies and patterns.

Kubernetes use is on the rise across almost all verticals thanks to its stability and maturity, as well as the many tools that enhance it. In very broad terms, Kubernetes simplifies scalability and productivity for enterprise applications. In the past couple of years, it’s become more common for organizations to lead with Kubernetes as their orchestration platform of choice.

One area where Kubernetes has seen slower adoption is edge computing and other resource-constrained environments. This has been primarily due to containers being too big and resource intensive. 

However, more powerful edge devices and smaller Kubernetes distros are changing this. For example, it's becoming more common for lightweight Kubernetes distros such as K3d, KubeEdge, or MicroK8s to deploy and manage small containerised applications to edge and IoT devices.

In the past Kubernetes and Docker competed to be the dominant container orchestrator. To make a long-story short, Kubernetes won, and the two technologies now do different, but complimentary, things.

Docker is the most popular and most loved container development tool, whereas Kubernetes is the most popular container runtime tool. This makes it common for individuals and organizations to develop their apps using Docker, but to run them using Kubernetes.

When learning Kubernetes it's vital that you're open to new concepts as well as new technologies. In fact, it's common for the concepts to be harder to grasp than the technologies.

On the technology side, it helps if you understand how containers work and have some hands-on experience with them.

On the concepts front, Kubernetes forces you to adopt microservices design patterns, infrastructure as code, and immutable infrastructure. These require you to change your mindset as well as a lot of your existing practices. 

As a quick example, you should avoid logging-on to live systems to perform updates or fixes. Instead, you should test updates and fixes in a separate environment, save them in a version control repository, then use a GitOps tool to push them to the live environment. This ensures your source repositories and live environments are always in sync.

Sometimes the jargon creates friction, but once you grasp and embrace the concepts the rest is easy.

There are two major paths to Kubernetes certification.

    1. Official CNCF certifications

    2. Platform-specific certifications

The official CNCF certifications test your mastery of Kubernetes. Those skills can be applied wherever Kubernetes is deployed. The official CNCF certifications are as follows.

1. Kubernetes and Cloud Native Associate (KCNA). This is a multiple choice proctored exam with no hands-on elements.

2. Certified Kubernetes Application Developer (CKAD). This is a simulator-based hands-on proctored exam.

3. Certified Kubernetes Administrator (CKA). This is a simulator-based hands-on proctored exam.

4. Certified Kubernetes Security Specialist (CKS). This is a simulator-based hands-on proctored exam.

Platform specific certifications exist for most of the major cloud platforms and test your mastery of Kubernetes using the particular cloud's implementation and associated tooling.

Both A Cloud Guru and Pluralsight offer comprehensive introductory courses on Kubernetes. Additionally, they both provide courses to help you earn official Kubernetes certifications, such as the Certified Kubernetes Administrator exam (ACG, Pluralsight).

Other Kubernetes learning resources:

• Quick Start Kubernetes

• The Kubernetes Book

• Exploring Kubernetes’ official documentation