DEV Community: Imran

🧠 The Ultimate Kubernetes Guide — From Zero to Pro (With Hands-On YAML)

Imran — Thu, 31 Jul 2025 01:43:08 +0000

Kubernetes is the operating system of the cloud—and understanding it is essential for modern DevOps, SaaS, and full-stack development. Whether you're a beginner or looking to deepen your knowledge, this tutorial will walk you through every core concept with real-world examples.

📦 What is Kubernetes?

Kubernetes (K8s) is an open-source container orchestration platform that helps you deploy, scale, and manage containerized applications.

Imagine running 100+ microservices. How do you keep them alive, ensure networking, balance traffic, and roll out updates safely? That’s what Kubernetes automates.

🔧 Why Use Kubernetes?

🚀 Auto-scaling and load balancing
🔁 Self-healing (crash recovery, restart)
🛠️ Rolling updates with zero downtime
🔐 Secrets & configuration management
🗃️ Persistent storage
🌐 Ingress + traffic routing
🧱 Infrastructure-as-Code (YAML)

🛠️ Kubernetes Core Components (Visualized)

Component	Description
Pod	Smallest unit in K8s. Runs 1+ containers.
Deployment	Manages pods & versions over time.
Service	Exposes your pods within/outside the cluster.
Ingress	Manages HTTP/HTTPS routing to services.
ConfigMap	Externalizes config data (non-sensitive).
Secret	Injects sensitive data (passwords, tokens).
PVC	Persistent storage requests for stateful apps.
Node	A VM or physical machine in the cluster.

🧱 Hands-On: Create a Complete K8s App Stack

We'll now walk through creating:

A simple Node.js app
A Deployment to manage it
A Service to expose it
A ConfigMap and Secret
A PersistentVolumeClaim

📁 Step 1: `deployment.yaml`

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
        - name: my-app
          image: node:18
          command: ["node", "-e", "require('http').createServer((_,res)=>res.end('Hi')).listen(3000)"]
          ports:
            - containerPort: 3000

✅ What it does:

Launches 2 pods of a Node.js app
Uses node:18 as base image
Exposes port 3000 inside the container

🌐 Step 2: `service.yaml`

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

✅ What it does:

Makes the app available via port 30080on your node
Load-balances between the pods
Accepts requests on port 80, routes to 3000

⚙️ Step 3: `configmap.yaml`

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  APP_ENV: production

✅ What it does:

Stores non-sensitive environment variables
Can be injected into your pod like this:

envFrom:
  - configMapRef:
      name: app-config

🔐 Step 4: `secret.yaml`

apiVersion: v1
kind: Secret
metadata:
  name: db-secret
type: Opaque
data:
  DB_PASSWORD: bXlTZWNyZXRQYXNz

✅ What it does:

Encodes secrets in base64 (e.g. mySecretPass)
You can inject it in your pod:

env:
  - name: DB_PASSWORD
    valueFrom:
      secretKeyRef:
        name: db-secret
        key: DB_PASSWORD

💾 Step 5:`pvc.yaml`

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

✅ What it does:

Requests 1 GB of storage
You can mount it into your pod at /data:

volumes:
  - name: storage
    persistentVolumeClaim:
      claimName: my-pvc

volumeMounts:
  - name: storage
    mountPath: /data

🚀 Running Everything

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml
kubectl apply -f configmap.yaml
kubectl apply -f secret.yaml
kubectl apply -f pvc.yaml

📚 Bonus: Useful K8s Commands

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

❤️ Support & Follow

If you found this helpful:

🧠 Follow me for more DevOps + Cloud tutorials
💬 Comment your Kubernetes use-case
⭐ Save this post for later

🚀 Master Docker: A DevOps-Grade Tutorial for Developers and Engineers 🐳

Imran — Thu, 31 Jul 2025 01:00:35 +0000

📌 Why Docker?

Docker eliminates "it works on my machine" problems by containerizing apps along with their environments. It’s the backbone of modern DevOps, enabling reproducible builds, fast deployments, and scalable infrastructure.

Whether you're building microservices, APIs, frontends, or full-stack SaaS apps—Docker is essential.

