Skip to main content

Kubernetes - Why Do We Need It?

Pre-requisites​

Before learning Kubernetes, you should have a good understanding of containers and container platforms like Docker.

What is Kubernetes?​

Kubernetes (often called K8s) is an open-source platform used to manage containerized applications.

In simple words, Kubernetes helps us:

  • Deploy containers
  • Manage containers
  • Scale containers
  • Recover failed containers automatically
  • Distribute traffic between containers

The official definition of Kubernetes is:

Kubernetes is an open-source container orchestration platform for automating deployment, scaling, and management of containerized applications.

info

Info: Kubernetes is mostly called or addressed as K8s. There are 8 letters between the K and S in the name. Kubernetes -> Kubernetes = K8s.

This definition can feel difficult to understand at first. So instead of memorizing it, let us understand why Kubernetes was created and what problems it solves.

Understanding the Problem​

We already know that containers are ephemeral in nature.

This means containers are temporary and can:

  • Stop unexpectedly
  • Crash
  • Be deleted
  • Be recreated anytime

Running a few containers manually is easy. But managing hundreds or thousands of containers becomes difficult very quickly.

Let us understand the common problems.

Problems with Traditional Container Platforms​

1. Single Host Problem​

Imagine a single server running multiple containers.

Now suppose one container suddenly starts consuming too much:

  • CPU
  • Memory
  • Disk
  • Network bandwidth

Because all containers share the same host resources:

  • Other containers may become slow
  • Some containers may fail to start
  • Applications may become unstable

The main problem here is that platforms like Docker mainly manage containers on a single host.

As applications grow, managing everything on one server becomes risky and inefficient.

2. No Auto-Healing​

Suppose a container crashes or someone accidentally stops it.

What happens?

The application becomes unavailable until someone manually starts the container again.

Containers can stop for many reasons:

  • Application crash
  • Resource exhaustion
  • Server failure
  • Network issues
  • Human mistakes

In real-world environments, manually monitoring and restarting containers all the time is not practical.

3. No Automatic Scaling​

A single container may not be able to handle increasing traffic.

For example:

  • An e-commerce application during a sale
  • A streaming app during a live event
  • A ticket booking system during peak hours

To handle more requests, we need multiple copies of the application running as containers.

Managing this manually becomes difficult as traffic keeps changing.

4. Load Balancing Problem​

If multiple containers of the same application are running, incoming traffic should be distributed properly across them.

Without load balancing:

  • Some containers may receive too much traffic
  • Some containers may remain idle
  • Applications may become slow or unavailable

How Kubernetes Solves These Problems​

Kubernetes was designed to solve all these operational challenges.

1. Cluster-Based Architecture​

Kubernetes works using a cluster architecture.

A Kubernetes cluster is a group of machines (called nodes) working together.

Instead of depending on a single server:

  • Workloads are distributed across multiple nodes
  • Applications become more reliable
  • Resource utilization improves
  • Failure of one machine does not stop the entire application

Kubernetes follows a control plane and worker node architecture:

  • The control plane manages the cluster
  • The worker nodes run the application containers

2. Auto-Healing​

Kubernetes continuously monitors applications.

If a container or pod fails:

  • Kubernetes automatically creates a replacement
  • Failed containers are restarted automatically
  • Applications become highly available

This feature is called auto-healing.

For example:

  • If a pod crashes, Kubernetes creates a new one automatically
  • If a node fails, workloads can be moved to another node

3. Auto-Scaling​

Kubernetes can automatically increase or decrease the number of application instances based on traffic or resource usage.

This is called auto-scaling.

Common Kubernetes components used for scaling include:

  • ReplicaSets
  • Deployments
  • Horizontal Pod Autoscaler (HPA)

For example:

  • During high traffic → Kubernetes creates more pods
  • During low traffic → Kubernetes removes unnecessary pods

This helps save resources and improve performance.

4. Load Balancing​

Kubernetes provides built-in load balancing.

It distributes incoming traffic across multiple application pods using:

  • Services
  • kube-proxy

This ensures:

  • Better performance
  • High availability
  • Efficient traffic distribution

For advanced traffic management features, Kubernetes also supports:

  • Ingress
  • Ingress Controllers

Summary​

Kubernetes is not just a container platform.

It is a powerful system that helps run containerized applications reliably at scale.

It solves major problems such as:

  • Managing containers across multiple servers
  • Recovering failed containers automatically
  • Scaling applications based on demand
  • Distributing traffic efficiently

In modern cloud-native environments, Kubernetes has become the standard platform for container orchestration.

In the upcoming documentation, we will learn about:

  • Pods
  • Nodes
  • Deployments
  • ReplicaSets
  • Services
  • Ingress
  • Auto Scaling
  • And many more Kubernetes concepts.