A Solution Architect’s Deep Dive Into the Kubernetes Architecture and Its Benefits

By 2021, 96% of organizations that participated in the 2021 the Cloud Native Computing Foundation survey were using or evaluating container technology. In its 2022 Container Report, Datadog found that nearly half of all organizations using containers were running Kubernetes® (also referred to as K8s) to deploy and manage at least some of those containers.

Despite the widespread growth of containers and Kubernetes, we’ve found that some organizations still don’t fully understand its capabilities. As a result, they’re not getting everything they can out of this powerful technology. Some of the capabilities that organizations may be missing out on include automation, self-healing, protection from data loss, and its cost-efficient performance across multicloud and multitenant cloud environments.

In this blog post, I hope to provide a thorough overview of Kubernetes and fill some knowledge gaps so that your organization can capitalize on the opportunities this powerful container technology provides.

Why Kubernetes?

Kubernetes is an open-source container orchestration platform for containerized workloads and service management. It automates the lifecycle of containerized applications on modern infrastructures, essentially operating like a data center operating system by managing applications across a distributed system.

Kubernetes does an outstanding job of automating containerized environments, which, in turn, allows organizations to save time and boost their productivity. What’s more, organizations can easily containerize workloads and set them on automatic.

Most of our clients ask us to deploy Kubernetes in their environment and to train their engineers after deployment. This is handled by a Rackspace Elastic Engineering team, which delivers its flexible services until clients feel self-sufficient. Some clients, on the other hand, want Rackspace Technology to completely manage Kubernetes for them so they can focus on other aspects of their business. These customers engage with us through our Rackspace Managed Platform for Kubernetes service.

What are some key features of Kubernetes ?

This container technology delivers six essential features:

1. Container orchestration: Automates the deployment, scaling and load balancing of containerized applications.
2. Declarative configuration: Allows you to declaratively define the desired state of your applications and infrastructure, making them easier to manage and maintain.
3. Service discovery: Includes a mechanism that allows applications to find and communicate with each other.
4. Load balancing: Distributes traffic across multiple instances of an application and includes built-in load balancing.
5. Automatic scaling: Scales applications automatically based on resource use or other metrics.
6. Rolling updates: Updates applications without downtime.

What is the Kubernetes master-worker node architecture model?

The Kubernetes architecture is built around a master-worker node model as seen in this diagram.

1. Kubernetes master node: The master node (also referred to as the control plane node) is in charge of managing the cluster and its resources. This control plane serves as the cluster’s central nervous system. It oversees managing the cluster’s state, scheduling applications and handling node communication. The master node also stores and manages the cluster’s configuration data.

Key elements of the master node include:

• API server: This is the master node’s central component, exposing the Kubernetes API to other cluster components. The API server handles all communication between cluster components.
• Etcd: This is a distributed key-value store that is used to store cluster configuration data. It’s an essential component of the Kubernetes master node because it stores the cluster’s state.
• Scheduler: The scheduler oversees the assignment of pods to cluster nodes based on resource availability and workload requirements. To ensure that the cluster runs efficiently, the scheduler makes intelligent decisions about where to place workloads.
• Controller manager: This function oversees the management of the various controllers that keep the cluster in its desired state. The controller manager also contains the replication controller, which ensures that the desired number of replicas are always running.

The master node’s roles and responsibilities include:

• Cluster administration: Oversees the overall state of the Kubernetes cluster. It ensures that all nodes in the cluster are operational, and that the configuration data is current.
• Resource allocation: Oversees resource allocation management across the cluster, ensuring that workloads are distributed evenly across available nodes and that the cluster runs at maximum efficiency.
• Scaling: Oversees scaling the cluster up or down based on workload. It can add or remove nodes as needed to keep the cluster running at maximum capacity.
• High availability: Delivers high availability to keep clusters running even if one or more nodes fail by employing replication and failover mechanisms.

2. Kubernetes worker nodes: A worker node (sometimes referred to as a minion node) is a cluster component that runs containerized applications. It carries out tasks delegated by the control plane, such as running containers and managing storage.

A worker node can be either a physical or virtual machine running the Linux® or Windows® operating system. Each worker node has a set of hardware resources that can be allocated to containers, such as CPU, memory and storage.

The worker node is powered by an operating system that provides the underlying infrastructure for running containers. It’s made up of several parts that work together to run containerized applications, including:

