Kubernetes for Beginners: A Complete Guide

1. Introduction

Kubernetes (often abbreviated as K8s) is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications.

While Docker helps you create and run containers, Kubernetes helps you run and manage containers across multiple servers (a cluster) efficiently. It eliminates manual work such as restarting crashed containers, load balancing traffic, or scaling the number of containers up and down.

In short:

Docker = creates containers
Kubernetes = manages containers at scale

2. Why Kubernetes Exists

Running a few containers manually is easy. But managing hundreds or thousands of containers across multiple machines quickly becomes complex.
Kubernetes solves this by:

Automatically restarting failed containers
Distributing load across nodes
Scaling containers up/down based on demand
Managing rolling updates without downtime

3. Core Concepts

a. Cluster

A Kubernetes cluster is the foundation. It has two types of machines:

Master Node (Control Plane): Manages the cluster (scheduling, scaling, etc.)
Worker Nodes: Run the actual applications (containers)

b. Node

A node is a single machine (physical or virtual) that runs your containers.
Each node contains:

Kubelet (communicates with the master)
Container runtime (e.g., Docker, containerd)
Kube-proxy (manages networking)

c. Pod

The smallest deployable unit in Kubernetes.

A pod wraps one or more containers that share storage, network, and configuration.

You rarely run individual containers directly in Kubernetes — you run them inside pods.

Example:
A web app and its helper logging container run together in one pod.

d. Deployment

Defines how many pods you want, what image to use, and how to update them.

Kubernetes automatically keeps the desired number of pods running.

Example:

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

Run it:

kubectl apply -f deployment.yaml

e. Service

A service exposes pods to the network.
Pods are temporary — when they restart, their IPs change. A service provides a stable IP and DNS name to reach them.

Example:

apiVersion: v1
kind: Service
metadata:
  name: web-service
spec:
  type: NodePort
  selector:
    app: web
  ports:
  - port: 80
    targetPort: 80
    nodePort: 30080

f. Namespace

Used to divide cluster resources logically.

You can have different environments (e.g., dev, staging, prod) in the same cluster.

4. Kubernetes Architecture

Control Plane (Master Node Components):

API Server: Entry point for all commands (kubectl talks to this).
Controller Manager: Ensures desired state (e.g., keeps 3 pods running).
Scheduler: Decides which node a pod should run on.
etcd: Key-value store for cluster configuration and state.

Worker Node Components:

Kubelet: Communicates with API server, manages pods on that node.
Kube-proxy: Manages network routing.
Container Runtime: Runs containers (Docker, containerd, etc.).

5. Basic Workflow

You define what you want (desired state) in a YAML file (e.g., 3 replicas of a web app).
You apply it:
```
kubectl apply -f deployment.yaml
```
Kubernetes schedules pods on nodes.
If a pod crashes, the controller recreates it.

If traffic increases, you scale replicas:

kubectl scale deployment web-app --replicas=5

The service ensures all pods are reachable through a single endpoint.

6. Common Kubernetes Objects

Object	Purpose
Pod	Smallest deployable unit containing one or more containers
ReplicaSet	Ensures a specified number of pods are running
Deployment	Manages ReplicaSets and rolling updates
Service	Provides stable networking for pods
ConfigMap	Stores configuration data
Secret	Stores sensitive data (passwords, keys)
Ingress	Manages external HTTP/HTTPS access
Volume	Persists data beyond container lifecycle
Namespace	Logical grouping of resources

7. Networking in Kubernetes

Pod-to-Pod communication: Managed internally by the cluster.
Service: Exposes pods within or outside the cluster.
Ingress: Routes external HTTP/HTTPS requests to services.

Example ingress:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web-ingress
spec:
  rules:
  - host: example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: web-service
            port:
              number: 80

8. Scaling and Load Balancing

Kubernetes can automatically scale pods based on CPU or memory usage using Horizontal Pod Autoscaler (HPA).

Example:

kubectl autoscale deployment web-app --min=2 --max=10 --cpu-percent=80

Load balancing happens automatically through Services, distributing traffic evenly across pods.

9. Storage and Persistence

Containers are temporary. To persist data, Kubernetes provides Volumes and PersistentVolumes (PVs).
Developers request storage via PersistentVolumeClaims (PVCs).

Example PVC:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: data-claim
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

10. Monitoring and Logging

Kubernetes provides metrics and logging integration with tools like:

Prometheus (metrics collection)
Grafana (visualization)
ELK Stack (logging)

Command to check pod logs:

kubectl logs pod-name

11. Common Commands

Command	Description
kubectl get pods	List running pods
kubectl get deployments	List deployments
kubectl get services	List services
kubectl describe pod pod-name	Show detailed info
kubectl delete pod pod-name	Delete a pod
kubectl apply -f file.yaml	Apply configuration
kubectl exec -it pod-name -- bash	Access container shell

12. Kubernetes vs Docker

Feature	Docker	Kubernetes
Focus	Containerization	Orchestration
Scope	Single host	Multi-host cluster
Scaling	Manual	Automatic
Load Balancing	Manual setup	Built-in
Fault Tolerance	None	Automatic pod recovery

Note: Docker and Kubernetes are complementary, not competitors. Kubernetes runs Docker containers (or other runtimes) at scale.

13. Why Use Kubernetes

Self-healing: Automatically restarts failed containers.
Scalability: Scale up/down based on load.
Zero downtime: Rolling updates and rollbacks.
Portability: Works on any cloud or on-premise environment.
Automation: Manages resource allocation and health checks automatically.

14. Best Practices

Use Namespaces to separate environments.
Store configs in ConfigMaps and secrets in Secrets.
Use readiness and liveness probes for health checks.
Keep YAML files version-controlled.
Use Resource Limits to prevent a pod from consuming too many resources.

15. Summary

Kubernetes is the industry-standard platform for automating containerized applications.

It abstracts infrastructure complexity and ensures your apps are always available, scalable, and resilient.