Bài 32: Docker Compose for Django

Docker Compose Introduction

Docker Compose quản lý multi-container applications.

Why Docker Compose?

Without Compose:docker run postgres ...docker run redis ...docker run django ...# Must manage each container separately# Complex networking and environment setup With Compose:docker-compose up# All containers start together# Automatic networking# Easy configuration

Install Docker Compose

# Docker Desktop includes Composedocker-compose --version # Linux: Install separatelysudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-composesudo chmod +x /usr/local/bin/docker-compose # Verifydocker-compose --version

docker-compose.yml Structure

Basic Structure

# docker-compose.ymlversion: '3.8' services:  web:    build: .    ports:      - "8000:8000"    volumes:      - .:/app    environment:      - DEBUG=True   db:    image: postgres:15    environment:      - POSTGRES_DB=mydb      - POSTGRES_USER=postgres      - POSTGRES_PASSWORD=postgres

YAML Syntax Basics

# Key-value pairskey: value # Listsitems:  - item1  - item2 # Nested structuresparent:  child1: value1  child2: value2 # Multi-line stringsdescription: |  This is a  multi-line string# Environment variablesenvironment:  - KEY=value  # or  KEY: value

Django + PostgreSQL Setup

Complete docker-compose.yml

# docker-compose.ymlversion: '3.8' services:  db:    image: postgres:15    container_name: myproject_db    volumes:      - postgres_data:/var/lib/postgresql/data    environment:      POSTGRES_DB: myproject_db      POSTGRES_USER: postgres      POSTGRES_PASSWORD: postgres123    ports:      - "5432:5432"    healthcheck:      test: ["CMD-SHELL", "pg_isready -U postgres"]      interval: 10s      timeout: 5s      retries: 5   web:    build: .    container_name: myproject_web    command: python manage.py runserver 0.0.0.0:8000    volumes:      - .:/app    ports:      - "8000:8000"    environment:      DEBUG: "True"      DATABASE_URL: postgresql://postgres:postgres123@db:5432/myproject_db      SECRET_KEY: dev-secret-key-change-in-production    depends_on:      db:        condition: service_healthy volumes:  postgres_data:

Django Settings for Docker

# settings.pyfrom decouple import configimport dj_database_url # Database from environmentDATABASES = {    'default': dj_database_url.config(        default='postgresql://postgres:postgres123@db:5432/myproject_db',        conn_max_age=600    )} # Or manual configurationDATABASES = {    'default': {        'ENGINE': 'django.db.backends.postgresql',        'NAME': config('DB_NAME', default='myproject_db'),        'USER': config('DB_USER', default='postgres'),        'PASSWORD': config('DB_PASSWORD', default='postgres123'),        'HOST': config('DB_HOST', default='db'),  # Service name from docker-compose        'PORT': config('DB_PORT', default='5432'),    }}

Dockerfile for Compose

# DockerfileFROM python:3.11-slim ENV PYTHONDONTWRITEBYTECODE=1ENV PYTHONUNBUFFERED=1 # Install system dependenciesRUN apt-get update && apt-get install -y \    postgresql-client \    && rm -rf /var/lib/apt/lists/* WORKDIR /app COPY requirements.txt /app/RUN pip install --upgrade pip && pip install -r requirements.txt COPY . /app/ EXPOSE 8000

Environment Variables

.env File

# .env (not committed to git!)DEBUG=TrueSECRET_KEY=your-secret-key-hereDB_NAME=myproject_dbDB_USER=postgresDB_PASSWORD=postgres123DB_HOST=dbDB_PORT=5432ALLOWED_HOSTS=localhost,127.0.0.1

docker-compose.yml with .env

version: '3.8' services:  db:    image: postgres:15    environment:      POSTGRES_DB: ${DB_NAME}      POSTGRES_USER: ${DB_USER}      POSTGRES_PASSWORD: ${DB_PASSWORD}    volumes:      - postgres_data:/var/lib/postgresql/data   web:    build: .    command: python manage.py runserver 0.0.0.0:8000    volumes:      - .:/app    ports:      - "8000:8000"    env_file:      - .env    depends_on:      - db volumes:  postgres_data:

