Python Full Stack Web Developer Course

Real-World Example: Flask Application with Comprehensive Dependency Management

Let's bring everything together with a complete example of a Flask application that demonstrates best practices for dependency management with Docker.

Project Structure

flask_app/
├── .dockerignore           # Files to exclude from Docker build
├── .gitignore              # Files to exclude from Git
├── Dockerfile              # Production Dockerfile
├── Dockerfile.dev          # Development Dockerfile
├── README.md               # Project documentation
├── docker-compose.yml      # Base Docker Compose config
├── docker-compose.override.yml  # Development overrides
├── docker-compose.prod.yml # Production overrides
├── app/                    # Application code
│   ├── __init__.py
│   ├── config.py           # Configuration
│   ├── models.py           # Database models
│   ├── routes.py           # API routes
│   ├── templates/          # Jinja2 templates
│   └── static/             # Static assets
├── migrations/             # Database migrations
├── requirements/
│   ├── base.txt            # Base dependencies
│   ├── development.txt     # Development dependencies
│   └── production.txt      # Production dependencies
├── scripts/
│   ├── entrypoint.sh       # Docker entrypoint script
│   └── start-dev.sh        # Development startup script
└── tests/                  # Application tests

Dependency Files

requirements/base.txt

# Core dependencies
Flask==2.0.1
Flask-SQLAlchemy==2.5.1
Flask-Migrate==3.1.0
SQLAlchemy==1.4.23
psycopg2-binary==2.9.1
gunicorn==20.1.0
python-dotenv==0.19.0
werkzeug==2.0.1
click==8.0.1
itsdangerous==2.0.1
jinja2==3.0.1
markupsafe==2.0.1

requirements/development.txt

# Include base requirements
-r base.txt

# Development packages
pytest==6.2.5
pytest-cov==2.12.1
black==21.8b0
flake8==3.9.2
ipython==7.27.0
debugpy==1.4.1

requirements/production.txt

# Include base requirements
-r base.txt

# Production packages
sentry-sdk==1.3.1
blinker==1.4

Docker Configuration

Dockerfile.dev

FROM python:3.9-slim

# Set environment variables
ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1 \
    FLASK_APP=app \
    FLASK_ENV=development

# Set working directory
WORKDIR /app

# Install system dependencies
RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential \
    libpq-dev \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

# Install Python dependencies
COPY requirements/development.txt .
RUN pip install --no-cache-dir -r development.txt

# Make scripts executable
COPY scripts/entrypoint.sh scripts/start-dev.sh ./
RUN chmod +x entrypoint.sh start-dev.sh

# Set entrypoint
ENTRYPOINT ["./entrypoint.sh"]

# Default command
CMD ["./start-dev.sh"]

Dockerfile (for production)

# Build stage
FROM python:3.9-slim AS builder

# Install build dependencies
RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential \
    libpq-dev \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

# Set working directory
WORKDIR /build

# Copy requirements
COPY requirements/production.txt .
RUN pip wheel --no-cache-dir --no-deps --wheel-dir /build/wheels -r production.txt

# Final stage
FROM python:3.9-slim

# Set environment variables
ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1 \
    FLASK_APP=app \
    FLASK_ENV=production

# Create non-root user
RUN addgroup --system app && adduser --system --group app

# Set working directory
WORKDIR /app

# Install runtime dependencies
RUN apt-get update && apt-get install -y --no-install-recommends \
    libpq5 \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

# Copy wheels and install dependencies
COPY --from=builder /build/wheels /wheels
COPY --from=builder /build/production.txt .
RUN pip install --no-cache-dir --no-index --find-links=/wheels -r production.txt \
    && rm -rf /wheels production.txt

# Copy application code
COPY . .

# Make scripts executable and fix ownership
RUN chmod +x scripts/entrypoint.sh && \
    chown -R app:app /app

# Switch to non-root user
USER app

# Set entrypoint
ENTRYPOINT ["./scripts/entrypoint.sh"]

# Run gunicorn
CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:8000", "--workers", "4"]

Docker Compose Files

docker-compose.yml (base configuration)

version: '3'

services:
  web:
    build: .
    depends_on:
      - db
    restart: unless-stopped
    environment:
      - DATABASE_URL=postgresql://postgres:postgres@db:5432/flask_app
  
  db:
    image: postgres:13
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_DB=flask_app
    restart: unless-stopped

volumes:
  postgres_data:

docker-compose.override.yml (development overrides, applied automatically)

version: '3'

services:
  web:
    build:
      context: .
      dockerfile: Dockerfile.dev
    ports:
      - "8000:8000"
      - "5678:5678"  # For remote debugging
    volumes:
      - .:/app
    environment:
      - FLASK_ENV=development
      - FLASK_DEBUG=1
  
  db:
    ports:
      - "5432:5432"
  
  # Additional development services
  adminer:
    image: adminer:latest
    ports:
      - "8080:8080"
    depends_on:
      - db
    restart: unless-stopped

docker-compose.prod.yml (production overrides)

version: '3'

services:
  web:
    build:
      context: .
      dockerfile: Dockerfile
    expose:
      - "8000"
    environment:
      - FLASK_ENV=production
      - LOG_LEVEL=INFO
    volumes:
      - static_data:/app/app/static
    deploy:
      replicas: 2
      restart_policy:
        condition: any
  
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/conf.d/default.conf
      - static_data:/static
    depends_on:
      - web
  
  db:
    environment:
      - POSTGRES_PASSWORD=${DB_PASSWORD:-postgres}
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./scripts/init-db.sh:/docker-entrypoint-initdb.d/init-db.sh

volumes:
  postgres_data:
  static_data:

Helper Scripts

scripts/entrypoint.sh

#!/bin/bash
set -e

# Wait for database to be ready
if [ "$DATABASE_URL" ]; then
  echo "Waiting for database..."
  
  RETRIES=5
  until psql $DATABASE_URL -c "select 1" > /dev/null 2>&1 || [ $RETRIES -eq 0 ]; do
    echo "Waiting for database to be available... $((RETRIES--)) remaining attempts..."
    sleep 1
  done
fi

# Run database migrations
if [ "$FLASK_ENV" = "production" ]; then
  echo "Running migrations..."
  flask db upgrade
fi

# Execute the command passed to docker run
exec "$@"

scripts/start-dev.sh

#!/bin/bash
set -e

# Run any development setup (e.g., migrations)
echo "Running development setup..."
flask db upgrade

# Start development server with debugger enabled
echo "Starting development server..."
python -m debugpy --listen 0.0.0.0:5678 --wait-for-client -m flask run --host=0.0.0.0 --port=8000

Using the Application

Development workflow:

# Start development environment
docker-compose up -d

# View logs
docker-compose logs -f

# Run tests
docker-compose exec web pytest

# Add a new dependency
# 1. Add to requirements/base.txt or requirements/development.txt
# 2. Rebuild the container
docker-compose build
docker-compose up -d

Production deployment:

# Build and start production environment
docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d

# Scale web service
docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d --scale web=3

This example demonstrates:

• Separate Dockerfiles for development and production
• Multi-stage builds for production to minimize image size
• Organized requirements files by environment
• Docker Compose configurations for different environments
• Helper scripts for common tasks
• Environment-specific configuration
• Database migration handling
• Development aids like debugger support

By following these patterns, you can create a robust, scalable workflow for managing dependencies in your Python applications.