What Is Kubernetes?

Imagine an air traffic control tower at a busy airport. Planes (your applications) need runways, gates, and fuel. The tower doesn't fly the planes -- it directs them, makes sure no two crash, and reroutes when things go wrong.

Kubernetes is that control tower for your applications. You tell it what you want running, and it figures out where and how.

The Full Picture

A cluster has two kinds of nodes. Click any component to learn what it does.

How It All Comes Together

Watch the components work together to deploy a new pod.

Check Your Understanding

Why Pods, Not Just Containers?

When you ship a fragile vase, you don't toss it in a truck bare. You wrap it in bubble wrap, put it in a box, and label it. The vase is your container, and the box with the label is your Pod.

Kubernetes never works with containers directly. Every container runs inside a Pod. A Pod is a single instance of your application -- the smallest object you can create in Kubernetes.

How Pods Scale

When traffic grows, Kubernetes adds more pods -- never more containers inside one pod. When a node runs out of space, new pods go to other nodes.

Multi-Container Pods

Sometimes a main container needs a helper -- a sidecar. They share the same network (can talk via localhost), the same storage, and the same lifecycle -- if the pod dies, both die.

Essential Pod Commands

Check Your Understanding

Why Do We Need Them?

Imagine a security team at a building. The contract says "always 3 guards on duty." If one calls in sick, a replacement is automatically dispatched. If the crowd grows, more guards are added. That's what a ReplicaSet does for your pods.

ReplicationController vs ReplicaSet

Both do the same job, but ReplicationController is the older version. ReplicaSet is newer and more powerful.

ReplicaSet YAML Explained

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: myapp-replicaset
spec:
  replicas: 3
  selector:
    matchLabels:
      type: front-end
  template:
    metadata:
      labels:
        type: front-end
    spec:
      containers:
        - name: nginx-container
          image: nginx

ReplicaSet Commands

Check Your Understanding

Deployments Wrap ReplicaSets

Think of renovating a hotel room by room. Guests never notice because there's always a room available. A Deployment does the same with your app -- it updates pods gradually so users never experience downtime.

Update Strategies

spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 25%
  minReadySeconds: 0

Rolling Update Step by Step

Watch how Kubernetes replaces old pods (red) with new ones (green) -- one at a time, with zero downtime.

Liveness vs Readiness Probes

Two health checks, two different questions. Think of a probe as a doctor's visit:

Probe Configuration

CrashLoopBackOff

When liveness fails repeatedly, Kubernetes restarts the container with increasing delay -- like a snooze alarm that waits longer each time. This state is called CrashLoopBackOff.

Deployment Commands

Check Your Understanding

Why Do We Need Services?

Imagine a phone directory for a company. Employees come and go, switch desks, get new extensions. But the directory number (e.g., "Sales: 555-0100") never changes. Callers always reach the right team. A Service is that directory for your pods.

Pods get new IP addresses every time they restart. If another app hardcodes that IP, it breaks. Services give pods a stable address that never changes.

Three Types of Services

Each type builds on the previous one, like nesting dolls.

Side-by-Side Comparison

Traffic Flow: Group Chat Edition

Watch how traffic flows through a LoadBalancer service to reach a pod.

Check Your Understanding

What Is KubeBot?

KubeBot is an interactive chatbot that teaches Kubernetes concepts. It's built with Node.js, runs in a Docker container, and deploys to Kubernetes. The project itself demonstrates the concepts it teaches.

The Dockerfile

FROM node:18-alpine
WORKDIR /app
COPY src/app.js .
EXPOSE 3000
CMD ["node", "app.js"]

The Deployment (Real YAML)

This is the actual deployment.yml from the project. Notice how it uses everything we learned: replicas, rolling updates, and probes.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: kubebot
spec:
  replicas: 3
  selector:
    matchLabels:
      app: kubebot
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 25%

Health Probes in the Real Code

The deployment YAML points probes at /health and /ready. Here's the actual code that handles those checks:

// Health endpoint (liveness probe)
if (req.url === '/health') {
  res.writeHead(200, {'Content-Type': 'application/json'});
  return res.end(JSON.stringify({status: 'UP'}));
}

// Ready endpoint (readiness probe)
if (req.url === '/ready') {
  res.writeHead(200, {'Content-Type': 'application/json'});
  return res.end(JSON.stringify({status: 'READY'}));
}

KubeBot's Services

The project has two services -- one for internal access, one for external.

apiVersion: v1
kind: Service
metadata:
  name: kubebot-internal
spec:
  type: ClusterIP
  selector:
    app: kubebot
  ports:
    - port: 80
      targetPort: 3000

apiVersion: v1
kind: Service
metadata:
  name: kubebot-nodeport
spec:
  type: NodePort
  selector:
    app: kubebot
  ports:
    - port: 80
      targetPort: 3000
      nodePort: 30080

Deploy It Yourself

Final Check

You Made It!

You now understand Kubernetes architecture, pods, ReplicaSets, deployments with rolling updates and probes, and all three service types. Clone the KubeBot project, deploy it, and keep experimenting.