What Is Kubernetes and What Is It Used For: Complete Beginner's Guide

Introduction

You’ve learned to use Docker and containers, but now you’re wondering: “How do I manage dozens or hundreds of containers in production?”. The answer is Kubernetes, often abbreviated as K8s. In this guide, I’ll explain what it is, how it works, and when it makes sense to use it.

What Is Kubernetes?

Kubernetes is an open-source platform for container orchestration. It was created by Google in 2014 based on 15 years of experience managing containers at scale, and is now maintained by the Cloud Native Computing Foundation (CNCF).

But what does “orchestration” mean? Imagine a symphony orchestra:

• The musicians are your containers, each knowing how to play their instrument
• The conductor is Kubernetes, coordinating all the musicians
• The score is the configuration that defines how they should play together

Without a conductor, each musician would play on their own. With Kubernetes, all containers work in harmony to run your application.

The Kubernetes Name

The name comes from the Greek κυβερνήτης (kybernetes), meaning “helmsman” or “pilot”. The logo with the seven-spoke helm represents this concept. The abbreviation K8s comes from the fact that there are 8 letters between “K” and “s”.

Why Do You Need Kubernetes?

Docker solves the problem of creating and running individual containers. But in production, things get complicated:

• What happens if a container crashes at 3 AM?
• How do you distribute traffic among 10 instances of the same application?
• How do you update the application without downtime?
• How do you manage 50 microservices that need to communicate with each other?

Kubernetes answers all these questions.

Docker vs Kubernetes: They’re Not Alternatives

A common misconception is thinking that Kubernetes replaces Docker. In reality, they work together:

Kubernetes can use Docker (or other runtimes like containerd) to run containers. You don’t have to choose between them: you use both.

What Kubernetes Is Used For: 6 Problems It Solves

1. Self-Healing: Containers That Fix Themselves

If a container crashes, Kubernetes detects it and automatically starts a new one. No one needs to be awake at 3 AM to manually restart services.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# Kubernetes ensures 3 replicas are always active
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 3  # If one dies, K8s creates a new one
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
      - name: web
        image: nginx:latest

2. Automatic Scaling

Got a traffic spike? Kubernetes can automatically increase the number of containers. Traffic drops? It reduces them to save resources.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# Automatically scales between 2 and 10 replicas based on CPU
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: web-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: web-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

3. Built-in Load Balancing

Kubernetes automatically distributes traffic among all available containers. If a container is overloaded or unresponsive, traffic is redirected to others.

4. Rolling Updates: Zero-Downtime Deployments

When you deploy a new version, Kubernetes:

1. Starts new containers with the updated version
2. Verifies they’re working correctly
3. Gradually shifts traffic to the new containers
4. Terminates the old containers

If something goes wrong, it can automatically rollback to the previous version.

5. Service Discovery

In a system with many microservices, how does service A find service B? Kubernetes provides an internal DNS system: each service has a name and Kubernetes handles translating it to the correct address.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# The "database" service will be reachable as "database.default.svc.cluster.local"
apiVersion: v1
kind: Service
metadata:
  name: database
spec:
  selector:
    app: postgres
  ports:
  - port: 5432

6. Secrets and Configuration Management

Passwords, API keys, configurations: Kubernetes manages them securely and injects them into containers without hardcoding them in the code.

1
2
3
4
5
6
7
8
9

# Secret for database credentials
apiVersion: v1
kind: Secret
metadata:
  name: db-credentials
type: Opaque
data:
  username: YWRtaW4=      # base64 encoded
  password: cGFzc3dvcmQ=  # base64 encoded

Kubernetes Fundamental Concepts

Pod

The Pod is Kubernetes’ basic unit. It contains one or more containers that share network and storage. In most cases, a Pod contains a single container.

Node

A Node is a machine (physical or virtual) that runs Pods. A Kubernetes cluster typically has multiple Nodes to ensure high availability.

Cluster

The Cluster is the set of all Nodes managed by Kubernetes. It includes:

