🚀 Introduction

Kubernetes (often abbreviated as K8s) architecture is designed to manage containerized applications in a distributed environment. Its architecture consists of a master node (or control plane) and multiple worker nodes. Here’s a detailed overview of each component:

On a broad level, you can divide the Kubernetes components into two parts

1. Control Plane (API Server, Scheduler, Controller Manager, C-CM, ETCD)

2. Data Plane (Kubelet, Kube-proxy, Container-Runtime)

Worker Nodes or Slave Node

Worker nodes are the machines where the actual application workloads (containers) run. Each worker node contains the following components:

Why the Control Plane is Necessary?

Despite worker nodes having all the needed components for running containers,

networking, and maintaining pod health, the control plane is crucial for orchestrating and managing the cluster. It offers the needed control, organization, and state management to make sure the cluster runs smoothly and efficiently 🌟

NOTE: To maintain High availability and Fault-tolerance always multiple masters and worker nodes will be running in real time.

Other Components

Kubectl is a command line tool that you use to communicate with the Kubernetes API server. The Kubectl binary is available in many operating system package managers. Using a package manager for your installation is often easier than a manual download and install process.

Container Network Interface(CNI) is a specification and library for configuring network interfaces in Linux containers. The main purpose of CNI is to allow different networking plugins to be used with container runtimes. This allows Kubernetes to be flexible and work with different networking solutions, such as Calico, Flannel, and Weave Net. CNI plugins are responsible for configuring network interfaces in pods, such as setting IP addresses, configuring routing, and managing network security policies.

Node Controller is responsible for managing Worker Nodes. It will monitor the new Nodes connecting to the cluster, validate the Node's health status based on metrics reported by the Node's Kubelet component, and update the Node's status field. If a Kubelet stops posting health checks to the API Server, the Node Controller will be responsible for triggering Pod eviction from the missing Node before removing the Node from the cluster.

Replication Controller ensures that a specified number of pod replicas are running at any one time. In other words, a Replication Controller makes sure that a pod or a homogeneous set of pods is always up and available.

Explain the role of the API server.

The API server is a core component of the control plane in Kubernetes.

It acts as the primary interface for communication between various Kubernetes components and external entities. The API server exposes the Kubernetes API, which allows users, administrators, and other components to interact with the cluster.

Here are some of the key responsibilities of the API server:

• The API server is responsible for managing the overall state and configuration of the Kubernetes cluster.

• The API server handles user authentication and authorization.

• The API server acts as an endpoint for clients and other Kubernetes components to interact with the cluster. This allows users to create, update, and delete Kubernetes resources, as well as retrieve information about the cluster’s state.

• The API server performs validation and admission control for incoming API requests.

• The API server interacts with the etcd key-value store, which serves as the cluster’s data store.

• The API server manages the lifecycle of resources and provides a control loop for various controllers running within the control plane.

Difference between Kubectl and Kubelet

The difference between kubectl and kubelet is: -

kubectl:

• Purpose:kubectl is a tool you use to talk to and manage your Kubernetes cluster.

• Interface: It’s like your remote control for Kubernetes. You can use it to give commands to the cluster, like starting or stopping applications.

• User-Friendly:kubectl is designed for people to use, so it has a user-friendly interface and commands.

• Location: It runs on your computer and connects to the Kubernetes cluster to control it.

• Examples: You use kubectl to create and manage things like applications, services, and configurations in your Kubernetes cluster.

kubelet:

• Purpose:kubelet is a node agent in Kubernetes that manages and coordinates pods and nodes

• Node Manager: It makes sure the containers (the parts of your applications) on that computer are running as they should be.

• Container Manager: It specifically takes care of starting, stopping, and keeping an eye on the containers.

• Node Health:kubelet checks if the computer (node) is healthy and tells the main control center if there's a problem.

• Not for Users: You don’t use kubelet it directly. It quietly does its job in the background on each computer in the cluster.

In short, kubectl is like your remote control for managing the whole cluster, while kubelet is the worker on each computer, making sure the applications (containers) on that computer run smoothly.

Conclusion

In Conclusion, Kubernetes (K8s) is a powerful open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications.

K8s architecture is built around a master node and multiple worker nodes, forming a distributed system that ensures high availability and fault tolerance.

