Deploy Python Apps with Docker Compose

Deploying Python Apps with Docker Compose: A Practical Guide

Docker Compose changed how I deploy Python apps. Before using it, I'd spend hours setting up dependencies, wrestling with environment variables, and praying nothing broke when moving from my laptop to a server. If that sounds familiar, you're in the right place.

What exactly is Docker Compose? Think of it as a recipe book for containers. Instead of running multiple Docker commands to start your database, Redis cache, and Python app separately, you write a single YAML file that defines everything. One command, and your entire stack fires up together.

Let me walk you through a real example. Imagine you're building a Flask app with PostgreSQL and Redis for caching. Here's how you'd do it the old way: start PostgreSQL manually, configure Redis, run your Flask app, and hope the ports don't clash. With Docker Compose, you write this:

version: '3.8'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - db
      - redis
  db:
    image: postgres:13
    environment:
      POSTGRES_USER: pythonskillset_user
      POSTGRES_PASSWORD: secret123
  redis:
    image: redis:alpine

Now run docker-compose up and watch everything start in perfect order. Your web service waits for db and redis to be ready. No manual checks, no timing issues.

The real magic is in the details. Let's say your Python app needs environment variables for database URLs and API keys. Add an env_file directive:

services:
  web:
    env_file:
      - .env

Store your secrets in a .env file (never commit it to GitHub!) and Docker Compose injects them automatically. Your app reads os.getenv('DATABASE_URL') and works seamlessly.

What about scaling? Suppose your web service needs to handle more traffic. Run docker-compose up --scale web=3 and you get three instances of your Python app running behind the same ports. Docker Compose handles load balancing across them. For a tech blog like PythonSkillset, this means you can handle traffic spikes without rewriting your deployment scripts.

Persistent data is another gotcha. Without volumes, containers lose all data when they restart. Here's the fix:

services:
  db:
    volumes:
      - postgres_data:/var/lib/postgresql/data
volumes:
  postgres_data:

Now your database survives container restarts and updates. I learned this the hard way when my local dev database disappeared after a system update.

One trick I wish I knew earlier: Use docker-compose config to validate your YAML file before running anything. It catches syntax errors and shows exactly what Docker Compose will do. Saved me countless headaches.

Common mistakes to avoid: - Hardcoding IP addresses. Use service names instead (like db or redis) and let Docker Compose handle DNS resolution. - Forgetting to rebuild after code changes. Run docker-compose build then docker-compose up to include your latest code. - Ignoring resource limits. Add mem_limit: 512m and cpus: '0.5' to prevent a runaway container from eating your server's memory.

For production deployment, consider adding restart policies:

services:
  web:
    restart: unless-stopped

This keeps your app running even if it crashes, which is crucial for PythonSkillset articles that expect reliable uptime.

Docker Compose isn't just for beginners—senior developers at companies like Spotify and Uber use it daily. It turns complex, multi-service Python apps into single-file deployments that anyone on your team can understand and reproduce.

Start with a simple two-service app (your Python script plus a database), then gradually add Redis, Nginx, or Celery workers. Each service just needs a few lines in your YAML file. Before you know it, you'll wonder how you ever deployed without it.