From Linux to Docker: Essential Containerization Skills to Double Ops Efficiency

Why Containerization Matters Now

After covering Linux basics, the author notes that modern deployment no longer relies on manually SSH-ing into individual servers. Instead, the standard is "cloud platform + containerization" because it simplifies management and maximizes server resource utilization.

What Is Containerization? A Concrete Comparison

The author uses a tangible analogy: a 6C16G server running three applications.

Virtual Machine (VM) approach: Requires three full VMs, each carrying a complete OS consuming 1-2 GB RAM just for the system, leaving insufficient resources for apps and forcing additional server purchases.

Container approach: The same 6C16G host runs 10+ containers. Each container packages only "application + necessary dependencies + configuration," sharing the host kernel. A single container starts with just a few MB of memory.

In short: VMs provide OS-level isolation; containers provide process-level isolation. Containers are lighter, start in seconds (vs minutes for VMs), have near-zero performance overhead (shared kernel vs hardware emulation), use MB-to-GB images (vs GB for VMs), and enable rapid migration.

Three Core Values of Containerization

Eliminate SSH hopping: No more memorizing server IPs; a single console controls start, stop, and scale operations for all apps.

Solve "environment mysticism": Code tested in a local container runs identically in a cloud container because dependencies and configuration are baked into the image, eradicating "works locally, crashes in production" issues.

Cost efficiency: Auto-scale containers during traffic peaks and remove them during troughs, achieving true pay-for-what-you-use economics.

Docker: The Container "Housekeeper" — Three Core Concepts

Image: The read-only template (e.g., an Nginx image with a pre-configured environment).

Container: A running instance of an image; one image can spawn multiple isolated containers.

Repository: A registry for storing and sharing images (e.g., Docker Hub), analogous to GitHub for code.

Essential Docker Commands Cheat Sheet

Image Operations

# Pull a specific version (avoid :latest for stability)
docker pull nginx:1.25.3
docker pull mysql:8.0.36

# List local images
# Basic view
docker images
# With digests for tamper-proof verification
docker images --digests

# Remove an image (must delete dependent containers first)
docker rmi nginx:1.25.3
# Force removal (use cautiously)
docker rmi -f nginx:1.25.3

# Tag an image for private registry push
docker tag nginx:1.25.3 my-registry/nginx:v1.0

Container Operations

# Run a container with production-grade flags
docker run -d \
  -p 80:80 \                 # Host port 80 -> container port 80
  --name my-nginx \          # Explicit name (not random)
  --restart=always \         # Auto-start on host reboot
  -v /data/nginx/conf:/etc/nginx/conf.d \  # Mount config directory
  -v /data/nginx/log:/var/log/nginx \      # Mount log directory (critical!)
  -e TZ=Asia/Shanghai \     # Set timezone to avoid log timestamp issues
  --user 1000:1000 \        # Run as non-root user for security
  nginx:1.25.3

# Inspect containers
docker ps          # Running only
docker ps -a       # All (including stopped)
docker ps -q       # Only IDs (useful for scripting)

# Lifecycle control
docker start my-nginx
docker stop my-nginx      # Graceful shutdown
docker kill my-nginx      # Force kill (emergency only)
docker restart my-nginx

# Removal
docker rm my-nginx           # Stopped container
docker rm -f my-nginx        # Running container (caution)
docker rm $(docker ps -aq)   # Purge all (test env only!)

# Enter a container for debugging
docker exec -it my-nginx /bin/bash
docker exec -it my-nginx sh   # For minimal images

Log Inspection — The Troubleshooting Lifeline

# Real-time tail (like tail -f)
docker logs -f my-nginx
# Last 100 lines then follow
docker logs -f --tail 100 my-nginx

# Time-window filtering
docker logs --since="2025-12-07 08:00:00" --until="2025-12-07 09:00:00" my-nginx

# With timestamps
docker logs -t my-nginx

# Grep for errors (case-sensitive)
docker logs -f my-nginx | grep "error"
# Case-insensitive timeout search
docker logs -f my-nginx | grep -i "timeout"

# Export logs to file for offline analysis
docker logs my-nginx > /tmp/nginx_logs_20251207.txt

Advanced Inspection & File Transfer

# Full container metadata (JSON)
docker inspect my-nginx

# Resource usage
docker stats my-nginx            # Live stream
docker stats --no-stream my-nginx  # Single snapshot

# Copy files between host and container
docker cp my-nginx:/var/log/nginx/access.log /tmp/   # Container -> host
docker cp /tmp/my.conf my-nginx:/etc/nginx/conf.d/   # Host -> container

Four Production-Ready Best Practices

Always include three flags at container start: --name (identifiable), -v (persist data/logs), --restart=always (self-healing).

Default log command: docker logs -f --tail 100 -t <container> — shows recent logs with timestamps and follows live.

Mount log directories to the host via -v; otherwise, deleting a container destroys its logs forever.

Never use the latest tag. Pin exact versions (e.g., nginx:1.25.3) to prevent unexpected breaking changes.

What's Next

Mastering these commands handles single-server container management. The next article will cover cloud platforms, their key services, and Kubernetes (K8s) commands for orchestrating containers across multiple servers.