.env.example

# .env.example (commit this to git)DEBUG=TrueSECRET_KEY=change-me-in-productionDB_NAME=myproject_dbDB_USER=postgresDB_PASSWORD=postgres123DB_HOST=dbDB_PORT=5432ALLOWED_HOSTS=localhost,127.0.0.1

Service Orchestration

depends_on

version: '3.8' services:  db:    image: postgres:15    # ... db config   redis:    image: redis:7-alpine    # ... redis config   web:    build: .    depends_on:      db:        condition: service_healthy  # Wait for db health check      redis:        condition: service_started  # Wait for redis to start   celery:    build: .    command: celery -A myproject worker -l info    depends_on:      - redis      - db

Health Checks

services:  db:    image: postgres:15    healthcheck:      test: ["CMD-SHELL", "pg_isready -U postgres"]      interval: 10s      timeout: 5s      retries: 5      start_period: 10s   redis:    image: redis:7-alpine    healthcheck:      test: ["CMD", "redis-cli", "ping"]      interval: 5s      timeout: 3s      retries: 5   web:    build: .    healthcheck:      test: ["CMD-SHELL", "curl -f http://localhost:8000/health/ || exit 1"]      interval: 30s      timeout: 10s      retries: 3      start_period: 40s

Networks in Compose

Default Network

# docker-compose.ymlversion: '3.8' services:  db:    image: postgres:15    # Automatically on default network   web:    build: .    # Can access db using hostname "db"

Custom Networks

version: '3.8' services:  db:    image: postgres:15    networks:      - backend   web:    build: .    networks:      - frontend      - backend   nginx:    image: nginx:alpine    networks:      - frontend networks:  frontend:    driver: bridge  backend:    driver: bridge

Network Aliases

services:  db:    image: postgres:15    networks:      backend:        aliases:          - database          - postgres-db   web:    build: .    networks:      - backend    # Can access db using: db, database, or postgres-db

Volumes for Persistence

Named Volumes

version: '3.8' services:  db:    image: postgres:15    volumes:      - postgres_data:/var/lib/postgresql/data      - postgres_backups:/backups   web:    build: .    volumes:      - static_volume:/app/staticfiles      - media_volume:/app/media volumes:  postgres_data:    driver: local  postgres_backups:    driver: local  static_volume:  media_volume:

Bind Mounts

services:  web:    build: .    volumes:      # Code for development (hot reload)      - .:/app            # Specific directories      - ./myproject:/app/myproject      - ./templates:/app/templates      - ./static:/app/static            # Read-only mount      - ./config:/app/config:ro            # Don't override node_modules (if using)      - /app/node_modules

Volume Management

# List volumesdocker volume ls # Inspect volumedocker volume inspect myproject_postgres_data # Remove volumedocker volume rm myproject_postgres_data # Remove all unused volumesdocker volume prune

Development vs Production Configs

Development Config

# docker-compose.dev.ymlversion: '3.8' services:  db:    image: postgres:15    volumes:      - postgres_data:/var/lib/postgresql/data    environment:      POSTGRES_DB: myproject_dev      POSTGRES_USER: postgres      POSTGRES_PASSWORD: postgres    ports:      - "5432:5432"  # Expose for local access   web:    build:      context: .      dockerfile: Dockerfile.dev    command: python manage.py runserver 0.0.0.0:8000    volumes:      - .:/app  # Code changes reflect immediately    ports:      - "8000:8000"    environment:      DEBUG: "True"      DATABASE_URL: postgresql://postgres:postgres@db:5432/myproject_dev    depends_on:      - db volumes:  postgres_data:

Production Config

