What is the role of the scheduler in the Kubernetes architecture?

Kubernetes, often referred to as K8s, is an open-source container orchestration platform that revolutionizes the world of containerized application management. Before Kubernetes, managing and scaling containerized applications was complicated and intense. However, with it, we are relieved of all the tedious processes involving them. Similar to the concertmaster of an orchestra, Kubernetes acts as the concertmaster, overseeing and managing the containerized applications.

It simplifies complexity through its capabilities, which can seamlessly handle intricate tasks such as load balancingA technique to evenly distribute network traffic to optimize performance and ensure high availability among resources. e.g. servers ., resource allocationThe process of distributing and assigning available resources to meet requirements of tasks., fault toleranceThe ability of a system to continue functioning properly and providing reliable services in the presence of failures., and scalingThe process of adjusting resources or capacity to meet the changing demands of a system or application. based on demand. It ensures that your applications run smoothly, leveraging the full potential of your infrastructure while maintaining high availability and reliability.

Components of Kubernetes

We can call the Kubernetes structure a hierarchical structure, including many different components. Each component has a special job assigned to it for a smooth workflow. These components include:

• Cluster 

• Coordinator node

• Worker node

• Pods

These are also shown in the illustration below:

The component we have to focus on is the coordinator node, which hosts the control plane components. These components are crucial for managing and controlling the cluster.

What are the control plane components?

Control plane components are the ones dedicated to maintaining the desired state of the cluster. These applications work together to provide control, orchestration, and management capabilities for containerized workloads.

These components include:

• API server 

• Scheduler 

• Controller manager 

• etcd 

• Cloud controller manager

Read up in detail about the components in the control plane.

Now, let's delve into the scheduler, as it is the main focus of our Answer. 

Kubernetes scheduler

As we can deduce from the name, the scheduler component schedules pods for them to run smoothly. Pods are the smallest deployable component in Kubernetes and are responsible for representing a running instance of one or more containers. They can encapsulate one or more related containers which are tightly coupledSystems having strong dependencies and are highly interdependent.. This benefits the different containers as they can share networking and storage resources.

How scheduler works

The scheduler works by finding the most optimized node for a pod to run on and ensuring that every available pod is assigned to a node. This is important so that the Kubelet can run them on the node. The Kubelet is the “agent” in each node, allowing communication between the node and the control plane. The Kubelet can be considered a node's control plane but with some limited capabilities. 

The general process of the scheduler is as follows:

• Add each newly created pod to a queue.

• Each pod from the queue is scheduled on nodes by the scheduler.

The default configuration of the scheduler is already set and is typically the go-to scheduler in Kubernetes. However, we can write our scheduling component with our custom configuration. Furthermore, each container in a pod has a different set of requirements for its execution. This means each container has to have a precisely defined pod. This entails the process of filtering and prioritizing.

Filtering

The initial configuration of the scheduler filter is predetermined for finding the general most suitable node. However, we can customize it and filter the nodes on our terms and configurations. This reduces the number of nodes the scheduler has to look over. Another challenge is faced even after filtering is that the pods aren't scheduled and aren't arranged in an optimized way. This is where scoring plays a role in tackling this problem. 

Prioritizing

Now the problem we solve with the prioritizing process is to arrange them according to the optimization. The nodes are scored based on how closely they meet the conditions, which helps find the most appropriate node for the pod. The nodes are then arranged based on scores, and the most compatible is chosen. If more than one node has the same score, the scheduler chooses a node randomly.

Pod scheduling methods

Node selector

The node selector is the most hassle-free way to schedule a pod on specific nodes. We can specify a set of key-value pairs on which each node is filtered. If a node has to be accepted to be scheduled, it must have all the key-value pair labels specified. 

Let's demonstrate this through a Kubectl label command:

This command will filter and schedule all the nodes with the disktype of SSD. 

Node affinity/anti-affinity

This is another feature that allows us to define the constraints for filtering and scheduling the nodes to our custom configuration. This method is more advanced and flexible than the ‘Node selector’ approach as this is the generalization of node selector. Node Affinity rules are defined using labels assigned to nodes and selectors specified in pods. There are two methods for this approach:

Node affinity

• Required: This rule specifies and ensures that the nodes selected meet the requirement strictly and won't schedule a node until a node with the correct requirement comes

• Preferred: This rule specifies that the specified nodes should meet the requirements; however, if no pods are found, it will schedule the pod on the node with the closest requirements. 

Node anti-affinity

The purpose of this rule is to enforce constraints on pod scheduling to prevent co-location or to promote spreading pods across different nodes. Simply put, it implements the rules opposite to the node affinity method. 

Taints and tolerations

This is another feature that aids in the scheduling of pods on nodes. It allows to specify of certain ‘taints’ on nodes and configures pods with corresponding ‘tolerations’. Another way to explain this method is that this feature will indicate which pod can tolerate or be scheduled on nodes with specific “taints”. 

Taints

This is another label that is attached to a node and specifies certain constraints, such as stated below:

• Hardware capabilities

• Node roles

• Availability zones

Tolerations

The tolerations are configured in the pod specs indicating the nodes with specific taints it can tolerate. The tolerations are specified as key-value pairs having different effects, such as:

• NoSchedule

• PreferNoSchedule

• NoExecute

Taints/toleration and node affinity

Using the different methods, we can achieve a set level of pod placement. Even when using the approaches such as Taints and tolerations and node affinity. However, both methods have their limitations, which can be overcome with the combination of both. This covers the areas each approach leaves and helps control the pod placement on a higher level.

Let's check your understanding by a short quiz.

Conclusion

Scheduler plays a vital role in the Kubernetes architecture by facilitating efficient resource allocation and workload distribution within the cluster. As a core component, scheduler is responsible for assigning pods to suitable worker nodes based on resource availability and constraints. This is all done based on factors like resource utilization, affinity/anti-affinity rules, and pod priority. Its ability to balance the workload across the available nodes enables Kubernetes to deliver scalability, high availability, and effective utilization making it one of the best orchestration tools.