-
- Joined
- Mar 22, 2026
-
- Messages
- 434
-
- Reaction score
- 10
-
- Points
- 0
When developing modern applications, it's rare to find a service that operates in complete isolation. Most applications rely on multiple components: a web server, a database, a cache, a message queue, and so on. While Docker is excellent for containerizing individual services, managing and orchestrating these interconnected containers can quickly become complex. This is where Docker Compose shines.
What is Docker Compose?
Docker Compose is a tool for defining and running multi-container Docker applications. With Compose, you use a YAML file to configure your application's services. Then, with a single command, you create and start all the services from your configuration. It essentially simplifies the process of defining, linking, and scaling multiple containers.
Why Use Docker Compose?
Key Concepts in
The core of Docker Compose is the
1.
2.
*
*
*
*
*
*
*
*
3.
4.
A Practical Example: Web App with Redis Cache
Let's set up a simple Flask web application that uses Redis as a cache to count page hits.
1. Project Structure:
2.
3.
4.
5.
Explanation of
*
*
*
*
* `ports: "637
What is Docker Compose?
Docker Compose is a tool for defining and running multi-container Docker applications. With Compose, you use a YAML file to configure your application's services. Then, with a single command, you create and start all the services from your configuration. It essentially simplifies the process of defining, linking, and scaling multiple containers.
Why Use Docker Compose?
- Simplified Setup: Define your entire application stack in one file, making setup consistent across environments.
- Reproducibility: Ensure everyone on your team has the exact same development environment, minimizing "it works on my machine" issues.
- Isolated Environments: Each project can have its own isolated environment, avoiding port conflicts or dependency issues with other projects on your host.
- Easy Scaling: Scale services up or down with simple commands.
- Development Workflow: Ideal for development, testing, and staging environments due to its ease of use and rapid iteration capabilities.
Key Concepts in
docker-compose.ymlThe core of Docker Compose is the
docker-compose.yml file. Here are its primary sections:1.
version: Specifies the Compose file format version (e.g., 3.8). Newer versions offer more features and syntax.2.
services: Defines the different containers that make up your application. Each service represents a single container that can be scaled independently.*
build or image:*
build: Specifies a path to a directory containing a Dockerfile. Compose will build the image from this Dockerfile.*
image: Specifies a pre-existing image from Docker Hub or a private registry (e.g., nginx:latest, postgres:13).*
ports: Maps ports from the host machine to the container (e.g., "8000:80" maps host port 8000 to container port 80).*
environment: Sets environment variables inside the container, crucial for configuration (e.g., DATABASE_URL).*
volumes: Mounts host paths or named volumes into the container. Useful for persistent data storage or injecting application code changes without rebuilding the image.*
depends_on: Expresses dependency between services. Compose starts services in dependency order (e.g., a web app depends on a database). *Important: depends_on only ensures start order, not readiness*. For true readiness checks, health checks are recommended.*
networks: Attaches services to specific networks. By default, Compose creates a single default network for all services.3.
networks: Defines custom bridge networks for services to communicate over, offering better isolation and organization for complex applications.4.
volumes: Defines named volumes for persistent data storage, which are managed by Docker and are independent of service lifecycle.A Practical Example: Web App with Redis Cache
Let's set up a simple Flask web application that uses Redis as a cache to count page hits.
1. Project Structure:
Code:
my-flask-app/
├── app.py
├── Dockerfile
├── requirements.txt
└── docker-compose.yml2.
app.py (Flask Application):
Python:
from flask import Flask
from redis import Redis
import os
app = Flask(__name__)
# 'redis' is the service name defined in docker-compose.yml,
# Docker Compose handles internal DNS resolution.
redis_host = os.getenv('REDIS_HOST', 'redis')
redis_port = int(os.getenv('REDIS_PORT', 6379))
redis = Redis(host=redis_host, port=redis_port)
@app.route('/')
def hello():
try:
redis.incr('hits')
current_hits = redis.get('hits').decode('utf-8')
return f'Hello World! I have been seen {current_hits} times.\n'
except Exception as e:
return f'Error connecting to Redis: {e}\n'
if __name__ == "__main__":
app.run(host="0.0.0.0", port=5000, debug=True)3.
requirements.txt:
Code:
Flask==2.3.3
redis==5.0.14.
Dockerfile for the Flask app:
Code:
# Use a lightweight Python base image
FROM python:3.9-slim-buster
# Set the working directory in the container
WORKDIR /app
# Copy requirements file and install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Copy the rest of the application code
COPY . .
# Expose the port the Flask app listens on
EXPOSE 5000
# Command to run the Flask application
CMD ["python", "app.py"]5.
docker-compose.yml:
YAML:
version: '3.8'
services:
web:
build: . # Build from Dockerfile in the current directory
ports:
- "5000:5000" # Map host port 5000 to container port 5000
depends_on:
- redis # Ensure redis starts before the web service
environment:
FLASK_ENV: development
REDIS_HOST: redis # Pass the service name as host to Flask app
REDIS_PORT: 6379
# Mount the current directory into the container for live code changes (during development)
volumes:
- .:/app
redis:
image: "redis:alpine" # Use the lightweight Redis image
ports:
- "6379:6379" # Optional: Expose Redis outside for debugging/external access
volumes:
- redis-data:/data # Use a named volume for persistent Redis data
volumes:
redis-data: # Define the named volume for Redis data persistenceExplanation of
docker-compose.yml:webservice:
build: .: Tells Compose to build an image from the Dockerfile in the current directory.*
ports: "5000:5000": Maps host port 5000 to container port 5000, making the web app accessible from your browser.*
depends_on: - redis: Ensures the redis service starts before web.*
environment: Sets FLASK_ENV and tells the Flask app where to find the Redis service.*
volumes: - .:/app: A bind mount that syncs your local code changes directly into the container, removing the need to rebuild the image during development.redisservice:
image: "redis:alpine": Uses the official Redis image from Docker Hub. alpine is a lightweight tag.* `ports: "637