Kubernetes for Beginners: The Visual Guide

Managing one Docker container is easy. Managing hundreds across multiple servers? That’s a nightmare — unless you have an orchestra conductor.

This is where Kubernetes (K8s) comes in. It’s the operating system for the cloud.

Introduction

What You'll Learn

What Kubernetes actually solves (The “Why”)
The full architecture: Control Plane vs. Worker Nodes
Key objects: Pods, Deployments, Services
How to write real YAML manifests
10 essential kubectl commands
A hands-on project: Deploy your first app

Mental Model: The Orchestra Conductor

Imagine a massive orchestra with 100 musicians (Containers).

Docker is the individual musician. They know how to play their instrument.
Kubernetes is the Conductor.

The Conductor doesn’t play an instrument. Instead, they:

Tell musicians when to start/stop (Scheduling)
Replace a musician if they faint (Self-healing)
Ensure the volume is balanced (Scaling)

Without the Conductor, you just have noise. With Kubernetes, you have a symphony.

Kubernetes Architecture

A Kubernetes cluster is split into two parts: The Brain (Control Plane) and The Muscle (Worker Nodes).

The Control Plane Components

Component	Nickname	What It Does
API Server	The Front Desk	Everything talks here. `kubectl` sends commands here.
Scheduler	The Placement Agency	Decides which node runs which Pod.
Etcd	The Distributed Notebook	Stores the entire cluster state (replicated, fault-tolerant).
Controller Manager	The Watchdog	Continuously checks: “Is the current state = desired state?”

The Worker Node Components

Component	What It Does
Kubelet	The site manager. Ensures containers are running as instructed.
Kube-proxy	The network traffic cop. Routes traffic to the right Pod.
Container Runtime	The engine (e.g., containerd). Actually runs the containers.

Key Concepts: The “K8s Objects”

1. Pod — The Atom

The smallest deployable unit. Usually contains one container.

Pods are Ephemeral!

Pods die. They can be killed by the scheduler, OOMKilled, or evicted. Never rely on a single Pod staying alive. That’s what Deployments are for.

2. Deployment — The Blueprint

Defines how many copies (replicas) of a Pod you want. Deployments self-heal — if a Pod dies, the Deployment restarts it.

# my-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
spec:
  replicas: 3          # Run 3 copies at all times
  selector:
    matchLabels:
      app: my-nginx
  template:
    metadata:
      labels:
        app: my-nginx
    spec:
      containers:
      - name: nginx
        image: nginx:alpine
        ports:
        - containerPort: 80

3. Service — The Stable Phone Number

Pods get new IP addresses every time they restart. A Service gives them a stable address.

Kubernetes Service Discovery Diagram — Service: The Stable Front Door to Pods

# my-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: my-nginx-svc
spec:
  selector:
    app: my-nginx      # Routes to Pods with this label
  ports:
  - port: 80
    targetPort: 80
  type: LoadBalancer   # Exposes externally (or NodePort for local dev)

Service Types at a Glance

ClusterIP (default): Only accessible inside the cluster.
NodePort: Exposes on each node’s IP + a static port (30000–32767).
LoadBalancer: Provisions a cloud load balancer (AWS/GCP/Azure).

Setting Up: Minikube (Local Kubernetes)

Before running kubectl, you need a cluster. Minikube runs a single-node cluster on your laptop.

minikube start

Start a local Kubernetes cluster (downloads K8s and starts a VM/container)

beginner

Example

minikube start --driver=docker

💡 Pro Tips

•--driver=docker uses Docker as the backend (no VM needed)
•First run takes 2-5 minutes to download
•minikube status to check if it's running

minikube status

Check that your local cluster is running

beginner

Output

minikube\ntype: Control Plane\nhost: Running\nkubelet: Running\napiserver: Running\nkubeconfig: Configured

Hands-On: Essential `kubectl` Commands

kubectl is your command-line remote control for the entire cluster.

1. Get Nodes

kubectl get nodes

List all nodes in the cluster and their status

beginner

Example

NAME STATUS ROLES AGE VERSION\nminikube Ready control-plane 5m v1.29

2. Apply a YAML Manifest

kubectl apply -f my-deployment.yaml

Create or update resources from a YAML file

beginner

Example

deployment.apps/my-nginx created

💡 Pro Tips

•The primary way to deploy in Kubernetes
•-f can point to a file OR a directory
•Re-run to update — Kubernetes diffs the change

3. Get All Resources

kubectl get all

List all Pods, Services, Deployments, and ReplicaSets in the current namespace

beginner

💡 Pro Tips

•-n kube-system to see the system namespace
•--all-namespaces (-A) to see everything cluster-wide

4. Get Pods

kubectl get pods

List all running Pods and their status

beginner

Example

NAME                        READY   STATUS    RESTARTS   AGE\nmy-nginx-6d5f9c4b89-x4kzp   1/1     Running   0          1m

💡 Pro Tips

•-o wide shows node IP and node name
•--watch (-w) streams live updates

5. Describe a Resource

kubectl describe pod [pod-name]

