I’ve started preparing for the Certified Kubernetes Administrator (CKA) exam using the Udemy course “Prepare for the Certified Kubernetes Administrators Certification with live practice tests right in your browser” - Mumshad Mannambeth.

To document my journey, I’m writing a blog series that covers each major topic from the CKA syllabus. This is Part 1 – Core Concepts.

🔹 Why Kubernetes?

In the world of modern applications, containers (like Docker) have become the standard way of packaging and running software. However, managing containers at scale — across multiple servers, ensuring high availability, load balancing, and recovery — is hard.

That’s where Kubernetes (K8s) comes in. It automates container deployment, scaling, networking, and healing. Think of Kubernetes as:

A container orchestrator
A cluster manager
A system that makes sure your app is always running the way you want

🔹 Kubernetes Architecture

Kubernetes clusters are made up of two main parts:

1. Control Plane (Master Node)

This is the “brain” of the cluster. It makes decisions and maintains the desired state. Key components:

API Server → The entry point for all requests (kubectl, users, and other services talk to the API server).
etcd → A distributed key-value store that saves the entire cluster state.
Scheduler → Decides which Node a Pod should run on based on resource availability.
Controller Manager → Runs controllers that handle tasks like ensuring Pods are up, scaling workloads, or reacting when Nodes fail.

2. Worker Nodes

These are the “muscles” of the cluster — they actually run the workloads. Components:

Kubelet → Agent running on each Node that communicates with the Control Plane.
Kube-proxy → Handles network routing and ensures Pods can talk to each other and outside the cluster.
Container Runtime → Runs the containers (e.g., Docker, containerd).

📌 Together, the Control Plane manages what should happen, and Worker Nodes ensure it actually happens.

🔹 Core Building Blocks of Kubernetes

Pod
- The smallest deployable unit in Kubernetes.
- Usually runs a single container (but can run multiple tightly coupled containers).
- Ephemeral — if it dies, it’s not automatically recreated unless managed by a higher-level object.
ReplicaSet
- Ensures a defined number of Pods are always running.
- If a Pod crashes, ReplicaSet will spin up a replacement.
Deployment
- A higher-level abstraction that manages ReplicaSets.
- Enables rolling updates (update apps with zero downtime) and rollbacks.
Service
- Provides stable networking and a way to expose Pods.
- Types:
  - ClusterIP → Internal communication inside the cluster.
  - NodePort → Exposes service on each Node’s IP at a static port.
  - LoadBalancer → Integrates with cloud provider load balancers to expose apps externally.

🔹 Hands-On Commands

Here’s what I tried while learning Core Concepts:

This exercise helped me see how Pods are created, how Services connect them, and how Kubernetes abstracts the underlying complexity.

🔹 Key Takeaways

Pods are temporary → They can disappear anytime; Deployments/ReplicaSets ensure they’re recreated.
Services provide stability → Without them, Pods would be inaccessible due to their short lifecycle.
Control Plane = decision maker; Worker Nodes = executors of workloads.
Kubernetes provides both abstraction and automation, reducing manual management effort.

🔹 What’s Next?

This was just the start. I’ll continue sharing my learnings as I cover:

Scheduling in Kubernetes
Logging & Monitoring
Application Lifecycle Management
Networking, Storage, and Security

Stay tuned for Part 2: Scheduling in my CKA Prep Series 🚀

If you’re also on your Kubernetes or DevOps journey, I’d love to connect and share resources. Drop your favorite K8s learning tip in the comments!

#Kubernetes #CKA #DevOps #LearningJourney #CloudComputing

Kubernetes Core Concepts – My Learning Journey (CKA Prep Series #1)