• Control Plane: the “brain” that makes decisions (where to place Pods, when to scale them, etc.)
• Worker Nodes: the machines that actually run the containers

Deployment

A Deployment describes the desired state of your application: which image to use, how many replicas, how to update it. Kubernetes ensures the actual state always matches the desired state.

Service

A Service exposes Pods to the network. It provides a stable IP address and load balancing, even when the underlying Pods change.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

┌─────────────────────────────────────────────────────────┐
│                      CLUSTER                            │
│  ┌─────────────────────────────────────────────────┐   │
│  │              CONTROL PLANE                       │   │
│  │  • API Server  • Scheduler  • Controller        │   │
│  └─────────────────────────────────────────────────┘   │
│                                                         │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐    │
│  │   NODE 1    │  │   NODE 2    │  │   NODE 3    │    │
│  │ ┌─────────┐ │  │ ┌─────────┐ │  │ ┌─────────┐ │    │
│  │ │  Pod A  │ │  │ │  Pod A  │ │  │ │  Pod B  │ │    │
│  │ └─────────┘ │  │ └─────────┘ │  │ └─────────┘ │    │
│  │ ┌─────────┐ │  │ ┌─────────┐ │  │ ┌─────────┐ │    │
│  │ │  Pod B  │ │  │ │  Pod C  │ │  │ │  Pod C  │ │    │
│  │ └─────────┘ │  │ └─────────┘ │  │ └─────────┘ │    │
│  └─────────────┘  └─────────────┘  └─────────────┘    │
└─────────────────────────────────────────────────────────┘

Kubernetes vs Docker Swarm

Docker has its own built-in orchestrator: Docker Swarm. What’s the difference?

When to choose Docker Swarm:

• Small/medium projects
• Teams with little orchestration experience
• Need to get started quickly

When to choose Kubernetes:

• Enterprise or growing projects
• Need for advanced features
• Team willing to invest in learning
• Significant scaling requirements

When NOT to Use Kubernetes

Kubernetes isn’t always the right answer. Avoid it if:

• You have few containers: managing 2-3 containers with K8s is like using a semi-truck to carry groceries
• The team is small: operational complexity can outweigh the benefits
• The application is monolithic: K8s shines with microservices
• You don’t have scaling requirements: if traffic is constant and predictable, you might not need it
• Limited budget: Kubernetes clusters have significant operational costs

Simpler Alternatives

How to Get Started with Kubernetes

If you want to explore Kubernetes without losing your mind, here’s a gradual path:

1. Learn Docker Fundamentals

If you haven’t already, start with Docker. Kubernetes orchestrates containers, so you need to know how to create them first.

2. Experiment Locally with Minikube

Minikube creates a Kubernetes cluster on your computer. Perfect for learning without cloud costs.

1
2
3
4
5

# Install Minikube and start a local cluster
minikube start

# Verify it works
kubectl get nodes

3. Explore kubectl

kubectl is the command for interacting with Kubernetes. Learn the basic operations:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# See running Pods
kubectl get pods

# Create resources from a YAML file
kubectl apply -f deployment.yaml

# View Pod logs
kubectl logs pod-name

# Enter a container
kubectl exec -it pod-name -- /bin/bash

4. Try a Managed Cluster

When you’re ready for production, use a managed service:

• Google Kubernetes Engine (GKE)
• Amazon Elastic Kubernetes Service (EKS)
• Azure Kubernetes Service (AKS)

These services manage the Control Plane for you, reducing operational complexity.

Conclusions

Kubernetes is a powerful tool that solves real problems in managing containerized applications at scale. It offers self-healing, automatic scaling, zero-downtime deployments, and much more.

However, it brings significant complexity. Before adopting it, ask yourself:

• Do I really need to orchestrate many containers?
• Does my team have the skills (or time to acquire them)?
• Do the benefits justify the added complexity?

If the answer is yes, Kubernetes can transform how you manage your applications. If not, simpler solutions like Docker Compose or Docker Swarm might be the better choice.

The advice is to start small: experiment with Minikube, practice the basic concepts, and gradually scale to more complex clusters when you actually need them.