Let’s understand some basic Kubernetes concepts. Trust me if the fundamentals are clear, becomes much easier to understand other concepts.

Kubernetes Basics:

So, what exactly is Kubernetes? — Kubernetes is an orchestration tool.

Now you might be wondering: “What does an orchestration tool actually mean?”

In simple terms, an orchestration tool is something that manages and coordinates multiple components and ensures a desired outcome is achieved automatically. Think of it like a manager in an office. Instead of employees, Kubernetes manages containers and makes sure everything runs as expected.

In the Kubernetes world, it manages things like:

• Pods

• Deployments

• Scaling applications

• Self-healing

• Rolling updates

And most importantly, it ensures your applications remain up and running.

For example, imagine your application pod crashes unexpectedly. Would you manually log in and restart it every time? Of course not.

This is where Kubernetes shines. Kubernetes detects the failure and automatically recreates the pod to bring your application back to the desired state. That is one of the core ideas behind Kubernetes — desired state management.

The Kubernetes have two major components Control Plane and the Worker Nodes. Let's understand this at high level

Control Plane (Brain):

Think of the Control Plane as the brain of Kubernetes. It decides what should happen, when it should happen, and where it should happen. The Control Plane is made up of the following components:

• API Server - Entry Point - You can think of it as the front door of Kubernetes.

• Scheduler - Decides where the pod should run

• Controller Manager - Ensures Desired state. The Controller Manager continuously checks whether the cluster is in the desired state.

• ETCD - The Heart of Kubernetes. ETCD is a distributed key-value database where Kubernetes stores all information. Everything Kubernetes knows is stored in ETCD.

Worker Node (The Muscle Power)

As the name suggests, this is where the actual workload runs. Your applications, pods, and containers are executed inside Worker Nodes.

• Kubelet – The Communicator - The Kubelet continuously talks to the Control Plane and performs action on the node based on configuration. Think of Kubelet as the bridge between the Control Plane and Worker Node.

• Container Runtime - Runs container (Docker/Containerd). The Container Runtime is responsible for actually running containers.

• kube-proxy - The kube-proxy is responsible for network communication inside the cluster.

Core Building Blocks

• pod - Smallest unit, Runs one more more container

• Deployment- Manager pod, handles scaling, rolling updates and self healing

• ReplicaSet - Ensures desired number of pods are always running. Deployment uses replica set internally

• Labels and Selectors - An internal parameter which is used to define/refer and identify pod or other components

• Namespace : Logical Isolation

How everything works together

Consider that you have a Manifest file where you run the command kubectl apply -f app.yaml

• Control Plane

  • API Server receives request. The API Server validates the request and accepts the configuration.

  • Once validated, Kubernetes stores the desired configuration in ETCD.

  • Controller Manager - Notices the new entry in ETCD that a new deployment needs x replicas it updates the cluster state and creates the required pod definitions. (Note the pods are not created yet only it updates the configuration)

  • Scheduler - Identifies that X replicas of pods needs to be created and check the configuration and pick a suitable node and assign to the pods

• Woker Node

  • Kublet which runs on each worker node keeps monitoring Control Plane, the moment it sees the pod scheduled to its node it starts the creation of pod.

  • Container Runtime : The Container Runtime pulls the required image and starts the containers.

  • kube-proxy : Once the pods are running the CNI plugin assigns IP addresses to pods, while kube-proxy manages routing and communication between services and pods.

This is the high-level end-to-end flow of Kubernetes and how all the components work together.