Why Every Python Developer Should Learn Docker in 2026

#!/usr/bin/env bash
# Try different Python versions without installing them
docker run --rm python:3.11-slim python --version
docker run --rm python:3.12-slim python --version

# Run a script from your current folder inside a container
docker run --rm -v "$PWD":/app -w /app python:3.12-slim python hello.py

# Create pinned requirements from your working virtual environment
#   pip freeze > requirements.txt

# Example requirements.txt
fastapi==0.115.5
uvicorn==0.32.1
SQLAlchemy==2.0.36
psycopg2-binary==2.9.10

# Pinned versions + a pinned base image = reproducible builds.

FROM python:3.12-slim

ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app/ ./app/
RUN useradd --create-home appuser
USER appuser

EXPOSE 8000
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

# .dockerignore
.venv/
__pycache__/
*.pyc
.git/
.env
tests/.pytest_cache/

# app/main.py
from fastapi import FastAPI

app = FastAPI()

@app.get("/health")
def health():
    return {"status": "ok"}

# Build and run:
#   docker build -t myapi:1.0 .
#   docker run --rm -p 8000:8000 myapi:1.0

services:
  api:
    build: .
    ports: ["8000:8000"]
    environment:
      DATABASE_URL: postgresql://app:app@db:5432/app
      REDIS_URL: redis://cache:6379/0
    depends_on: [db, cache]

  db:
    image: postgres:16
    environment:
      POSTGRES_USER: app
      POSTGRES_PASSWORD: app
      POSTGRES_DB: app
    volumes: ["dbdata:/var/lib/postgresql/data"]

  cache:
    image: redis:7

volumes:
  dbdata:

# .github/workflows/docker-ci.yml
name: docker-ci
on: [push, pull_request]
jobs:
  build-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: docker build -t myapi:${{ github.sha }} .
      - run: |
          docker run --rm myapi:${{ github.sha }} \
            python -c "import app.main; print('import ok')"
      # Run your test suite inside the image, for example with a test stage
      # or by installing test requirements in a separate CI image.

[ ] Pinned base image (python:3.x-slim)
[ ] Pinned requirements.txt
[ ] Requirements installed before code is copied
[ ] .dockerignore excludes .venv, .git, .env, caches
[ ] Non-root user
[ ] Config via environment variables
[ ] docker-compose.yml for app + database (+ cache)
[ ] README: docker compose up and how to run tests

## Run with Docker

    docker compose up --build

API: http://localhost:8000/health

## Run tests

    docker compose run --rm api pytest -q

## Configuration
Set DATABASE_URL and REDIS_URL in a local .env file
(not committed). See .env.example.

Day 1  Images, containers, ports, volumes
Day 2  Write a Dockerfile for a small Flask or FastAPI app
Day 3  .dockerignore, non-root user, layer caching
Day 4  Docker Compose with Postgres
Day 5  Add Redis or a worker service
Day 6  Build and test the image in CI
Day 7  Document everything in the README