Docker for Beginners: A Hands-On Tutorial to Master Containers from Scratch

✅ Chapter 4: Docker Compose and Multi-Container Applications

🔍 Introduction

As you’ve learned from previous chapters, Docker is a powerful tool for building and running isolated containers. But what happens when your application grows beyond a single container?

Real-world applications often rely on multiple services—for example, a web frontend, backend API, database, and caching layer. Managing these components manually with docker run becomes messy and error-prone.

That’s where Docker Compose steps in. It simplifies the definition, orchestration, and management of multi-container Docker applications.

🧱 What is Docker Compose?

Docker Compose is a tool that allows you to define and run multi-container Docker applications using a YAML file called docker-compose.yml.

With just one command, docker-compose up, you can:

• Spin up multiple containers
• Define networks and volumes
• Handle dependencies
• Set environment variables
• Restart policies and more

🗂️ Key Benefits of Docker Compose

• Simplified orchestration for microservices
• Cleaner project structure
• Environment reproducibility
• Easy local development and testing
• Declarative configuration in one file

🧾 Basic Docker Compose File Structure

A docker-compose.yml file follows this format:

yaml

version: '3.8'

services:

  service_name:

    image: <image>

    ports:

      - "host:container"

    volumes:

      - ./host_path:/container_path

    environment:

      - VAR=value

🧪 Example 1: Running Nginx with Docker Compose

Create a simple docker-compose.yml:

yaml

version: '3.8'

services:

  web:

    image: nginx:latest

    ports:

      - "8080:80"

Run it:

bash

docker-compose up

Stop it:

bash

docker-compose down

Visit http://localhost:8080 to see Nginx running.

🧰 Useful Docker Compose Commands

🧪 Example 2: Flask + Redis App

Let’s build a simple Python app that stores visit counts using Redis.

📁 Project Structure

flask-redis/

├── app.py

├── requirements.txt

└── docker-compose.yml

🐍 app.py

python

from flask import Flask

import redis

app = Flask(__name__)

r = redis.Redis(host='redis', port=6379)

@app.route('/')

def hello():

    count = r.incr('hits')

    return f'Hello! This page has been viewed {count} times.'

if __name__ == '__main__':

    app.run(host='0.0.0.0', port=5000)

📦 requirements.txt

nginx

flask

redis

🧱 Dockerfile

Dockerfile

FROM python:3.10

WORKDIR /app

COPY requirements.txt .

RUN pip install -r requirements.txt

COPY . .

CMD ["python", "app.py"]

🧾 docker-compose.yml

yaml

version: '3.8'

services:

  web:

    build: .

    ports:

      - "5000:5000"

    depends_on:

      - redis

  redis:

    image: redis:alpine

🚀 Running the App

1. Build and run the containers:

bash

docker-compose up --build

2. Visit http://localhost:5000

You’ll see visit count increasing with each refresh.

🔧 depends_on Explained

depends_on ensures that Redis starts before Flask, but it doesn’t wait for Redis to be "ready". For readiness, use health checks or entrypoint scripts.

🔗 Networking in Docker Compose

All services in the same Compose file automatically share a private bridge network.

• You can refer to services by name (e.g., redis)
• No need to expose ports internally unless you need host access

🧩 Volumes in Docker Compose

You can define persistent volumes directly in Compose.

yaml

version: '3.8'

services:

  db:

    image: mysql

    volumes:

      - db_data:/var/lib/mysql

    environment:

      MYSQL_ROOT_PASSWORD: password

volumes:

  db_data:

📊 Docker Compose vs docker run

📦 Using .env Files with Compose

Create a .env file in the same directory:

ini

MYSQL_ROOT_PASSWORD=supersecret

Reference it in docker-compose.yml:

yaml

environment:

  - MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}

Keeps sensitive or environment-specific values separate from your Compose config.

🧪 Example 3: WordPress + MySQL with Compose

yaml

version: '3.8'

services:

  wordpress:

    image: wordpress

    ports:

      - "8080:80"

    environment:

      - WORDPRESS_DB_HOST=mysql

      - WORDPRESS_DB_USER=root

      - WORDPRESS_DB_PASSWORD=root

    depends_on:

      - mysql

  mysql:

    image: mysql:5.7

    environment:

      - MYSQL_ROOT_PASSWORD=root

    volumes:

      - mysql_data:/var/lib/mysql

volumes:

  mysql_data:

Visit http://localhost:8080 to install WordPress.

🔁 Restart Policies in Compose

Ensure services restart on failure:

yaml

restart: unless-stopped

🛠 Debugging Compose Issues

🚀 Scaling with Docker Compose

You can scale a service horizontally using:

bash

docker-compose up --scale web=3

Note: You’ll need a load balancer (like Nginx or HAProxy) for proper request distribution.

🔐 Security Best Practices

• Never store secrets directly in docker-compose.yml
• Use .env files or secret managers (Vault, AWS Secrets Manager)
• Set proper restart policies
• Avoid using latest tag in production (use fixed versions)

✅ Summary of Chapter 4

You’ve now learned:

• What Docker Compose is and why it’s important
• How to write and use docker-compose.yml
• How to manage multi-container apps
• How services share networks and volumes
• Real-world examples using Flask + Redis, WordPress + MySQL
• How to use .env files, health checks, scaling, and restart policies

With Compose, your development and deployment become cleaner, scalable, and easier to manage.