Docker Kubernetes MasterClass: DevOps from Scratch

 

Introduction to DevOps

What Is DevOps and Why It Matters

DevOps is a fusion of “development” and “operations.” It’s more than a buzzword—it’s a culture shift that promotes collaboration between teams to deliver software faster and more reliably. With DevOps, the wall between coding and deployment comes down.

Benefits of DevOps Culture

Adopting DevOps leads to:

• Faster deployment cycles

• Improved collaboration

• Higher product quality

• Quicker bug fixes and updates

In short, DevOps helps businesses move at the speed of innovation.

The Role of Containers and Orchestration in DevOps

Containers (like Docker) allow apps to run the same way across environments. Orchestration tools (like Kubernetes) help manage, scale, and deploy these containers efficiently.

---

Getting Started with Docker

What Is Docker?

Docker is an open-source platform that lets developers package applications into containers—lightweight, standalone units that include everything needed to run the software.

Installing Docker on Your Machine

Setting up Docker is simple:

• Windows/macOS: Download Docker Desktop from docker.com

• Linux: Use your package manager:
  sudo apt install docker.io

Understanding Docker Images and Containers

• Images: Blueprints that contain code, runtime, libraries, etc.

• Containers: Running instances of images.

Think of an image like a recipe and a container as the dish you cook using that recipe.

Docker CLI Basics

Some essentials:

bash
docker pull nginx         # Download an image
docker run -d -p 80:80 nginx  # Run a container
docker ps                 # List running containers
docker stop <container_id>   # Stop a container

---

Building and Running Docker Containers

Creating Your First Dockerfile

A Dockerfile is a script used to build Docker images.

Dockerfile
FROM node:18
WORKDIR /app
COPY . .
RUN npm install
CMD ["npm", "start"]

Use docker build -t my-app . to build your image.

Docker Compose for Multi-Container Apps

Docker Compose lets you define multi-container apps (e.g., web + database) using a YAML file.

yaml
version: '3'
services:
  web:
    build: .
    ports:
      - "3000:3000"
  db:
    image: postgres

Start everything with docker-compose up.

Best Practices for Writing Dockerfiles

• Use lightweight base images (alpine)

• Minimize layers

• Avoid installing unnecessary packages

• Leverage .dockerignore to reduce context size

---

Introduction to Kubernetes

What Is Kubernetes and Why Use It?

Kubernetes (K8s) is a powerful container orchestration system. It automates deployment, scaling, and management of containerized apps.

Why it matters:

• Auto-scaling and self-healing

• Load balancing

• Seamless rollouts and rollbacks

Kubernetes Architecture Overview

Kubernetes consists of:

• Master node: Manages cluster

• Worker nodes: Run applications

• Components: Pods, Deployments, Services, etc.

Nodes, Pods, and Services

• Node: A physical/virtual machine

• Pod: The smallest deployable unit, which wraps one or more containers

• Service: An abstraction to expose your app to the network

---

Setting Up a Kubernetes Cluster

Minikube vs. Kind vs. Managed Services

• Minikube: Great for local testing

• Kind: Kubernetes in Docker

• GKE, EKS, AKS: Google, AWS, Azure managed clusters

Deploying Your First App to Kubernetes

1. Create a deployment YAML:

yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: hello
  template:
    metadata:
      labels:
        app: hello
    spec:
      containers:
      - name: hello
        image: nginx

2. Apply it:

bash
kubectl apply -f deployment.yaml

kubectl Commands You Must Know

bash
kubectl get pods
kubectl describe pod <name>
kubectl logs <name>
kubectl delete -f deployment.yaml

---

Kubernetes Configurations and Manifests

Writing YAML for Pods, Deployments, and Services

• YAML defines how Kubernetes resources behave

• Always double-check spacing—YAML is picky!

Using ConfigMaps and Secrets

Store configuration separately:

bash
kubectl create configmap app-config --from-literal=MODE=production
kubectl create secret generic db-secret --from-literal=PASSWORD=1234

Namespace and Resource Management

Namespaces let you organize environments (dev, staging, prod). Use resource limits to control CPU/memory usage.

---

Scaling and Load Balancing

Horizontal Pod Autoscaling

bash
kubectl autoscale deployment hello-app --cpu-percent=50 --min=1 --max=10

Services and Ingress Controllers