Show detailed information about a Pod including events and error messages

beginner

Syntax

kubectl describe [resource] [name]

Example

kubectl describe pod my-nginx-6d5f9c4b89-x4kzp

💡 Pro Tips

•This is your #1 debugging tool
•The 'Events' section at the bottom shows WHY a pod failed
•Also works: kubectl describe deployment my-nginx

6. View Logs

kubectl logs [pod-name]

Print the logs from a container in a Pod

beginner

Example

kubectl logs my-nginx-6d5f9c4b89-x4kzp

💡 Pro Tips

•-f = follow (live stream)
•--previous = logs from the crashed previous container
•-c [container-name] if the Pod has multiple containers

7. Execute a Command Inside a Pod

kubectl exec -it [pod-name] -- /bin/sh

Open an interactive shell inside a running container

beginner

Example

kubectl exec -it my-nginx-6d5f9c4b89-x4kzp -- /bin/sh

💡 Pro Tips

•-it = interactive terminal
•Use /bin/bash if the container has bash
•Exit with 'exit' or Ctrl+D

8. Scale a Deployment

kubectl scale deployment my-nginx --replicas=5

Change the number of running Pod replicas instantly

beginner

Example

deployment.apps/my-nginx scaled

💡 Pro Tips

•Scale to 0 to stop all Pods without deleting the Deployment
•Kubernetes adds/removes Pods within seconds

9. Port Forward (Local Access)

kubectl port-forward pod/[pod-name] 8080:80

Forward a local port to a port on a Pod (for testing)

beginner

Example

kubectl port-forward pod/my-nginx-6d5f9c4b89-x4kzp 8080:80

💡 Pro Tips

•Open http://localhost:8080 to access the Pod directly
•Also works with services: kubectl port-forward svc/my-nginx-svc 8080:80
•Press Ctrl+C to stop forwarding

10. Delete a Resource

kubectl delete -f my-deployment.yaml

Delete all resources defined in a YAML file

beginner

Example

deployment.apps/my-nginx deleted

💡 Pro Tips

•Preferred over kubectl delete deployment my-nginx (matches what you created)
•Kubernetes gracefully stops Pods before deleting

Troubleshooting: Common Pod Statuses

Status	Meaning	What To Do
Pending	No node has enough CPU/RAM	Check `kubectl describe pod` for resource errors
CrashLoopBackOff	App crashes immediately on start	`kubectl logs --previous [pod]` to see the crash reason
ImagePullBackOff	Can’t download the container image	Check image name spelling and registry access
OOMKilled	Container exceeded its memory limit	Increase `resources.limits.memory` in your YAML
Terminating (stuck)	Pod won’t delete cleanly	`kubectl delete pod [name] --force --grace-period=0`

Hands-On Challenge: Deploy Your First App

Mission: Run Nginx in Kubernetes

Deploy a 3-replica Nginx app and access it from your browser.

Step 1: Start minikube

minikube start --driver=docker

Step 2: Create your deployment YAML (save as nginx-deploy.yaml)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx-app
  template:
    metadata:
      labels:
        app: nginx-app
    spec:
      containers:
      - name: nginx
        image: nginx:alpine
        ports:
        - containerPort: 80

Step 3: Apply it

kubectl apply -f nginx-deploy.yaml

Step 4: Verify 3 Pods are Running

kubectl get pods

Step 5: Access it via port-forward

kubectl port-forward deployment/nginx-app 8080:80

Open http://localhost:8080 — you should see the Nginx welcome page!

Step 6: Scale to 5 replicas

kubectl scale deployment nginx-app --replicas=5
kubectl get pods --watch

Quiz: Test Your Knowledge

🧠

Test Your Knowledge

Take a quick 4-question quiz to check your understanding.

Key Takeaways

Kubernetes orchestrates containers — it’s the Conductor for your entire application.
Control Plane manages state; Worker Nodes run workloads.
Pods are ephemeral; Deployments keep them alive and at the right replica count.
Services give Pods stable, load-balanced networking.
kubectl apply -f is how you deploy; kubectl describe + kubectl logs is how you debug.

You Now Know

The Conductor (Kubernetes) ensures your application keeps playing, no matter what happens to the musicians. And you can now direct that orchestra with kubectl!

Next Steps

Docker Compose — Multi-container apps for development
AWS vs Azure vs GCP — Where to run your cluster in production

Found this helpful? Explore more in the Containers Hub!

Get weekly IT guides

Start a local Kubernetes cluster (downloads K8s and starts a VM/container)

Check that your local cluster is running

List all nodes in the cluster and their status

Create or update resources from a YAML file

List all Pods, Services, Deployments, and ReplicaSets in the current namespace

List all running Pods and their status

Show detailed information about a Pod including events and error messages

Print the logs from a container in a Pod

Open an interactive shell inside a running container

Change the number of running Pod replicas instantly

Forward a local port to a port on a Pod (for testing)

Delete all resources defined in a YAML file

Test Your Knowledge

Get weekly IT guides

Shekhar Kumar

Found this useful? Help others discover it