# docker-compose.prod.ymlversion: '3.8' services:  db:    image: postgres:15    volumes:      - postgres_data:/var/lib/postgresql/data    environment:      POSTGRES_DB: ${DB_NAME}      POSTGRES_USER: ${DB_USER}      POSTGRES_PASSWORD: ${DB_PASSWORD}    restart: always    # Don't expose port in production   web:    build:      context: .      dockerfile: Dockerfile.prod    command: gunicorn myproject.wsgi:application --bind 0.0.0.0:8000    volumes:      - static_volume:/app/staticfiles      - media_volume:/app/media    env_file:      - .env.prod    depends_on:      - db    restart: always   nginx:    image: nginx:alpine    ports:      - "80:80"      - "443:443"    volumes:      - ./nginx/nginx.conf:/etc/nginx/nginx.conf      - static_volume:/app/staticfiles      - media_volume:/app/media    depends_on:      - web    restart: always volumes:  postgres_data:  static_volume:  media_volume:

docker-compose Commands

Basic Commands

# Start all servicesdocker-compose up # Start in background (detached mode)docker-compose up -d # Start specific servicedocker-compose up web # Build images before startingdocker-compose up --build # Force recreate containersdocker-compose up --force-recreate # Stop all servicesdocker-compose down # Stop and remove volumesdocker-compose down -v # Stop and remove imagesdocker-compose down --rmi all

Service Management

# Start servicesdocker-compose start # Stop services (keep containers)docker-compose stop # Restart servicesdocker-compose restart # Restart specific servicedocker-compose restart web # Pause servicesdocker-compose pause # Unpause servicesdocker-compose unpause

Viewing Information

# View running servicesdocker-compose ps # View all services (including stopped)docker-compose ps -a # View logsdocker-compose logs # Follow logsdocker-compose logs -f # Logs for specific servicedocker-compose logs web # Last 100 linesdocker-compose logs --tail=100 # View service configurationdocker-compose config

Executing Commands

# Execute command in running containerdocker-compose exec web python manage.py migrate # Execute with different userdocker-compose exec -u root web bash # Run one-time command (creates new container)docker-compose run web python manage.py createsuperuser # Run without dependenciesdocker-compose run --no-deps web python manage.py shell # Remove container after rundocker-compose run --rm web python manage.py test

Scaling Services

# Scale web service to 3 instancesdocker-compose up -d --scale web=3 # Scale multiple servicesdocker-compose up -d --scale web=3 --scale celery=2

Database Initialization

Wait for Database

# entrypoint.sh#!/bin/bash echo "Waiting for postgres..." while ! nc -z db 5432; do  sleep 0.1done echo "PostgreSQL started" # Run migrationspython manage.py migrate # Start serverexec "$@"

# DockerfileFROM python:3.11-slim # Install netcat for database checkRUN apt-get update && apt-get install -y netcat-traditional WORKDIR /app COPY requirements.txt /app/RUN pip install -r requirements.txt COPY . /app/ # Make entrypoint executableRUN chmod +x /app/entrypoint.sh ENTRYPOINT ["/app/entrypoint.sh"]CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

# docker-compose.ymlservices:  web:    build: .    entrypoint: /app/entrypoint.sh    command: python manage.py runserver 0.0.0.0:8000

Initialize Database with Data

# docker-compose.ymlservices:  db:    image: postgres:15    volumes:      - postgres_data:/var/lib/postgresql/data      - ./init.sql:/docker-entrypoint-initdb.d/init.sql    # SQL file runs on first container start

-- init.sqlCREATE DATABASE myproject_db;CREATE USER myproject_user WITH PASSWORD 'password';GRANT ALL PRIVILEGES ON DATABASE myproject_db TO myproject_user;

Running Migrations in Containers

Manual Migration

# Run migrationsdocker-compose exec web python manage.py migrate # Make migrationsdocker-compose exec web python manage.py makemigrations # Show migrationsdocker-compose exec web python manage.py showmigrations

Automatic Migration on Startup

# docker-compose.ymlservices:  web:    build: .    command: >      sh -c "python manage.py migrate &&             python manage.py runserver 0.0.0.0:8000"

Migration Service

