What is Kubernetes?
Kubernetes (commonly referred to as K8s) is an open-source system for automating the deployment, scaling, and management of containerized applications. Developed originally by Google and now governed by the Cloud Native Computing Foundation (CNCF), Kubernetes is the industry standard for container orchestration.
It allows you to manage clusters of hosts running Linux containers, providing mechanisms for:
- Deployment
- Maintenance
- Scaling of applications
Kubernetes is designed to enable the declarative configuration and automation of infrastructure. It abstracts the complexity of container lifecycle management, offering developers a consistent API regardless of the underlying infrastructure — be it AWS, Azure, GCP, bare metal, or hybrid environments.
Why Kubernetes?
- Automated scaling based on demand
- Self-healing capabilities (auto-restarts, rescheduling)
- Rolling updates and rollbacks
- Service discovery and load balancing
- Consistent environment across development, testing, and production
Major Use Cases of Kubernetes
Kubernetes supports a wide range of use cases across industries and domains. Here are the most common:
1. Microservices Architecture
Kubernetes is ideal for deploying and managing microservices. Each service runs in its own container, and Kubernetes orchestrates how they are deployed, scaled, and communicate.
2. Automated CI/CD Pipelines
Kubernetes integrates seamlessly with tools like Jenkins, Argo CD, GitLab, and Tekton to automate Continuous Integration and Continuous Deployment. It enables blue-green and canary deployments.
3. Hybrid and Multi-Cloud Deployments
Kubernetes abstracts infrastructure so that workloads can run across multiple environments—on-premises, private cloud, or multiple public cloud providers—without changing application code.
4. Resource Optimization
Through intelligent scheduling and bin packing, Kubernetes can significantly improve resource utilization, thereby reducing operational costs.
5. Self-Healing Infrastructure
Kubernetes monitors applications and automatically replaces or reschedules failed containers, ensuring minimal downtime without manual intervention.
6. Edge Computing and IoT
Lightweight Kubernetes distributions like K3s or MicroK8s allow orchestration of workloads on edge devices with constrained resources.
7. Batch and Event-Driven Workloads
Kubernetes supports scheduled jobs and event-driven architectures using tools like Knative for serverless workloads or Kafka for event processing.
How Kubernetes Works (Architecture & Components)
Kubernetes follows a master-worker (control plane – node) architecture with a rich set of components that manage the desired state of applications.
🔹 1. Kubernetes Control Plane (Master)
Responsible for managing the Kubernetes cluster and ensuring the desired state is maintained.
Components:
- API Server:
The front end of the Kubernetes control plane. All communication (CLI, UI, or tools) goes through the API server. - etcd:
A distributed key-value store used to persist cluster configuration and state. - Controller Manager:
Runs background processes that handle replication, node management, job tracking, etc. - Scheduler:
Assigns pods to nodes based on resource availability and constraints.
🔹 2. Worker Nodes
Nodes are the machines (VMs or physical servers) that run the containerized applications.
Node Components:
- kubelet:
Ensures containers are running in a Pod. Communicates with the API server. - kube-proxy:
Maintains network rules and facilitates communication between services and pods. - Container Runtime:
Executes containers. Supported runtimes include containerd, CRI-O, and Docker (deprecated).
🔹 3. Pods
The smallest deployable unit in Kubernetes. A pod may run a single container or multiple tightly coupled containers that share storage/network.
🔹 4. Services
A logical abstraction to expose a set of pods as a network service. Enables load balancing, internal DNS, and service discovery.
Types:
- ClusterIP (internal only)
- NodePort (exposes to external IP)
- LoadBalancer (cloud-integrated)
🔹 5. Additional Key Objects
- Deployments: Define how to create and manage pods declaratively.
- ReplicaSets: Maintain a specified number of pod replicas.
- Namespaces: Logical separation of cluster resources.
- ConfigMaps & Secrets: Externalize application config and sensitive data.
- Volumes & Persistent Volumes (PVs): Handle stateful workloads and persistent storage.
Basic Kubernetes Workflow
The Kubernetes workflow is declarative — you describe the desired state, and Kubernetes ensures the actual state matches it.
🛠️ 1. Define the Desired State
Using YAML/JSON files, you define what resources you want:
- How many replicas
- Which image to use
- CPU/memory limits
- Network policies
Example: deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-app
spec:
replicas: 3
selector:
matchLabels:
app: my-app
template:
metadata:
labels:
app: my-app
spec:
containers:
- name: my-app-container
image: nginx
ports:
- containerPort: 80
⚙️ 2. Apply to Cluster
kubectl apply -f deployment.yaml
🔄 3. Kubernetes Takes Over
- Scheduler selects nodes.
- Kubelet runs pods.
- Controller Manager maintains replicas.
- Service exposes application if defined.
🧠 4. Observe and Monitor
Use kubectl to check cluster status:
kubectl get pods
kubectl get services
kubectl describe pod <pod-name>
📈 5. Scale and Update
Update images or scale up replicas:
kubectl scale deployment my-app --replicas=5
kubectl set image deployment/my-app my-app-container=nginx:latest
🔄 6. Rollback If Needed
kubectl rollout undo deployment/my-app
Step-by-Step Getting Started Guide for Kubernetes
This guide uses Minikube to run Kubernetes locally. Alternatives include Kind, MicroK8s, or managed cloud clusters (EKS, AKS, GKE).
✅ Step 1: Install Prerequisites
- Install kubectl (CLI):
curl -LO "https://dl.k8s.io/release/$(curl -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
chmod +x kubectl && sudo mv kubectl /usr/local/bin/
- Install Minikube:
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
chmod +x minikube-linux-amd64 && sudo mv minikube-linux-amd64 /usr/local/bin/minikube
✅ Step 2: Start Kubernetes Cluster
minikube start --driver=docker
✅ Step 3: Deploy an Application
kubectl create deployment demo-app --image=nginx
kubectl expose deployment demo-app --type=NodePort --port=80
✅ Step 4: Access the Application
minikube service demo-app
✅ Step 5: Explore Cluster
kubectl get all
kubectl describe deployment demo-app
✅ Step 6: Scale Application
kubectl scale deployment demo-app --replicas=4
✅ Step 7: Delete Resources
kubectl delete service demo-app
kubectl delete deployment demo-app
minikube stop