Introduction to Kubernetes

Containerization has set the gold standard for deploying applications on both on-premises and cloud environments. As microservices architecture becomes more popular, people increasingly embrace containerization because it naturally fits this architectural approach.

Containerization brings many advantages:

1. It guarantees portability. This technology’s inherent isolation lets developers deploy their application code on various environments and operating systems without worrying about compatibility.
2. It boosts scalability. Developers can deploy containers quickly and repeatedly. Unlike virtual machines, containers don’t require booting up an entire operating system, letting developers scale up or down quickly by adding or removing containers on single or multiple machines.
3. It enhances fault tolerance. Because each container operates in isolation, one malfunctioning container doesn’t affect others on the same machine. Using the agility containerization offers, developers can quickly swap out faulty containers for working ones.

The three benefits highlighted above barely scratch the surface of the vast advantages containerization offers. Containerization’s versatility and adaptability make it a favored choice among developers. Moreover, as we delve deeper into its potential, we realize the myriad ways it revolutionizes software deployment.

However, as applications scale, managing containers can become challenging. Many modern, production-grade applications using this technology deploy hundreds, if not thousands, of containers. This challenge isn’t unique to containerization but also extends to microservices as a whole. Imagine managing dozens or hundreds of virtual machines, each hosting tens or hundreds of containers. This is where Kubernetes steps in.

What is Kubernetes?

Kubernetes is an open-source container orchestration tool. At a high level, Kubernetes streamlines the automation, scaling, and oversight of containerized applications. In any production environment, the critical objective is maintaining container operations with minimal downtime. Without Kubernetes, when a container fails or becomes unresponsive, developers would have to manually restart it or initiate a new and functioning one to minimize disruptions. While this might seem straightforward, consider the complexity of overseeing numerous containers spread across diverse physical and virtual machines in both on-premises and cloud environments. It’s in these situations that a container orchestration tool such as Kubernetes comes in handy.

Kubernetes offers several notable benefits:

1. Self-healing — Kubernetes actively monitors the health of each container within its cluster of servers (nodes). If a container fails or becomes unresponsive, Kubernetes can restart or terminate it based on the specified configuration.
2. Automatic bin packing — Kubernetes efficiently allocates CPU and memory resources to each container based on configurations set by developers. It strategically places containers on servers (nodes) to maximize the utilization of underlying resources.
3. Storage orchestration — Kubernetes supports persistent storage, integrating seamlessly with both on-premises and cloud storage solutions.
4. Load balancing — Kubernetes actively observes the traffic directed toward each managed container. Kubernetes balances and distributes traffic across containers based on the set configuration, ensuring application stability.
5. Automated rollouts and rollbacks — Managing container states in Kubernetes is straightforward. Kubernetes easily deploys new features or updates container images across hundreds or thousands of containers. Moreover, it provides the flexibility to roll back deployments using various deployment strategies.
6. Secret and configuration management — Kubernetes securely handles secrets and sensitive information, including passwords, OAuth tokens, and SSH keys. When secrets update, there’s no need to rebuild container images. Kubernetes ensures this update happens discreetly without exposing secrets in its configuration.

How does Kubernetes Work?

At a high level, deploying Kubernetes means deploying a cluster. A Kubernetes cluster consists of at least one control plane and a set of servers, referred to as “worker nodes”. It’s on these worker nodes that containerized applications run, consuming most of the cluster’s computational resources. Every Kubernetes cluster should have at least one worker node. The control plane is also hosted on a server. However, its components differ from those of a worker node. In a production environment, it is best practice to host the control plane on multiple machines to provide fault tolerance and high availability.

Moreover, in Kubernetes, the smallest deployable unit is a Pod. A Pod contains one or multiple containers that are tightly coupled with each other. Pods are deployed in worker nodes, and it’s crucial to recognize that Pods should remain stateless. The Kubernetes API can terminate, update, or instantiate a Pod at any moment, and given that a Pod is ephemeral, it’s vital to ensure that critical data isn’t stored solely within it. Instead, any persistent data should be stored in external storage systems, ensuring that it remains intact even if a Pod is replaced or removed. This approach not only safeguards data but also ensures smooth scaling, updates, and recovery in Kubernetes environments.

The illustration below basically shows the architecture of a working Kubernetes cluster:

Components of the Control Plane

The control plane acts as the brain of the Kubernetes cluster. With its components, it makes crucial decisions and governs all activities within the cluster.

These are the fundamental components of a Kubernetes control plane:

1. kube-apiserver — This component exposes the Kubernetes API and acts as the front-end of the Kubernetes cluster. Users can query and modify the state of API objects in Kubernetes (like Pods, Namespaces, ConfigMaps, and Events) through the Kubernetes API, typically accessed using the kubectl command-line interface or other command-line tools.
2. etcd — This is a key-value store that holds all the Kubernetes cluster data. It serves as a repository, preserving snapshots of the cluster’s states and vital details.
3. kube-scheduler — This component is responsible for deploying newly created Pods to worker nodes. It evaluates complex criteria to determine the placement of Pods. These criteria encompass individual and collective resource demands, hardware/software/policy constraints, affinity and anti-affinity rules, data proximity, and inter-workload interference.
4. kube-controller-manager — This component operates as the control loop of the Kubernetes cluster, running its controller processes. It is the brain behind the orchestration; It constantly observes the cluster’s present state and interacts with the apiserver to achieve the targeted state.
5. cloud-controller-manager — This optional component links cloud-specific control logic to the Kubernetes cluster. It facilitates communication between the cloud provider’s API and the Kubernetes cluster. If the cluster is running on-premises, the cluster does not have a cloud-controller-manager.

Components of a Worker Node

As stated above, worker nodes shoulder the majority of the cluster’s compute capacity. These nodes can be physical or virtual machines that communicate with the control plane. Pods are deployed in these worker nodes, which run the application code.

These are the core components of a Kubernetes worker node:

1. kubelet — This is an agent installed in each and every worker node. It is the component that communicates with the control plane’s apiserver. It manages all the containers that are deployed in a node and ensures that they are encapsulated inside a Pod. Containers not deployed through Kubernetes are not managed by the kubelet.
2. kube-proxy — This component ensures the communication between Pods. It is responsible for making network rules on nodes. These rules allow network communication to Pods from sessions inside or outside of the cluster.

Conclusion

Kubernetes has emerged as a transformative force in software deployment, addressing the complexities and challenges posed by containerization and microservices. By offering an efficient, robust, and scalable solution, Kubernetes simplifies container orchestration and fortifies applications to ensure they’re fault-tolerant, agile, and resource-optimized. Its architecture, comprising both the control plane and worker nodes, is meticulously designed to manage the containerized applications’ lifecycle seamlessly. As applications evolve and grow in complexity, Kubernetes stands out as an indispensable tool for modern developers, ensuring that software delivery is smooth, efficient, and resilient. Whether you’re a developer, an IT professional, or a business leader, understanding and harnessing the capabilities of Kubernetes is paramount for staying at the forefront of technological advancement.

References:

https://kubernetes.io/docs/concepts/overview/

https://kubernetes.io/docs/concepts/overview/components/

https://aws.amazon.com/what-is/containerization/