Kubernetes 101: Understanding the Basics, Features, and Architecture 🚀

☸️ What is Kubernetes?

Kubernetes (often called K8s)is an open-source platform that helps you automate the deployment and management of containers. It was first created by Google and is now maintained by the Cloud Native Computing Foundation (CNCF).

The reason Kubernetes has become so popular is because it solves many of the challenges that come with running containers in production. Instead of manually starting and managing containers, Kubernetes makes it possible to easily launch as many copies of your application as you need, spread them across multiple servers, and handle the networking so users can reliably access your services.

In this beginner’s guide, we’ll explore:
1. What Kubernetes is.
2. The main features it offers.
3. How it works behind the scenes.

What is Kubernetes Used For?

Kubernetes is designed to manage and scale applications running in containers. Containers are like small, isolated boxes that hold everything an app needs to run.

Now imagine you have hundreds of these containers running across multiple servers — it’s tough to manage them manually. Kubernetes makes this easy by automating the process.

Here’s what Kubernetes can do for you:

1. Start new apps automatically when needed.
2. Restart apps if they crash.
3. Distribute workloads so no server gets overloaded.
4. Scale apps up or down depending on demand.

In short: Kubernetes is like a system administrator that keeps your apps healthy and running smoothly, without you doing everything manually.

🤔 Is Kubernetes Easy to Learn?

Honestly… not at first 😅. Learning Kubernetes can be a bit challenging in the beginning. Why? Because it has many moving parts, and it’s built for running apps at scale.

Most developers first learn Docker, which helps run one container at a time. But Docker alone is low-level — you still have to manage containers manually. Kubernetes, on the other hand, provides high-level tools and abstractions so you can describe your apps in configuration files, and Kubernetes takes care of the rest.

So yes, the learning curve is steep at first. But once you understand the core concepts (like Pods, Nodes, and Deployments), things start to click.

✨ Kubernetes Features

Kubernetes is packed with features that make running containers easier and more reliable. Let’s go through the key ones:

1. Automated rollouts, scaling, and rollbacks

• You can define how many copies (replicas) of your app should run.
• Kubernetes automatically spreads them across servers.
• If a server goes down, Kubernetes reschedules your containers.
• You can scale apps up or down instantly, either manually or automatically (based on CPU, memory, or custom metrics).

2. Service discovery, load balancing, and ingress

• Kubernetes handles internal communication between apps.
• It can also expose your apps to the outside world.
• Load balancers ensure traffic is spread across all available instances.

3. Supports both stateless and stateful apps

• Initially, Kubernetes was focused on apps that don’t store data (stateless).
• Now, it also supports apps that need persistent data (stateful), like databases.

4. Storage management

• Kubernetes connects your containers to storage — whether it’s cloud storage, a network drive, or your local filesystem.

5. Declarative state management

• You don’t have to manually tell Kubernetes what steps to take.
• Instead, you write a YAML file describing the state you want (e.g., “I want 3 replicas of this app”).
• Kubernetes then works to make the cluster match that state automatically.

6. Works across environments

• Run Kubernetes locally on your laptop (using Minikube, Kind, or K3s).
• Use it in the cloud (AWS, Google Cloud, Azure all provide managed Kubernetes).
• Or even run it at the edge.

7. Highly extensible

• Kubernetes has many built-in features, but you can extend it.
• You can create custom objects, controllers, or operators to support your unique use cases.

With all these features, Kubernetes is suitable for almost any situation where you want to run containers reliably.

🛠 How Does Kubernetes Work?

Kubernetes often feels complex because it has many different parts working together. But once you understand the basics and how these pieces fit, getting started becomes much easier.

In Kubernetes, the whole setup is called a cluster. A cluster is made up of nodes, which are just machines that run your containers. These machines can be physical servers or virtual machines.

Every cluster has two main parts: the control plane and the nodes. The control plane is like the brain of the system — it manages the cluster, schedules new containers on the nodes, and provides the API server you use to interact with Kubernetes. To increase reliability, a cluster can also run with multiple control plane instances so it keeps working even if one fails.

Let’s look at the important components inside Kubernetes:

Component	Description
kube-apiserver	This is the part of the control plane that runs the API server. It’s the only way to interact with a running Kubernetes cluster. You can issue commands to the API server using the Kubectl CLI) or an HTTP client.
kube-controller-manager	The controller manager starts and runs Kubernetes’ built-in controllers. A controller is essentially an event loop that applies actions after changes in your cluster. They create, scale, and delete objects in response to events such as an API request or increased load.
kube-scheduler	The scheduler assigns new Pods (containers) onto the nodes in your cluster. It establishes which nodes can fulfill the Pod’s requirements, then selects the most optimal placement to maximize performance and reliability.
kubelet	Kubelet is a worker process that runs on each of your nodes. It maintains communication with the Kubernetes control plane to receive its instructions. Kubelet is responsible for pulling container images and starting containers in response to scheduling requests.
kube-proxy	Proxy is another component found on individual nodes. It configures the host’s networking system so traffic can reach the services in your cluster.

And then there’s kubectl — the command-line tool you’ll use to interact with Kubernetes. With it, you can deploy apps, check logs, scale workloads, and much more.

🎯 Wrapping Up
Kubernetes may seem complex, but once you understand the basics, it becomes an incredibly powerful tool for managing applications.

This was just the start! In the next part, we’ll go beyond theory and actually get hands-on with Kubernetes.

In the next part of this Kubernetes 102, we’ll dive into:

• Installing and setting up Kubernetes step by step
• Core concepts like Node, Pod, Namespace, ReplicaSet, and Deployment
• Using kubectl to interact with your cluster

👉 Follow me here, or connect with me on LinkedIn and Twitter for updates, tips, and more developer content.