• ClusterIP: Internal access

• NodePort: Expose app on each node's IP

• LoadBalancer: Cloud-based external access

• Ingress: Manages routing based on hostname/path

Rolling Updates and Rollbacks

Update your app with zero downtime:

bash
kubectl rollout restart deployment hello-app
kubectl rollout undo deployment hello-app

---

Persistent Storage in Kubernetes

Volumes vs. Persistent Volumes

• Volumes are temporary

• Persistent Volumes (PVs) survive pod restarts

StatefulSets for Stateful Applications

Use StatefulSets for apps like databases that require stable storage and identity.

Storage Classes and Provisioning

Dynamic provisioning allows automatic creation of storage with different performance profiles.

---

CI/CD Integration with Docker and Kubernetes

Introduction to CI/CD Pipelines

CI/CD automates testing and deployment:

• CI: Test & build

• CD: Release & deploy

Jenkins, GitHub Actions, and GitLab CI Integration

You can integrate Docker/Kubernetes with:

• Jenkins pipelines

• GitHub Actions (.github/workflows)

• GitLab CI/CD (.gitlab-ci.yml)

Deploying Automatically to Kubernetes

Use tools like:

• Helm

• ArgoCD

• Skaffold

---

Monitoring and Logging

Prometheus and Grafana

• Prometheus: Metrics collection

• Grafana: Visual dashboards

Install via Helm:

bash
helm install prometheus prometheus-community/kube-prometheus-stack

Centralized Logging with ELK Stack

ELK = Elasticsearch + Logstash + Kibana. Or use Fluentd + Grafana Loki.

Health Checks and Metrics

Use readiness and liveness probes to monitor app health.

---

Security Best Practices

Image Scanning and Vulnerability Management

Scan images with:

• Trivy

• Snyk

• Clair

Kubernetes RBAC and Network Policies

Control access using Roles and RoleBindings. Define what users/services can do and where they can connect.

Secrets Management

Never hard-code secrets. Use Kubernetes Secrets or external tools like HashiCorp Vault.

---

Troubleshooting and Debugging

Common Docker Issues

• Image not found? Check tag.

• Port already in use? Try a different one.

• Container crashing? Check logs.

Kubernetes Pod Fails - What to Do

Use:

bash
kubectl describe pod <name>
kubectl logs <name>

Logs, Events, and Describe Commands

Always check:

• kubectl get events

• kubectl describe <resource>

• kubectl logs -f <pod-name>

---

Real-World Projects and Use Cases

Deploying a Microservices Application

Break apps into services like user, payment, and orders. Use Docker and Kubernetes to deploy each one independently.

CI/CD Pipeline with Helm

Helm simplifies K8s deployment:

bash
helm install myapp ./chart

Blue/Green Deployments

Deploy new versions side-by-side. Route traffic slowly from old to new to reduce risk.

---

DevOps Career Roadmap

Skills You Need to Master

• Docker

• Kubernetes

• CI/CD tools

• Scripting (Bash, Python)

• Cloud Platforms (AWS, GCP)

Certification Paths (CKA, DCA)

• CKA: Certified Kubernetes Administrator

• DCA: Docker Certified Associate

Interview and Resume Tips

• Highlight real-world projects

• Use GitHub portfolio

• Be ready for hands-on assessments

---

Conclusion

Mastering Docker and Kubernetes from scratch is a game-changer for any aspiring DevOps engineer. With containers, orchestration, automation, and proper monitoring, you can build and manage systems that scale effortlessly and deploy like a pro. Whether you’re just starting or aiming to become certified, this MasterClass gives you the solid foundation to thrive in the world of DevOps.

---

FAQs

1. Can I learn Docker and Kubernetes without a programming background?
Yes, basic scripting helps, but you can start without deep coding skills.

2. Is Kubernetes only used with Docker?
Nope! Kubernetes supports other runtimes like containerd and CRI-O too.

3. Do I need to use the cloud to run Kubernetes?
Not at all. You can run it locally with Minikube or Kind.

4. What’s the best way to practice?
Hands-on labs, building sample projects, and trying platforms like Katacoda or Play with Kubernetes.

5. Are Docker and Kubernetes still in demand in 2025?
Absolutely. They’re foundational in modern DevOps, cloud-native, and microservices ecosystems.