Docker Installation and Setup: From Zero to Production-Ready in 30 Minutes

You've been burned before. You push code to production, and it crashes because the server has a different version of Node, or Python, or some obscure C library. The classic 'works on my machine' lie. Docker ends that nonsense. It packages your app with everything it needs — down to the operating system libraries — into a single, runnable unit called a container. Once you have Docker installed, you can run that container anywhere: your laptop, your teammate's Windows machine, a cloud server, even a Raspberry Pi. No surprises. By the end of this guide, you'll have Docker installed, verified, and ready to run your first container. You'll also know how to avoid the three most common setup traps that waste hours.

What Docker Actually Solves (And Why You Should Care)

Before Docker, deploying software was a nightmare. You'd write a setup script, pray the server had the right OS version, and spend hours debugging library conflicts. Docker eliminates that by bundling your app with its entire runtime environment. A container includes the OS, libraries, environment variables, and your code. It runs identically on any machine with Docker. The core concept is an image — a read-only template with instructions for creating a container. You build an image, push it to a registry (like Docker Hub), and pull it on any machine. Containers are lightweight, start in seconds, and isolate processes. They're not virtual machines — they share the host OS kernel, so they use fewer resources. This is why Docker dominates DevOps: it makes deployment predictable and repeatable.

// io.thecodeforge — DevOps tutorial

# Without Docker: manual setup on a fresh Ubuntu server
sudo apt-get update
sudo apt-get install -y nodejs npm
# ... but what if the server uses CentOS? Or has Node 12 instead of 16?
# With Docker: one command to run the same app anywhere
docker run -d -p 3000:3000 node:16-alpine node app.js

Installing Docker on Linux (The Right Way)

Linux is Docker's native home. The Docker Engine runs directly on the Linux kernel. The recommended method is using the official convenience script from Docker. It detects your distribution, adds the correct repository, and installs the latest stable version. Do not use your distro's package manager (apt, yum) unless you want an outdated version. The script handles everything. After installation, you need to start the Docker daemon and enable it to start on boot. Finally, add your user to the 'docker' group to run Docker commands without sudo. This is a security risk in multi-user environments, but for a single developer machine, it's standard practice.

// io.thecodeforge — DevOps tutorial

# Step 1: Download and run the official Docker installation script
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Step 2: Start Docker daemon and enable on boot
sudo systemctl enable docker
sudo systemctl start docker

# Step 3: Add your user to the docker group (log out and back in after)
sudo usermod -aG docker $USER

# Step 4: Verify installation
docker --version
docker run hello-world

Installing Docker on macOS and Windows (Docker Desktop)

Docker Desktop is the easiest way to run Docker on macOS and Windows. It includes Docker Engine, Docker CLI, Docker Compose, and a GUI. On macOS, it uses a lightweight HyperKit VM to run Linux containers. On Windows, it can use Hyper-V or WSL 2. WSL 2 is recommended for better performance. Download the installer from docker.com, drag it to Applications, and launch. Docker Desktop will start the daemon automatically. You'll see the Docker whale icon in your menu bar or system tray. Click it to manage containers. The CLI works the same as on Linux. One gotcha: Docker Desktop on macOS has default memory limits (2GB). For serious work, increase it in Preferences -> Resources -> Advanced.

// io.thecodeforge — DevOps tutorial

# After installing Docker Desktop, open a terminal and verify:
docker --version

# Run the hello-world container to test
docker run hello-world

# Check Docker Desktop resources (macOS):
# Preferences -> Resources -> Advanced -> Memory: set to 4GB or more

# For Windows with WSL 2:
# Ensure WSL 2 is installed: wsl --set-default-version 2
# In Docker Desktop Settings -> Resources -> WSL Integration -> enable integration with your distro