# docker-compose.ymlservices:  migrate:    build: .    command: python manage.py migrate    depends_on:      db:        condition: service_healthy   web:    build: .    command: python manage.py runserver 0.0.0.0:8000    depends_on:      - migrate

Complete Example

Project Structure

myproject/├── myproject/│   ├── __init__.py│   ├── settings.py│   ├── urls.py│   └── wsgi.py├── blog/├── manage.py├── requirements.txt├── Dockerfile├── docker-compose.yml├── entrypoint.sh├── .env.example├── .dockerignore└── .gitignore

docker-compose.yml

version: '3.8' services:  db:    image: postgres:15    container_name: myproject_db    volumes:      - postgres_data:/var/lib/postgresql/data    environment:      POSTGRES_DB: myproject_db      POSTGRES_USER: postgres      POSTGRES_PASSWORD: postgres123    ports:      - "5432:5432"    healthcheck:      test: ["CMD-SHELL", "pg_isready -U postgres"]      interval: 10s      timeout: 5s      retries: 5   web:    build: .    container_name: myproject_web    command: python manage.py runserver 0.0.0.0:8000    volumes:      - .:/app      - static_volume:/app/staticfiles      - media_volume:/app/media    ports:      - "8000:8000"    env_file:      - .env    depends_on:      db:        condition: service_healthy    restart: unless-stopped volumes:  postgres_data:  static_volume:  media_volume:

Workflow

# 1. Setupcp .env.example .env # 2. Build and startdocker-compose up -d --build # 3. Run migrationsdocker-compose exec web python manage.py migrate # 4. Create superuserdocker-compose exec web python manage.py createsuperuser # 5. Collect static filesdocker-compose exec web python manage.py collectstatic --noinput # 6. View logsdocker-compose logs -f # 7. Access at http://localhost:8000 # 8. Stopdocker-compose down # 9. Clean up (remove volumes)docker-compose down -v

Bài Tập

Bài 1: Basic Docker Compose Setup

Task: Setup Django + PostgreSQL with Docker Compose:

# Requirements:# 1. Create docker-compose.yml with db and web services# 2. Use PostgreSQL 15 for database# 3. Configure Django to use PostgreSQL# 4. Add environment variables# 5. Setup volumes for persistence# 6. Configure depends_on# 7. Start services with docker-compose up# 8. Run migrations# 9. Create superuser# 10. Test connection to database

Bài 2: Multi-Container Application

Task: Django + PostgreSQL + Redis setup:

# Requirements:# 1. Add Redis service to docker-compose.yml# 2. Configure Django to use Redis for cache# 3. Add health checks for all services# 4. Setup custom networks# 5. Configure volumes for all services# 6. Add .env file for environment variables# 7. Test cache with Redis# 8. View logs for all services# 9. Scale web service to 2 instances# 10. Test load balancing

Bài 3: Development and Production Configs

Task: Separate dev and prod configurations:

# Requirements:# 1. Create docker-compose.dev.yml# 2. Create docker-compose.prod.yml# 3. Development: Hot reload, exposed ports, SQLite ok# 4. Production: Gunicorn, nginx, PostgreSQL required# 5. Different Dockerfiles (Dockerfile.dev, Dockerfile.prod)# 6. Environment-specific .env files# 7. Production: No code mounting# 8. Production: Static files with nginx# 9. Test both configurations# 10. Document differences

Bài 4: Complete Production Setup

Task: Production-ready Docker Compose:

# Requirements:# 1. Django + PostgreSQL + Redis + Nginx# 2. Health checks for all services# 3. Restart policies# 4. Volume management# 5. Custom networks (frontend/backend)# 6. Database initialization script# 7. Automatic migrations on startup# 8. SSL/HTTPS with nginx# 9. Log aggregation# 10. Backup script for database# 11. Monitoring (healthchecks)# 12. Documentation# 13. .env.example file# 14. docker-compose up works perfectly# 15. Production-ready security

Tài Liệu Tham Khảo

Previous: Bài 31: Docker Basics | Next: Bài 33: Deploying with Docker

#multi-container

Docker Compose for Django