• Kubelet: A worker node agent that communicates with the control plane. It’s in charge of managing the node’s state, starting and stopping containers, and reporting node status to the control plane.
• Kube-proxy: A network proxy that runs on every worker node. It’s in charge of managing network traffic between cluster containers and services.
• Container runtime: The software that executes containers on the worker node. Docker, Containerd and CRI-O are among the container runtimes supported by Kubernetes.

When you deploy a containerized application to a Kubernetes cluster, the control plane schedules it to run on a worker node, which uses its resources to run the container.

The kubelet communicates with the control plane to obtain container information, such as image and resource requirements. It then retrieves the container image from a container registry and launches it on the worker node.

The kube-proxy manages network traffic between cluster containers and services. It ensures that each container has a distinct IP address and can communicate with other containers and services. The container is managed by the container runtime on the worker node. It secures and isolates the container’s environment and manages resources such as CPU, memory and storage.

What is a Kubernetes pod?

A Kubernetes pod is the smallest deployable unit that represents a single instance of a running process in a cluster. It’s a logical host for one or more containers, complete with shared resources and a network namespace. It encapsulates one or more containers, storage resources and networking components, and represents a single instance of a running process in a cluster. Also, pods can be created, scaled or deleted at any time by Kubernetes based on the deployment’s configuration.

Pods are intended to run one or more containers that are closely related, such as a web server and its database. Containers within a pod have the same network namespace and IP address and can communicate via the localhost network interface. Pods also share the same storage volume, which is typically used to store shared application data or configuration files between containers. This simplifies data management and ensures consistency across the application.

One of the primary advantages of using pods is their ability to be scaled up or down in response to demand. For example, if an application’s workload increases, Kubernetes can create additional pods to handle the additional load. If the workload falls, Kubernetes can reduce the number of pods running to optimize resource usage.

Each Kubernetes pod has its own IP address as well as a fully qualified domain name (FQDN) that can be used to communicate with other pods and services in the cluster. This makes managing and connecting multiple pods within a distributed application easier.

Pods may also be configured with various lifecycle hooks, which enable the execution of custom logic during a pod’s startup, shutdown or update. This can be useful for tasks like data initialization, database migrations and configuration changes within an application.

What is a Kubernetes replica?

Kubernetes offers a variety of features for managing and operating containerized applications, including the ability to create and manage application replicas. A replica is a copy of a pod that is created to provide redundancy and high availability. Kubernetes allows users to create multiple replicas of a pod and distribute them across multiple nodes in a cluster. This ensures that if one pod fails or becomes unavailable, another pod can step in and continue serving traffic without interruption.

To manage a pod’s replicas, Kubernetes provides two types of controllers: replication and ReplicaSet. Replication controllers are an older mechanism for managing Kubernetes replicas. ReplicaSet is the newer and preferred method.

ReplicaSet is more powerful and flexible than the older replication controllers. It provides a more robust set of features for replica management. Users can use ReplicaSet to scale up or down the number of replicas based on demand, create deployment strategies for rolling out updates and automatically replace failed replicas.

When creating a ReplicaSet, users define a template that describes the pod they want to replicate and the number of replicas they want to create. Kubernetes then ensures that the desired number of replicas are always running by adding or removing replicas as needed.

ReplicaSet can also be combined with Kubernetes Service, an abstraction layer that defines a logical set of pods and provides a consistent IP address and DNS name for a group of replicas. Users can access a pod’s replicas using a consistent URL, regardless of which replica is serving the request.

What is Kubernetes deployment?

The process of deploying containerized applications on Kubernetes clusters is known as Kubernetes deployment. A deployment is an abstraction layer that defines a containerized application’s desired state and provides a way to manage it. It handles container deployment, scaling and rolling updates.

A Kubernetes deployment is accomplished through the creation and management of replica sets, as seen in the image below. It can be compared to a design for a containerized application. It specifies the application’s desired state, including the number of replicas, the container image to be used and any configuration settings. By creating and managing replica sets, Kubernetes deployment ensures that the desired state of the application is maintained.

Kubernetes deployment also supports rolling updates, which allow you to update an application’s container image or configuration without downtime. A rolling update gradually replaces existing replicas with new ones to update the replica set in a controlled manner.

Kubernetes use is expanding as more companies realize the benefits they can gain, including saving on container orchestration, deploying workloads in multiple clouds, automating deployment and scalability, and much more. Rackspace Technology has been the partner of choice for many leading companies that want to capitalize on the opportunities this powerful container technology provides.

Let us know how we can help your organization launch and optimize Kubernetes in your organization — as well as leverage the expertise of a dedicated and flexible Rackspace Elastic Engineering team.