Understanding Kubernetes: A Friendly Guide to Its Core Components
DevOps & Cloud Engineer — building scalable, automated, and intelligent systems. Developer of sorts | Automator | Innovator
Kubernetes can feel intimidating at first. It has many moving parts, unfamiliar terminology, and a lot of YAML. However, once you understand the main components and how they work together, it starts to make sense. Think of Kubernetes as a city, where different citizens have different jobs to keep everything running.
In this blog, we will walk through each important component in Kubernetes and understand what role it plays. There will be no rushed explanations. Just clear, enjoyable learning.
What Is Kubernetes?
Kubernetes is an open source system created to help deploy, scale, and manage containerized applications. Containers are like neat little boxes that hold everything your application needs to run. Kubernetes helps to make sure these applications are running reliably across multiple machines.
Imagine you have many apps that need to be running all the time. Kubernetes is the manager that keeps everything organised, heals things when they break, and ensures your application is always available.
The Big Picture
Kubernetes is made up of two main logical parts:
The Control Plane (The brains or government of the system)
The Worker Nodes (The workers who run the applications)
Let us explore both!
Control Plane Components
The Control Plane is responsible for deciding what needs to happen and when. It watches the cluster and makes sure the actual state matches the desired state.
1. API Server
Role: The front door of Kubernetes.
Whenever you ask Kubernetes to do something, such as deploy an app or create a container, you talk to the API Server. Tools like kubectl communicate with it. It validates requests and sends tasks to the rest of the Control Plane.
2. etcd
Role: The memory of the cluster.
etcd is a distributed key-value store that holds the entire state of Kubernetes. If the API Server is the front door, etcd is the vault of information behind it. If etcd is lost, the cluster forgets everything about its applications and configurations.
3. Scheduler
Role: The planner of the system.
The Scheduler decides which node should run which pod. Pods are scheduled based on available resources, constraints, and policies. Think of the Scheduler as an air traffic controller placing flights in open runways.
4. Controller Manager
Role: The guardian of the system.
The Controller Manager runs controllers that watch the state of the cluster and take action when something is not as desired. For example, if one pod dies, a controller notices it and creates a new one. Kubernetes always tries to make reality match the desired state.
Worker Node Components
Worker nodes are the machines where the actual application workloads run. These can be physical servers, cloud instances, or even your laptop.
1. Kubelet
Role: The caretaker of the node.
The Kubelet makes sure that the containers that Kubernetes tells it to run are actually running. It talks to the container runtime and ensures that everything is healthy.
2. Kube Proxy
Role: The traffic officer.
Kube Proxy manages networking rules and routes traffic among pods. It makes sure that one service can talk to another service smoothly, even across nodes.
3. Container Runtime
Role: The engine that runs containers.
Kubernetes does not run containers directly. It depends on a container runtime like containerd, CRI-O, or Docker. The container runtime actually pulls images and starts containers.
Kubernetes Objects and Resources
Now let us talk about the items you interact with as a user.
1. Pods
A Pod is the smallest deployable unit. It usually contains one container, but it can have more. If containers need to work very closely together, they live inside the same Pod.
2. Deployments
Deployments manage replicas of your Pods. If you want three copies of an application running, you create a Deployment. If one Pod fails, Kubernetes replaces it automatically.
3. Services
Services help your applications talk to each other. They give stable network addresses even if Pods keep changing.
4. ConfigMaps and Secrets
These store configuration and sensitive data separately from code. ConfigMaps handle normal configuration. Secrets handle secure values like passwords and tokens.
Putting It All Together
Imagine you tell Kubernetes that you want to run three copies of your web application. Here is what happens:
You send the request to the API Server.
The request is stored in etcd.
The Scheduler selects Worker Nodes to run the Pods.
The Kubelet on each selected node starts the containers.
The Controller Manager ensures that three Pods are always running.
Kube Proxy ensures traffic flows to all three Pods evenly.
Everything works together seamlessly.
Conclusion
Kubernetes might appear complex, but each part has a clear purpose. The Control Plane thinks, decides, and manages state. The Worker Nodes run the applications. The resources like Pods, Deployments, and Services define what you want to run.
Once you understand these components, Kubernetes becomes far less mysterious. It becomes something stable, logical, and even enjoyable to work with.