Verifying Your Docker Installation (Don't Skip This)

After installation, you must verify Docker works correctly. Run docker version to check client and server versions. If you get 'Cannot connect to the Docker daemon', the daemon isn't running. On Linux, start it with sudo systemctl start docker. On macOS/Windows, launch Docker Desktop. Next, run docker run hello-world. This pulls a tiny test image from Docker Hub and runs a container that prints a success message. If it works, your installation is complete. If you get permission errors, you forgot to add your user to the docker group. Run sudo usermod -aG docker $USER and log out/in. If you're on a VM or remote server, ensure your user has sudo access.

// io.thecodeforge — DevOps tutorial

# Check Docker client and server versions
docker version

# Run the hello-world test
docker run hello-world

# List running containers (should be empty after hello-world exits)
docker ps

# List all containers (including stopped)
docker ps -a

# Check Docker system info
docker info

Running Your First Real Container (Not Hello World)

Hello World is boring. Let's run something useful: an Nginx web server. Run docker run -d -p 8080:80 nginx:alpine. The -d flag runs it in detached mode (background). -p 8080:80 maps port 8080 on your host to port 80 in the container. nginx:alpine is a lightweight Nginx image. Open http://localhost:8080 in your browser. You should see the Nginx welcome page. To stop the container, run docker stop <container-id>. To remove it, docker rm <container-id>. This is the pattern you'll use for most services: databases, APIs, frontends. Containers are ephemeral — any data written inside is lost when the container is removed. For persistent data, you need volumes (covered in a later article).

// io.thecodeforge — DevOps tutorial

# Pull and run Nginx in detached mode, mapping port 8080 to 80
docker run -d -p 8080:80 --name my-nginx nginx:alpine

# Verify it's running
docker ps

# Stop the container
docker stop my-nginx

# Remove the container
docker rm my-nginx

# Run with a custom index.html (mount a volume)
echo "<h1>Hello from Docker!</h1>" > index.html
docker run -d -p 8080:80 -v $(pwd)/index.html:/usr/share/nginx/html/index.html nginx:alpine

Understanding Docker Images and Layers

Docker images are built in layers. Each instruction in a Dockerfile creates a new layer. Layers are cached. If you change a layer, only that layer and subsequent ones are rebuilt. This makes builds fast. Images are read-only. When you run a container, Docker adds a thin writable layer on top. Any changes inside the container (creating files, installing packages) happen in this writable layer. When the container is deleted, the writable layer is lost. That's why you need volumes for persistent data. Images are identified by a hash (SHA256). Tags (like nginx:alpine) are human-readable aliases. Always use specific tags in production, not latest, because latest changes and can break your deployment.

// io.thecodeforge — DevOps tutorial

# Pull an image and see its layers
docker pull nginx:alpine

# Inspect image layers
docker history nginx:alpine

# Build a custom image with a Dockerfile
cat > Dockerfile << EOF
FROM nginx:alpine
COPY index.html /usr/share/nginx/html/index.html
EOF

docker build -t my-nginx:1.0 .

# See layers of the new image
docker history my-nginx:1.0

Docker Compose: Multi-Container Setup Made Simple

Real applications need multiple services: a web server, a database, a cache. Docker Compose lets you define and run multi-container applications with a single YAML file. You define services, networks, and volumes. One command (docker-compose up) starts everything. This is essential for local development and CI/CD. Compose is included with Docker Desktop. On Linux, you may need to install it separately. The file is usually named docker-compose.yml. Each service specifies an image or build context, ports, environment variables, and dependencies. Compose creates a default network so containers can communicate by service name.

// io.thecodeforge — DevOps tutorial

version: '3.8'
services:
  web:
    image: nginx:alpine
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html
    depends_on:
      - api
  api:
    build: ./api
    ports:
      - "3000:3000"
    environment:
      - DB_HOST=db
      - DB_USER=app
      - DB_PASSWORD=secret
    depends_on:
      - db
  db:
    image: postgres:15-alpine
    volumes:
      - pgdata:/var/lib/postgresql/data
    environment:
      POSTGRES_USER: app
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: myapp
volumes:
  pgdata:

Common Installation Pitfalls and How to Fix Them

The most common error is 'Cannot connect to the Docker daemon'. On Linux, the daemon might not be running or your user isn't in the docker group. Run sudo systemctl status docker to check. If it's inactive, start it. If your user isn't in the docker group, add them and log out/in. On macOS/Windows, Docker Desktop might not be running. Launch it from Applications. Another pitfall: disk space. Docker images and containers consume disk. Run docker system df to see usage. Clean up with docker system prune -a (removes all unused images, containers, and networks). On macOS, Docker Desktop uses a disk image that can grow large. Reset it in Troubleshoot -> Reset to factory defaults. Never run docker system prune in production without understanding what it removes.

// io.thecodeforge — DevOps tutorial

# Check Docker daemon status (Linux)
sudo systemctl status docker

# Start Docker daemon
sudo systemctl start docker

# Check disk usage
docker system df

# Clean up unused resources (careful!)
docker system prune -a --volumes

# Check Docker Desktop logs (macOS)
# ~/Library/Containers/com.docker.docker/Data/log/vm/dockerd.log

# Reset Docker Desktop to factory defaults
# Docker Desktop -> Troubleshoot -> Reset to factory defaults