The master node oversees cluster orchestration, scheduling, and communication, while worker nodes executing tasks and host containers.

The master-node and worker-node structure, combined with essential components like the API server, etcd, controllers, schedulers, service-proxy, and kubelet, form the backbone of K8s. This architecture ensures effective management, automation, and scaling of containerized applications, facilitating high availability and fault tolerance. K8s has become a standard in the container orchestration space, providing a versatile and efficient platform for deploying and managing applications in modern, cloud-native environments.

Some Important Questions related to Kubernetes architecture

1. What are the main components of the Kubernetes architecture?

   • On a broad level, you can divide the Kubernetes components into two parts

   • 1. Control Plane (API Server, Scheduler, Controller Manager, C-CM, ETCD)
   • 2. Data Plane (Kubelet, Kube-proxy, Container-Runtime)

2. Can you explain the role of the Kubernetes Master node?

   • The Master node is responsible for managing the Kubernetes cluster and coordinating all activities. It controls the scheduling of applications, maintains cluster state, and manages scaling and self-healing.

3. What are the components running on the Kubernetes Master node, and what are their functions?

   • Components include the API server, etcd, scheduler, and controller manager. The API server exposes the Kubernetes API, etcd is a distributed key-value store for cluster state, the scheduler assigns workloads to nodes, and the controller manager handles cluster management tasks.

4. What is the role of the Kubernetes Worker node?

   • Worker nodes host the actual workloads (containers) that run applications. They receive tasks from the Master node and execute them.

5. Can you describe the components running on the Kubernetes Worker node and what their responsibilities are?

   • Components include kubelet, kube-proxy, and container runtime (e.g., Docker). The kubelet communicates with the Master node and manages containers on the node. Kube-proxy handles network communication and routing. The container runtime executes containers.

6. How does the Kubernetes control plane communicate with the worker nodes?

   • The Kubernetes control plane communicates with worker nodes via the kubelet API, which runs on each worker node.

7. What is the role of the kubelet in the Kubernetes architecture?

   • The kubelet is responsible for managing the containers on a node. It ensures that containers are running and healthy as per the instructions provided by the control plane.

8. Explain the purpose of the kube-proxy component in Kubernetes.

   • Kube-proxy is responsible for managing network communications between different parts of the Kubernetes cluster and ensuring that traffic is correctly routed to the appropriate containers.

9. What are etcd clusters, and how are they used in Kubernetes?

   • etcd clusters are distributed key-value stores that store the state of the Kubernetes cluster. They are used by Kubernetes to store configuration details, cluster state, and metadata.

10. How does Kubernetes ensure the high availability of its components?

    • Kubernetes achieves high availability by replicating control plane components (API server, scheduler, controller manager) across multiple nodes and using mechanisms like leader election and health checks for fault tolerance.

11. Describe the communication flow between various Kubernetes components during a typical operation, such as deploying an application.

    • The API server receives requests from clients, such as kubectl or the dashboard. It stores the state in etcd and forwards requests to appropriate components like the scheduler or controller manager. These components then orchestrate the necessary actions on the worker nodes via the kubelet.

12. How does Kubernetes manage networking between pods in a cluster?

    • Kubernetes manages networking through a Container Network Interface (CNI) plugin, which provides networking capabilities to containers. Each pod gets its IP address, and kube-proxy manages the network routing.

13. What is the purpose of the Kubernetes API server, and how is it accessed?

    • The API server serves as the front end for Kubernetes. It exposes the Kubernetes API, which clients use to interact with the cluster. Clients can access the API server using kubectl or programmatically via client libraries.

14. How does Kubernetes handle authentication and authorization of users and services?

    • Kubernetes uses various authentication mechanisms, such as client certificates, tokens, or integration with external authentication providers like LDAP or OAuth. Authorization is based on Role-Based Access Control (RBAC) rules defined in Kubernetes.

15. Can you explain the concept of namespaces in Kubernetes and their significance in the architecture?

    • Namespaces provide a way to logically partition resources within a Kubernetes cluster. They are used to isolate and organize objects like pods, services, and deployments. Namespaces help in managing resources, access control, and multi-tenancy within the cluster.