🔧 Prerequisites:
✅ Basic CLI knowledge
✅ A project or app to test Docker with (Node.js used here, but language doesn't matter)

🛠️ 1. Install Docker

🖥️ macOS / Windows
➡️ Install Docker Desktop: https://www.docker.com/products/docker-desktop

sudo apt update
sudo apt install docker.io -y
sudo systemctl start docker
sudo systemctl enable docker

Verify
docker --version

🐳 2. Understand Docker’s Core Concepts

Concept	Description
Image	A blueprint of your app (like a class)
Container	A running instance of an image
Dockerfile	Instructions to build your image
Volume	Persistent storage for containers
Network	Allows containers to communicate
Registry	Stores images (like Docker Hub or GitHub Container Registry)

🚀 3. Running Your First Container

docker run hello-world
Explanation:

Pulls the hello-world image
Runs it inside a new container
Shows a success message

🧱 4. Create and Use a Dockerfile

Step-by-step: Let's Dockerize a Node.js app.
Project:

mkdir myapp && cd myapp
npm init -y
npm i express
echo "require('express')().listen(3000)" > index.js

DockerFile :

# Base image
FROM node:18

# Set working directory
WORKDIR /app

# Copy files
COPY package*.json ./
RUN npm install
COPY . .

# Expose and run
EXPOSE 3000
CMD ["node", "index.js"]

Build and Run:

docker build -t myapp .
docker run -p 3000:3000 myapp

📦 5. Use Volumes (Dev Mode)

So changes reflect without rebuilds:

docker run -p 3000:3000 -v $(pwd):/app myapp

🔁 6. Docker Compose – Multi-Container Apps

Example: Node.js app + MongoDB

<pre>
version: '3.9'
services:
  app:
    build: .
    ports:
      - "3000:3000"
    volumes:
      - .:/app
    environment:
      - NODE_ENV=development
    depends_on:
      - mongo

  mongo:
    image: mongo
    volumes:
      - mongodata:/data/db
    ports:
      - "27017:27017"

volumes:
  mongodata:

</pre>

*** Run: ***

docker-compose up --build

💡7. Multi-Stage Docker Builds

Reduce image size and isolate build from production:

# Stage 1: Build
FROM node:18 AS builder
WORKDIR /app
COPY . .
RUN npm install && npm run build

# Stage 2: Runtime
FROM node:18-slim
WORKDIR /app
COPY --from=builder /app/dist .
CMD ["node", "server.js"]

🧰 8. Helpful Docker Commands

docker ps -a                 # List all containers
docker images                # List images
docker logs <container>      # Logs
docker exec -it <container> bash  # Enter container
docker stop <id>             # Stop container
docker rm <id>               # Remove container
docker rmi <image>           # Remove image

🔐 9. Docker Security Best Practices

✅ Use minimal base images (alpine, node:slim)
✅ Use .dockerignore like .gitignore
✅ Run as non-root if possible
✅ Use image scanning tools:

docker scout quickview
# or
trivy image myapp

🔄 10. Real DevOps CI/CD with Docker

GitHub Actions Example:

<pre>
name: Docker CI

on:
  push:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Build Docker image
        run: docker build -t myorg/myapp:${{ github.sha }} .

      - name: Push to Docker Hub
        run: |
          echo "${{ secrets.DOCKER_PASS }}" | docker login -u ${{ secrets.DOCKER_USER }} --password-stdin
          docker push myorg/myapp:${{ github.sha }}
</pre>

🧪 11. Advanced Real-World Scenarios

📌 Run PostgreSQL + Adminer for Dev:

services:
  db:
    image: postgres
    environment:
      POSTGRES_PASSWORD: pass

  adminer:
    image: adminer
    ports:
      - "8080:8080"

🧩 Host React or Next.js with Nginx:

FROM node:18 AS builder
WORKDIR /app
COPY . .
RUN npm install && npm run build

FROM nginx:alpine
COPY --from=builder /app/build /usr/share/nginx/html

🧼 12. Clean Up Resources

docker system prune -a
docker volume prune
docker image prune

🧠 Conclusion: Docker is DevOps

Once you’ve mastered Docker:

Build fast, reproducible workflows
Deploy secure, production-ready images
Use in CI/CD pipelines
Plug into Kubernetes or serverless platforms

💬 Want More?

Let me know in the comments if you want a follow-up:

🧭 Kubernetes for Docker users
🛠️ Docker + Ansible + Terraform workflow
🧠 Docker debugging & profiling tools

🧑‍💻 Connect With Me

📺 YouTube: Codewithimran
🐙 GitHub: Codewithimran
💡 LinkedIn: Codewithimran

DEV Community: Imran

🧠 The Ultimate Kubernetes Guide — From Zero to Pro (With Hands-On YAML)

📦 What is Kubernetes?

🔧 Why Use Kubernetes?

🛠️ Kubernetes Core Components (Visualized)

🧱 Hands-On: Create a Complete K8s App Stack

📁 Step 1: deployment.yaml

✅ What it does:

🌐 Step 2: service.yaml

✅ What it does:

⚙️ Step 3: configmap.yaml

✅ What it does:

🔐 Step 4: secret.yaml

✅ What it does:

💾 Step 5:pvc.yaml

✅ What it does:

🚀 Running Everything

📚 Bonus: Useful K8s Commands

❤️ Support & Follow

🚀 Master Docker: A DevOps-Grade Tutorial for Developers and Engineers 🐳

🛠️ 1. Install Docker

🐳 2. Understand Docker’s Core Concepts

🚀 3. Running Your First Container

🧱 4. Create and Use a Dockerfile

📦 5. Use Volumes (Dev Mode)

🔁 6. Docker Compose – Multi-Container Apps

💡7. Multi-Stage Docker Builds

🧰 8. Helpful Docker Commands

🔐 9. Docker Security Best Practices

🔄 10. Real DevOps CI/CD with Docker

🧪 11. Advanced Real-World Scenarios

🧼 12. Clean Up Resources

🧠 Conclusion: Docker is DevOps

💬 Want More?

🧑‍💻 Connect With Me

📁 Step 1: `deployment.yaml`

🌐 Step 2: `service.yaml`

⚙️ Step 3: `configmap.yaml`

🔐 Step 4: `secret.yaml`

💾 Step 5:`pvc.yaml`