12.2.3 Python Docker Workflow

The Python Docker workflow centers on installing dependencies from a requirements file (or equivalent modern tooling) with proper layer caching, choosing an appropriately minimal base image, and deciding whether a virtual environment is genuinely necessary within the already-isolated context of a container.

A Typical Python Dockerfile Structure

Dependencies are installed in their own cached layer, separate from the application's source code.

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python", "main.py"]

Copying only requirements.txt before running the install step allows this layer to be cached separately from the broader application source.

Why python:3.12-slim Is a Common, Reasonable Base Choice

The slim variant provides a smaller image than the full python image while still including enough of a standard Linux environment to avoid the additional friction Alpine-based images sometimes introduce for Python specifically.

FROM python:3.12-slim

FROM python:3.12-alpine

The Alpine variant is smaller still, but its different underlying C library (musl rather than glibc) can occasionally cause compatibility issues with certain Python packages that include compiled extensions, making slim a more broadly compatible default choice.

Avoiding Unnecessary Cached Pip Files

The --no-cache-dir flag prevents pip from retaining its own download cache within the image layer, since this cache provides no benefit in a container that won't be reused for future installs the way a developer's own machine might be.

pip install --no-cache-dir -r requirements.txt

Running as a Non-Root User

Creating and switching to a dedicated user follows the same non-root execution practice relevant across other language ecosystems.

RUN useradd -m appuser
USER appuser

Why the Python Docker Workflow Matters

These established conventions — proper dependency layer caching, a sensibly chosen base image, avoiding unnecessary cache retention — together produce efficient, broadly compatible Python container images appropriate to this ecosystem's specific tooling and common pitfalls.