-
- Joined
- Mar 22, 2026
-
- Messages
- 320
-
- Reaction score
- 0
-
- Points
- 0
Docker Compose is an essential tool for defining and running multi-container Docker applications. Instead of managing individual Docker containers, networks, and volumes manually, Compose allows you to define your entire application stack in a single YAML file, then spin it up or tear it down with a single command. This drastically simplifies local development environments, making them consistent and reproducible across different machines and team members.
Why Docker Compose?
Imagine a typical web application: a web server (like Nginx or Apache), an application backend (Node.js, Python, Java), and a database (PostgreSQL, MySQL, MongoDB). Without Compose, you'd be running multiple
Docker Compose solves this by:
Core Component:
The heart of Docker Compose is the
A basic structure looks like this:
Let's break down the key sections:
*
*
*
*
*
*
*
*
*
Common Docker Compose Commands
Once you have your
Example: Python Flask App with PostgreSQL
Let's put it all together.
To run this example:
1. Save the files (
2. Open your terminal in that directory.
3. Run
4. Open your browser to
5. When you're done,
Docker Compose drastically simplifies complex application setups, making local development a much smoother experience. It's a fundamental tool for any developer working with multi-service architectures.
Why Docker Compose?
Imagine a typical web application: a web server (like Nginx or Apache), an application backend (Node.js, Python, Java), and a database (PostgreSQL, MySQL, MongoDB). Without Compose, you'd be running multiple
docker run commands, manually creating networks, and linking containers. This quickly becomes cumbersome and error-prone.Docker Compose solves this by:
- Defining Services: Each component of your application (backend, database, frontend) is defined as a "service."
- Orchestration: Compose handles the creation, linking, and startup order of these services.
- Consistency: Ensures everyone on the team uses the exact same development environment.
- Isolation: Each service runs in its own isolated container.
Core Component:
docker-compose.ymlThe heart of Docker Compose is the
docker-compose.yml file. This YAML file describes your services, networks, and volumes.A basic structure looks like this:
YAML:
version: '3.8' # Specify Compose file format version
services:
web:
build: . # Build from Dockerfile in current directory
ports:
- "8000:8000"
volumes:
- .:/app # Mount current directory into container for live changes
depends_on:
- db
environment:
DATABASE_URL: postgres://user:password@db:5432/mydatabase
db:
image: postgres:13
environment:
POSTGRES_DB: mydatabase
POSTGRES_USER: user
POSTGRES_PASSWORD: password
volumes:
- db_data:/var/lib/postgresql/data # Persist database data
volumes:
db_data: # Define a named volumeLet's break down the key sections:
version: Specifies the Compose file format version. Using3.8or newer is recommended for modern features.services: This is where you define each component of your application.
web: Our application service.*
build: .: Tells Compose to build a Docker image from the Dockerfile located in the current directory (.).*
ports: - "8000:8000": Maps port 8000 on your host machine to port 8000 inside the web container.*
volumes: - .:/app: A bind mount. This mounts your local project directory into the /app directory inside the container. Changes made to your local code will instantly reflect in the container, which is crucial for development.*
depends_on: - db: Ensures the db service starts before the web service. Note: This only waits for the container to start, not for the service inside to be fully ready. For production, consider health checks.*
environment: Sets environment variables inside the container. This is perfect for database connection strings, API keys, etc.*
db: Our database service.*
image: postgres:13: Pulls the official PostgreSQL 13 image from Docker Hub.*
environment: Sets database credentials.*
volumes: - db_data:/var/lib/postgresql/data: Uses a named volume (db_data) to persist the database's data. If you stop and restart containers, your data will still be there.volumes: Defines named volumes that can be shared and reused across services, ensuring data persistence.
Common Docker Compose Commands
Once you have your
docker-compose.yml file, managing your application stack is simple:docker-compose up: Builds, creates, starts, and attaches to containers for all services. If you add the-dflag (docker-compose up -d), it will run them in detached mode (in the background).docker-compose down: Stops and removes containers, networks, and volumes defined in thedocker-compose.ymlfile. If you want to remove anonymous volumes (like those used for database persistence by default), usedocker-compose down -v.docker-compose ps: Lists all services currently running for your project.docker-compose logs [service_name]: Displays log output from services. You can specify a service name (e.g.,docker-compose logs web) or omit it to see logs from all services. Use-ffor follow mode.docker-compose exec [service_name] [command]: Executes a command inside a running service container. For example,docker-compose exec web bashopens a bash shell in yourwebservice container.docker-compose build [service_name]: Builds or re-builds services. Useful if you've changed aDockerfileand need to update the image.
Example: Python Flask App with PostgreSQL
Let's put it all together.
Dockerfile (for the Flask app in the same directory):
Code:
# Dockerfile
FROM python:3.9-slim-buster
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python", "app.py"]requirements.txt:
Code:
Flask
psycopg2-binaryapp.py:
Python:
# app.py
import os
from flask import Flask
import psycopg2
app = Flask(__name__)
@app.route('/')
def hello():
try:
conn = psycopg2.connect(os.environ.get('DATABASE_URL'))
cur = conn.cursor()
cur.execute("SELECT version();")
db_version = cur.fetchone()[0]
cur.close()
conn.close()
return f"Hello from Flask! Connected to PostgreSQL: {db_version}"
except Exception as e:
return f"Error connecting to DB: {e}"
if __name__ == '__main__':
app.run(host='0.0.0.0', port=8000)docker-compose.yml (as shown above):
YAML:
version: '3.8'
services:
web:
build: .
ports:
- "8000:8000"
volumes:
- .:/app
depends_on:
- db
environment:
DATABASE_URL: postgres://user:password@db:5432/mydatabase # 'db' is the service name, which acts as a hostname
db:
image: postgres:13
environment:
POSTGRES_DB: mydatabase
POSTGRES_USER: user
POSTGRES_PASSWORD: password
volumes:
- db_data:/var/lib/postgresql/data
volumes:
db_data:To run this example:
1. Save the files (
Dockerfile, requirements.txt, app.py, docker-compose.yml) in the same directory.2. Open your terminal in that directory.
3. Run
docker-compose up.4. Open your browser to
http://localhost:8000. You should see the Flask app connecting to PostgreSQL.5. When you're done,
Ctrl+C in the terminal to stop, then docker-compose down to clean up.Docker Compose drastically simplifies complex application setups, making local development a much smoother experience. It's a fundamental tool for any developer working with multi-service architectures.