@icarusmx/creta 1.5.11 → 1.5.13

package/lib/exercises/09-docker-first-steps.md

@@ -0,0 +1,1475 @@
+# Docker First Steps - Containers Without the Confusion
+
+<!-- vim: set foldmethod=marker foldlevel=0: -->
+
+## 📖 LazyVim Reading Guide {{{
+
+**Start with:** `zM` (close all folds) → Navigate with `za` (toggle fold under cursor)
+
+This document uses fold markers `{{{` and `}}}` for organized reading.
+
+}}}
+
+## 🚨 Problem: "It Works on My Machine" {{{
+
+You've built something amazing on your laptop, but:
+- **Teammate:** "It doesn't run on my computer"
+- **Server:** "Missing dependencies"
+- **You 6 months later:** "How did I even set this up?"
+
+**Common complaints:**
+- Different OS versions cause conflicts
+- Forgotten dependencies
+- Environment variables lost
+- "Works locally, breaks in production"
+
+**The root cause:** Your code depends on a specific environment that doesn't travel with your code.
+
+}}}
+
+## ✅ Solution: Docker Containers {{{
+
+Docker packages your app **WITH its environment** into a portable container.
+
+**Think of it like this:**
+- **Without Docker:** Shipping furniture assembly instructions to someone without tools
+- **With Docker:** Shipping a fully assembled furniture piece
+
+**What Docker gives you:**
+- 📦 **Portability** - Runs the same everywhere (Mac, Linux, Windows, cloud)
+- 🔒 **Isolation** - Each container is its own sandbox
+- 🚀 **Consistency** - Same environment from dev to production
+- ⚡ **Speed** - Lighter than virtual machines
+
+**Core concept:** A container is a running instance of an image.
+
+}}}
+
+## 🎯 Core Concepts {{{
+
+### Images vs Containers {{{
+
+**Image:**
+- Blueprint or recipe
+- Static, read-only template
+- Contains: code, dependencies, OS libraries
+- Stored on your machine or Docker Hub
+
+**Container:**
+- Running instance of an image
+- Active, can be started/stopped
+- Isolated process with its own filesystem
+- Dies when stopped (unless you persist data)
+
+**Analogy:**
+- **Image** = Cookie cutter
+- **Container** = Actual cookie
+
+**Example:**
+```bash
+# Image = node:20 (blueprint for Node.js 20 environment)
+# Container = your-running-app (actual running instance)
+```
+
+}}}
+
+### Dockerfile: The Recipe {{{
+
+A `Dockerfile` is a text file that defines **how to build an image**.
+
+**Basic structure:**
+```dockerfile
+FROM node:20           # Start from base image
+WORKDIR /app           # Set working directory
+COPY . .               # Copy your code
+RUN npm install        # Install dependencies
+CMD ["npm", "start"]   # Command to run when container starts
+```
+
+**Think of it as:**
+- `FROM` = "Start with a blank Node.js environment"
+- `WORKDIR` = "Create and enter /app folder"
+- `COPY` = "Copy my code into the container"
+- `RUN` = "Execute commands during build"
+- `CMD` = "What to run when container starts"
+
+}}}
+
+### Docker Hub: The Library {{{
+
+**Docker Hub** = GitHub for Docker images
+
+**Official images available:**
+- `node` - Node.js environments
+- `python` - Python environments
+- `nginx` - Web server
+- `postgres` - PostgreSQL database
+- `mysql` - MySQL database
+
+**Usage:**
+```bash
+# Pull official Node.js 20 image
+docker pull node:20
+
+# Pull specific version
+docker pull postgres:15
+```
+
+**Pro tip:** Always specify a version tag (e.g., `node:20`) instead of using `latest` for reproducibility.
+
+}}}
+
+}}}
+
+## 🔧 Installation {{{
+
+### macOS (Recommended: Docker Desktop) {{{
+
+**Option 1: Download from website**
+1. Visit: https://www.docker.com/products/docker-desktop
+2. Download Docker Desktop for Mac
+3. Install (drag to Applications)
+4. Launch Docker Desktop
+5. Wait for Docker icon in menu bar to show "running"
+
+**Option 2: Homebrew**
+```bash
+brew install --cask docker
+```
+
+**Verify installation:**
+```bash
+docker --version
+# Docker version 24.x.x
+
+docker run hello-world
+# Should download and run test container
+```
+
+}}}
+
+### Linux (Ubuntu/Debian) {{{
+
+**Install Docker Engine:**
+```bash
+# Update package index
+sudo apt update
+
+# Install required packages
+sudo apt install -y apt-transport-https ca-certificates curl software-properties-common
+
+# Add Docker's official GPG key
+curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
+
+# Add Docker repository
+echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
+
+# Install Docker
+sudo apt update
+sudo apt install -y docker-ce docker-ce-cli containerd.io
+
+# Add your user to docker group (avoid sudo)
+sudo usermod -aG docker $USER
+newgrp docker  # Apply group change
+
+# Verify
+docker --version
+docker run hello-world
+```
+
+}}}
+
+### Windows (WSL2 + Docker Desktop) {{{
+
+**Prerequisites:**
+1. Windows 10 64-bit: Pro, Enterprise, or Education (Build 19041+)
+2. Enable WSL2
+
+**Steps:**
+1. Download Docker Desktop from https://www.docker.com/products/docker-desktop
+2. Run installer
+3. Ensure "Use WSL 2 instead of Hyper-V" is checked
+4. Restart computer
+5. Launch Docker Desktop
+
+**Verify in PowerShell or WSL:**
+```bash
+docker --version
+docker run hello-world
+```
+
+}}}
+
+}}}
+
+## 🏃 Your First Container {{{
+
+### Step 1: Run a Pre-built Image {{{
+
+**Start with official nginx web server:**
+```bash
+# Run nginx in detached mode
+docker run -d -p 8080:80 --name my-nginx nginx
+
+# Breakdown:
+# -d              = detached (runs in background)
+# -p 8080:80      = map port 80 in container to 8080 on your machine
+# --name my-nginx = give container a friendly name
+# nginx           = image to use
+```
+
+**Test it:**
+```bash
+# Open browser to http://localhost:8080
+# You should see "Welcome to nginx!"
+```
+
+**What just happened:**
+1. Docker checked if `nginx` image exists locally
+2. Didn't find it → downloaded from Docker Hub
+3. Created container from image
+4. Started nginx web server inside container
+5. Exposed port 80 (inside) as 8080 (outside)
+
+}}}
+
+### Step 2: Interact with Running Container {{{
+
+**View running containers:**
+```bash
+docker ps
+
+# Output shows:
+# CONTAINER ID   IMAGE   COMMAND   CREATED   STATUS   PORTS   NAMES
+# abc123...      nginx   ...       ...       Up       0.0.0.0:8080->80/tcp   my-nginx
+```
+
+**Execute command inside container:**
+```bash
+# Open bash shell inside container
+docker exec -it my-nginx bash
+
+# You're now "inside" the container!
+# Try:
+ls /usr/share/nginx/html  # See nginx files
+exit  # Leave container (it keeps running)
+```
+
+**View logs:**
+```bash
+docker logs my-nginx
+
+# See nginx access logs
+# Every time you visit http://localhost:8080, new log appears
+```
+
+}}}
+
+### Step 3: Stop and Remove Container {{{
+
+**Stop container:**
+```bash
+docker stop my-nginx
+
+# Container stops but still exists
+```
+
+**Verify it's stopped:**
+```bash
+docker ps        # Shows running containers (empty)
+docker ps -a     # Shows all containers (includes stopped)
+```
+
+**Remove container:**
+```bash
+docker rm my-nginx
+
+# Now it's completely gone
+```
+
+**One-liner to stop and remove:**
+```bash
+docker rm -f my-nginx
+# -f forces removal even if running
+```
+
+}}}
+
+}}}
+
+## 🏗️ Build Your Own Image {{{
+
+### Step 1: Create a Simple Node.js App {{{
+
+**Project structure:**
+```bash
+my-docker-app/
+├── Dockerfile
+├── package.json
+└── server.js
+```
+
+**Create files:**
+
+**server.js:**
+```javascript
+const http = require('http');
+
+const server = http.createServer((req, res) => {
+  res.writeHead(200, { 'Content-Type': 'text/plain' });
+  res.end('Hello from Docker container!\n');
+});
+
+server.listen(3000, '0.0.0.0', () => {
+  console.log('Server running on port 3000');
+});
+```
+
+**package.json:**
+```json
+{
+  "name": "my-docker-app",
+  "version": "1.0.0",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js"
+  }
+}
+```
+
+}}}
+
+### Step 2: Write a Dockerfile {{{
+
+**Dockerfile:**
+```dockerfile
+# Use official Node.js 20 image as base
+FROM node:20
+
+# Set working directory inside container
+WORKDIR /app
+
+# Copy package.json (if you had dependencies, would run npm install here)
+COPY package.json .
+
+# Copy application code
+COPY server.js .
+
+# Expose port 3000 (documentation only, doesn't actually publish)
+EXPOSE 3000
+
+# Command to run when container starts
+CMD ["npm", "start"]
+```
+
+**Line-by-line explanation:**
+1. `FROM node:20` - Start with Node.js 20 environment
+2. `WORKDIR /app` - All subsequent commands run in /app directory
+3. `COPY package.json .` - Copy package.json from your machine to container
+4. `COPY server.js .` - Copy server.js to container
+5. `EXPOSE 3000` - Document that container listens on port 3000
+6. `CMD ["npm", "start"]` - Run `npm start` when container starts
+
+}}}
+
+### Step 3: Build the Image {{{
+
+**Build command:**
+```bash
+# Navigate to project directory
+cd my-docker-app
+
+# Build image
+docker build -t my-app:1.0 .
+
+# Breakdown:
+# build          = build an image
+# -t my-app:1.0  = tag it as "my-app" version "1.0"
+# .              = Dockerfile is in current directory
+```
+
+**Watch the build process:**
+```
+[+] Building 12.3s (9/9) FINISHED
+ => [internal] load build definition from Dockerfile
+ => [internal] load .dockerignore
+ => [1/4] FROM docker.io/library/node:20
+ => [2/4] WORKDIR /app
+ => [3/4] COPY package.json .
+ => [4/4] COPY server.js .
+ => exporting to image
+ => => naming to docker.io/library/my-app:1.0
+```
+
+**Verify image exists:**
+```bash
+docker images
+
+# Output:
+# REPOSITORY   TAG   IMAGE ID       CREATED         SIZE
+# my-app       1.0   xyz789...      2 minutes ago   1.1GB
+```
+
+}}}
+
+### Step 4: Run Your Custom Image {{{
+
+**Start container from your image:**
+```bash
+docker run -d -p 3000:3000 --name my-container my-app:1.0
+```
+
+**Test it:**
+```bash
+curl http://localhost:3000
+# Hello from Docker container!
+```
+
+**Check logs:**
+```bash
+docker logs my-container
+# Server running on port 3000
+```
+
+**Success!** You've built and run your own Docker image. 🎉
+
+}}}
+
+}}}
+
+## 💾 Working with Data {{{
+
+### The Problem: Containers are Ephemeral {{{
+
+**What happens:**
+```bash
+# Start container
+docker run -d --name test-db postgres
+
+# Container writes data to /var/lib/postgresql/data (inside container)
+
+# Stop and remove container
+docker rm -f test-db
+
+# All data is GONE! 💀
+```
+
+**Why:** Containers are temporary. When removed, everything inside dies.
+
+}}}
+
+### Solution: Volumes {{{
+
+**Volumes** persist data outside containers.
+
+**Named volume (recommended):**
+```bash
+# Create volume
+docker volume create my-data
+
+# Run container with volume mounted
+docker run -d \
+  --name test-db \
+  -v my-data:/var/lib/postgresql/data \
+  postgres
+
+# Breakdown:
+# -v my-data:/var/lib/postgresql/data
+#    ↑                ↑
+#    Volume name      Path inside container
+```
+
+**Now data persists:**
+```bash
+# Remove container
+docker rm -f test-db
+
+# Data still exists in volume
+docker volume ls
+# DRIVER    VOLUME NAME
+# local     my-data
+
+# Start new container with same volume
+docker run -d --name test-db-2 -v my-data:/var/lib/postgresql/data postgres
+# All previous data is back!
+```
+
+}}}
+
+### Bind Mounts: Development Workflow {{{
+
+**Use case:** Live code changes without rebuilding
+
+**Example:**
+```bash
+# Mount your local code directory into container
+docker run -d \
+  --name dev-server \
+  -p 3000:3000 \
+  -v $(pwd):/app \
+  node:20 \
+  sh -c "cd /app && npm install && npm start"
+
+# Breakdown:
+# -v $(pwd):/app
+#    ↑        ↑
+#    Your local directory → /app in container
+```
+
+**Now:**
+- Edit `server.js` on your machine
+- Changes appear instantly in container
+- Restart container to see changes (or use nodemon for auto-restart)
+
+**Pro tip:** Use `.dockerignore` to exclude `node_modules/` from bind mounts.
+
+}}}
+
+}}}
+
+## 🌐 Docker Compose: Multi-Container Apps {{{
+
+### The Problem: Complex Multi-Service Apps {{{
+
+**Typical web app needs:**
+- Frontend (React/Svelte)
+- Backend (Node.js/Express)
+- Database (PostgreSQL)
+- Cache (Redis)
+
+**Without Docker Compose:**
+```bash
+# Start database
+docker run -d --name db -v db-data:/var/lib/postgresql/data postgres
+
+# Start Redis
+docker run -d --name cache redis
+
+# Build backend
+docker build -t backend .
+docker run -d --name api -p 5000:5000 --link db --link cache backend
+
+# Build frontend
+docker build -t frontend .
+docker run -d --name web -p 3000:3000 --link api frontend
+```
+
+**Too much manual work!** 😫
+
+}}}
+
+### Solution: docker-compose.yml {{{
+
+**Define all services in one file:**
+
+**docker-compose.yml:**
+```yaml
+version: '3.8'
+
+services:
+  # PostgreSQL database
+  db:
+    image: postgres:15
+    environment:
+      POSTGRES_PASSWORD: secret
+      POSTGRES_DB: myapp
+    volumes:
+      - db-data:/var/lib/postgresql/data
+
+  # Redis cache
+  cache:
+    image: redis:7
+
+  # Backend API
+  api:
+    build: ./backend
+    ports:
+      - "5000:5000"
+    environment:
+      DATABASE_URL: postgres://postgres:secret@db:5432/myapp
+      REDIS_URL: redis://cache:6379
+    depends_on:
+      - db
+      - cache
+
+  # Frontend
+  web:
+    build: ./frontend
+    ports:
+      - "3000:3000"
+    environment:
+      API_URL: http://api:5000
+    depends_on:
+      - api
+
+volumes:
+  db-data:
+```
+
+**Start entire stack:**
+```bash
+docker-compose up -d
+
+# All services start in correct order!
+```
+
+**Stop entire stack:**
+```bash
+docker-compose down
+```
+
+**View logs:**
+```bash
+# All services
+docker-compose logs -f
+
+# Specific service
+docker-compose logs -f api
+```
+
+}}}
+
+### Development Workflow with Compose {{{
+
+**docker-compose.yml for development:**
+```yaml
+version: '3.8'
+
+services:
+  app:
+    build: .
+    ports:
+      - "3000:3000"
+    volumes:
+      # Bind mount for live code changes
+      - .:/app
+      - /app/node_modules  # Don't overwrite node_modules
+    environment:
+      NODE_ENV: development
+    command: npm run dev  # Use dev script with auto-reload
+```
+
+**Workflow:**
+```bash
+# Start dev environment
+docker-compose up
+
+# Edit code on your machine
+# Changes reflect immediately (with hot reload)
+
+# Stop
+Ctrl+C
+docker-compose down
+```
+
+}}}
+
+}}}
+
+## 🧪 Practice Exercises {{{
+
+### Exercise 1: Run and Explore {{{
+
+**Goal:** Get comfortable with basic container operations
+
+**Steps:**
+```bash
+# 1. Run Ubuntu container interactively
+docker run -it ubuntu bash
+
+# 2. Inside container, explore:
+pwd                 # Where am I? (/root)
+ls                  # What's here?
+apt update          # Update package lists
+apt install -y curl # Install curl
+curl https://api.github.com/users/github | head -n 5
+exit                # Leave container
+
+# 3. Container is now stopped but exists
+docker ps -a | grep ubuntu
+
+# 4. Restart it
+docker start <container-id>
+docker exec -it <container-id> bash
+
+# curl still installed! (because container still exists)
+
+# 5. Clean up
+exit
+docker rm -f <container-id>
+```
+
+**Key learning:** Stopped containers preserve their state until removed.
+
+}}}
+
+### Exercise 2: Build a Python Web App {{{
+
+**Goal:** Create and containerize a simple Flask app
+
+**Files to create:**
+
+**app.py:**
+```python
+from flask import Flask
+app = Flask(__name__)
+
+@app.route('/')
+def hello():
+    return "Hello from Python in Docker!"
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=5000)
+```
+
+**requirements.txt:**
+```
+flask==3.0.0
+```
+
+**Dockerfile:**
+```dockerfile
+FROM python:3.11
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+COPY app.py .
+
+EXPOSE 5000
+
+CMD ["python", "app.py"]
+```
+
+**Build and run:**
+```bash
+docker build -t flask-app .
+docker run -d -p 5000:5000 --name my-flask flask-app
+
+# Test
+curl http://localhost:5000
+# Hello from Python in Docker!
+
+# Clean up
+docker rm -f my-flask
+```
+
+}}}
+
+### Exercise 3: Persistent Database {{{
+
+**Goal:** Run PostgreSQL with persistent data
+
+**Steps:**
+```bash
+# 1. Create volume
+docker volume create pg-data
+
+# 2. Start PostgreSQL with volume
+docker run -d \
+  --name my-postgres \
+  -e POSTGRES_PASSWORD=mypassword \
+  -e POSTGRES_DB=testdb \
+  -v pg-data:/var/lib/postgresql/data \
+  -p 5432:5432 \
+  postgres:15
+
+# 3. Connect and create table
+docker exec -it my-postgres psql -U postgres -d testdb
+
+# Inside psql:
+CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT);
+INSERT INTO users (name) VALUES ('Alice'), ('Bob');
+SELECT * FROM users;
+\q
+
+# 4. Destroy container
+docker rm -f my-postgres
+
+# 5. Start new container with same volume
+docker run -d \
+  --name my-postgres-2 \
+  -e POSTGRES_PASSWORD=mypassword \
+  -e POSTGRES_DB=testdb \
+  -v pg-data:/var/lib/postgresql/data \
+  -p 5432:5432 \
+  postgres:15
+
+# 6. Check data persisted
+docker exec -it my-postgres-2 psql -U postgres -d testdb -c "SELECT * FROM users;"
+# id | name
+# ----+-------
+#  1 | Alice
+#  2 | Bob
+
+# Data survived! 🎉
+```
+
+}}}
+
+### Exercise 4: Full Stack with Compose {{{
+
+**Goal:** Deploy a full web app stack
+
+**Project structure:**
+```
+fullstack-app/
+├── docker-compose.yml
+├── backend/
+│   ├── Dockerfile
+│   └── server.js
+└── frontend/
+    ├── Dockerfile
+    └── index.html
+```
+
+**docker-compose.yml:**
+```yaml
+version: '3.8'
+
+services:
+  backend:
+    build: ./backend
+    ports:
+      - "5000:5000"
+    environment:
+      DB_HOST: db
+      DB_NAME: myapp
+      DB_PASSWORD: secret
+    depends_on:
+      - db
+
+  frontend:
+    build: ./frontend
+    ports:
+      - "3000:3000"
+    depends_on:
+      - backend
+
+  db:
+    image: postgres:15
+    environment:
+      POSTGRES_PASSWORD: secret
+      POSTGRES_DB: myapp
+    volumes:
+      - db-data:/var/lib/postgresql/data
+
+volumes:
+  db-data:
+```
+
+**backend/Dockerfile:**
+```dockerfile
+FROM node:20
+WORKDIR /app
+COPY package.json .
+RUN npm install
+COPY . .
+EXPOSE 5000
+CMD ["npm", "start"]
+```
+
+**frontend/Dockerfile:**
+```dockerfile
+FROM nginx:alpine
+COPY index.html /usr/share/nginx/html/
+EXPOSE 3000
+```
+
+**Run:**
+```bash
+cd fullstack-app
+docker-compose up -d
+
+# All services start together!
+# Frontend: http://localhost:3000
+# Backend: http://localhost:5000
+# Database: localhost:5432
+
+# Stop
+docker-compose down
+```
+
+}}}
+
+}}}
+
+## 🛡️ Best Practices {{{
+
+### Always Use Specific Image Tags {{{
+
+**❌ Bad:**
+```dockerfile
+FROM node
+FROM python
+```
+
+**✅ Good:**
+```dockerfile
+FROM node:20-alpine
+FROM python:3.11-slim
+```
+
+**Why:** `latest` changes over time, breaking reproducibility.
+
+}}}
+
+### Use .dockerignore {{{
+
+**Create .dockerignore:**
+```
+node_modules/
+npm-debug.log
+.git/
+.env
+*.md
+.DS_Store
+```
+
+**Why:** Faster builds, smaller images, no sensitive data leaked.
+
+}}}
+
+### Multi-Stage Builds for Production {{{
+
+**Problem:** Build tools bloat final image
+
+**Solution:**
+```dockerfile
+# Build stage
+FROM node:20 AS build
+WORKDIR /app
+COPY package*.json .
+RUN npm install
+COPY . .
+RUN npm run build
+
+# Production stage
+FROM node:20-alpine
+WORKDIR /app
+COPY --from=build /app/dist ./dist
+COPY package*.json .
+RUN npm install --production
+CMD ["node", "dist/server.js"]
+```
+
+**Result:** Final image only has production dependencies and built code.
+
+}}}
+
+### Don't Run as Root {{{
+
+**❌ Bad:**
+```dockerfile
+FROM node:20
+WORKDIR /app
+COPY . .
+CMD ["npm", "start"]  # Runs as root
+```
+
+**✅ Good:**
+```dockerfile
+FROM node:20
+WORKDIR /app
+COPY . .
+RUN chown -R node:node /app
+USER node  # Switch to non-root user
+CMD ["npm", "start"]
+```
+
+**Why:** Security. Root exploits can escape container.
+
+}}}
+
+### Clean Up After Yourself {{{
+
+**Remove unused containers:**
+```bash
+docker container prune
+```
+
+**Remove unused images:**
+```bash
+docker image prune -a
+```
+
+**Remove unused volumes:**
+```bash
+docker volume prune
+```
+
+**Nuclear option (remove everything):**
+```bash
+docker system prune -a --volumes
+```
+
+}}}
+
+### Use Health Checks {{{
+
+**In Dockerfile:**
+```dockerfile
+FROM node:20
+WORKDIR /app
+COPY . .
+EXPOSE 3000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+  CMD curl -f http://localhost:3000/health || exit 1
+
+CMD ["npm", "start"]
+```
+
+**In docker-compose.yml:**
+```yaml
+services:
+  api:
+    build: .
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 3s
+      retries: 3
+      start_period: 5s
+```
+
+**Why:** Container might run but app is broken. Health checks detect this.
+
+}}}
+
+}}}
+
+## 📚 Quick Reference {{{
+
+### Essential Docker Commands {{{
+
+```bash
+# Images
+docker images                  # List images
+docker pull image:tag          # Download image
+docker build -t name:tag .     # Build image from Dockerfile
+docker rmi image-id            # Remove image
+
+# Containers
+docker ps                      # List running containers
+docker ps -a                   # List all containers
+docker run -d image            # Run container in background
+docker run -it image bash      # Run interactively
+docker exec -it container bash # Execute command in running container
+docker logs container          # View logs
+docker stop container          # Stop container
+docker start container         # Start stopped container
+docker rm container            # Remove container
+docker rm -f container         # Force remove running container
+
+# Volumes
+docker volume ls               # List volumes
+docker volume create name      # Create volume
+docker volume rm name          # Remove volume
+docker volume inspect name     # View volume details
+
+# System
+docker system df               # Show disk usage
+docker system prune            # Remove unused data
+docker version                 # Show Docker version
+docker info                    # System-wide info
+
+# Compose
+docker-compose up              # Start services
+docker-compose up -d           # Start in background
+docker-compose down            # Stop and remove services
+docker-compose ps              # List services
+docker-compose logs -f         # Follow logs
+docker-compose build           # Build/rebuild services
+```
+
+}}}
+
+### Common docker run Flags {{{
+
+```bash
+-d                         # Detached (background)
+-it                        # Interactive with TTY
+-p 8080:80                 # Port mapping (host:container)
+-v name:/path              # Named volume mount
+-v $(pwd):/app             # Bind mount (current dir → /app)
+-e KEY=value               # Environment variable
+--name my-container        # Container name
+--rm                       # Auto-remove when stopped
+--network my-net           # Connect to network
+--restart unless-stopped   # Restart policy
+```
+
+}}}
+
+### Dockerfile Instructions {{{
+
+```dockerfile
+FROM image:tag             # Base image
+WORKDIR /app               # Set working directory
+COPY source dest           # Copy files
+ADD source dest            # Copy + extract archives
+RUN command                # Execute command during build
+CMD ["cmd", "arg"]         # Default command when container starts
+ENTRYPOINT ["cmd"]         # Main command (CMD becomes args)
+EXPOSE 3000                # Document port (doesn't publish)
+ENV KEY=value              # Environment variable
+USER username              # Switch user
+VOLUME /data               # Define volume mount point
+HEALTHCHECK CMD curl...    # Health check command
+```
+
+}}}
+
+### docker-compose.yml Structure {{{
+
+```yaml
+version: '3.8'
+
+services:
+  service-name:
+    build: ./path              # Build from Dockerfile
+    image: image:tag           # Use existing image
+    ports:
+      - "8080:80"              # Port mapping
+    volumes:
+      - vol-name:/path         # Named volume
+      - ./local:/container     # Bind mount
+    environment:
+      KEY: value               # Environment variables
+    depends_on:
+      - other-service          # Start order
+    networks:
+      - my-network             # Custom network
+    restart: unless-stopped    # Restart policy
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost"]
+      interval: 30s
+
+volumes:
+  vol-name:
+
+networks:
+  my-network:
+```
+
+}}}
+
+}}}
+
+## 🐛 Troubleshooting {{{
+
+### Container Exits Immediately {{{
+
+**Check logs:**
+```bash
+docker logs container-name
+```
+
+**Common causes:**
+- Application crashed
+- Missing environment variables
+- Port already in use
+
+**Debug interactively:**
+```bash
+# Override CMD to keep container alive
+docker run -it image-name sh
+```
+
+}}}
+
+### Can't Connect to Container {{{
+
+**Check port mapping:**
+```bash
+docker ps
+# Look at PORTS column: 0.0.0.0:8080->80/tcp
+```
+
+**Check if app is listening on 0.0.0.0:**
+```bash
+# ❌ Bad: app listens on localhost
+app.listen(3000, 'localhost')
+
+# ✅ Good: app listens on all interfaces
+app.listen(3000, '0.0.0.0')
+```
+
+**Verify with curl:**
+```bash
+# From host
+curl http://localhost:8080
+
+# Inside container
+docker exec -it container-name curl http://localhost:80
+```
+
+}}}
+
+### Volume Data Not Persisting {{{
+
+**Check volume is mounted:**
+```bash
+docker inspect container-name | grep Mounts -A 10
+```
+
+**Verify volume exists:**
+```bash
+docker volume ls
+docker volume inspect volume-name
+```
+
+**Common mistake:**
+```bash
+# ❌ No volume specified - data dies with container
+docker run -d postgres
+
+# ✅ Volume specified - data persists
+docker run -d -v pg-data:/var/lib/postgresql/data postgres
+```
+
+}}}
+
+### Out of Disk Space {{{
+
+**Check Docker disk usage:**
+```bash
+docker system df
+
+# TYPE            TOTAL   ACTIVE   SIZE      RECLAIMABLE
+# Images          15      5        4.2GB     2.1GB (50%)
+# Containers      20      3        100MB     80MB (80%)
+# Volumes         10      3        1.5GB     800MB (53%)
+```
+
+**Clean up:**
+```bash
+# Remove stopped containers
+docker container prune
+
+# Remove unused images
+docker image prune -a
+
+# Remove unused volumes
+docker volume prune
+
+# Everything
+docker system prune -a --volumes
+```
+
+}}}
+
+### Build Fails with "No Space Left" {{{
+
+**Check build cache:**
+```bash
+docker builder prune
+```
+
+**Free up Docker disk:**
+```bash
+# macOS: Docker Desktop → Settings → Resources → Disk Image Size
+# Linux: Clean up /var/lib/docker/
+```
+
+}}}
+
+### Container Can't Resolve DNS {{{
+
+**Test DNS inside container:**
+```bash
+docker exec -it container-name ping google.com
+```
+
+**Fix: Specify DNS servers:**
+```bash
+docker run -d --dns 8.8.8.8 --dns 8.8.4.4 image-name
+```
+
+**In docker-compose.yml:**
+```yaml
+services:
+  app:
+    image: myapp
+    dns:
+      - 8.8.8.8
+      - 8.8.4.4
+```
+
+}}}
+
+}}}
+
+## 🎓 Advanced Topics {{{
+
+### Networking Modes {{{
+
+**Bridge (default):**
+```bash
+# Containers can talk to each other by name
+docker network create my-network
+docker run -d --network my-network --name api backend-image
+docker run -d --network my-network frontend-image
+# Frontend can reach backend at http://api:5000
+```
+
+**Host (share host network):**
+```bash
+docker run -d --network host nginx
+# Container uses host's network directly
+# No port mapping needed
+# Less isolation
+```
+
+**None (no networking):**
+```bash
+docker run -d --network none my-image
+# Completely isolated
+```
+
+}}}
+
+### Docker Secrets (Production) {{{
+
+**For Swarm/Kubernetes:**
+```bash
+# Create secret
+echo "mysecretpassword" | docker secret create db-password -
+
+# Use in service
+docker service create \
+  --name db \
+  --secret db-password \
+  postgres
+```
+
+**Alternative for dev:**
+```bash
+# Use environment file
+docker run -d --env-file .env my-app
+```
+
+}}}
+
+### Multi-Architecture Builds {{{
+
+**Build for ARM and x86:**
+```bash
+# Setup buildx
+docker buildx create --use
+
+# Build for multiple platforms
+docker buildx build \
+  --platform linux/amd64,linux/arm64 \
+  -t myapp:latest \
+  --push \
+  .
+```
+
+**Why:** Deploy same image to AWS (x86) and Raspberry Pi (ARM).
+
+}}}
+
+}}}
+
+## 💡 Pro Tips {{{
+
+1. **Use Alpine images for smaller sizes:**
+   ```dockerfile
+   FROM node:20-alpine  # ~100MB instead of ~900MB
+   ```
+
+2. **Layer caching optimization:**
+   ```dockerfile
+   # Copy package.json first (changes less often)
+   COPY package*.json .
+   RUN npm install
+   # Then copy code (changes frequently)
+   COPY . .
+   ```
+
+3. **Combine RUN commands to reduce layers:**
+   ```dockerfile
+   # ❌ Creates 3 layers
+   RUN apt update
+   RUN apt install -y curl
+   RUN apt clean
+
+   # ✅ Creates 1 layer
+   RUN apt update && \
+       apt install -y curl && \
+       apt clean
+   ```
+
+4. **Use docker-compose override files:**
+   ```bash
+   # docker-compose.yml - base config
+   # docker-compose.override.yml - local dev overrides
+   # docker-compose.prod.yml - production overrides
+
+   # Dev (auto-applies override)
+   docker-compose up
+
+   # Production
+   docker-compose -f docker-compose.yml -f docker-compose.prod.yml up
+   ```
+
+5. **Shell into Alpine containers:**
+   ```bash
+   # Alpine uses 'sh' not 'bash'
+   docker exec -it container-name sh
+   ```
+
+6. **Copy files out of container:**
+   ```bash
+   docker cp container-name:/app/logs/error.log ./local-path/
+   ```
+
+7. **Monitor resource usage:**
+   ```bash
+   docker stats  # Live CPU/Memory/Network usage
+   ```
+
+8. **Save and load images:**
+   ```bash
+   # Save image to tar
+   docker save my-app:latest > my-app.tar
+
+   # Load on another machine
+   docker load < my-app.tar
+   ```
+
+}}}
+
+## 🚀 Next Steps {{{
+
+**Master these progressively:**
+
+1. ✅ **Level 1:** Run pre-built containers (`docker run`)
+2. ✅ **Level 2:** Build simple images (`Dockerfile`)
+3. ✅ **Level 3:** Manage data with volumes
+4. 🎯 **Level 4:** Multi-container apps (`docker-compose`)
+5. 🎯 **Level 5:** Optimize images (multi-stage builds, Alpine)
+6. 🎯 **Level 6:** Production deployments (CI/CD, orchestration)
+
+**Related skills:**
+- **Docker Compose** - Multi-container orchestration
+- **Kubernetes** - Production container orchestration
+- **CI/CD Pipelines** - Automated Docker builds and deployments
+- **Container Security** - Scanning, secrets management
+- **Docker Swarm** - Native Docker clustering
+
+**Resources:**
+- Docker Hub: https://hub.docker.com (explore official images)
+- Docker Docs: https://docs.docker.com
+- Play with Docker: https://labs.play-with-docker.com (browser-based playground)
+
+}}}
+
+---
+
+**Remember:** Docker isn't scary - it's just a way to package your app with everything it needs. Start simple, experiment often, and soon "it works on my machine" becomes "it works everywhere!" 🐳