Skip to main content

Python Docker Integration

Introduction​

Docker has revolutionized how we package, deploy, and run applications. For Python developers, Docker solves the age-old "it works on my machine" problem by creating consistent environments across development, testing, and production systems. This tutorial will guide you through integrating Python applications with Docker, enabling you to build portable, isolated, and scalable applications.

Docker creates lightweight, standalone containers that include everything needed to run an application: code, runtime, system tools, libraries, and settings. By containerizing Python applications, you ensure consistent behavior regardless of where they run.

Why Use Docker with Python?​

Before diving into implementation, let's understand why Docker and Python make a powerful combination:

  1. Dependency Management: Package all dependencies in a container, eliminating version conflicts
  2. Environment Consistency: Identical environments across development, staging, and production
  3. Isolation: Each application runs in its own container, preventing conflicts
  4. Scalability: Easily scale applications horizontally
  5. Version Control: Track changes to your environment alongside code
  6. Simplified Deployment: Deploy the same container across different platforms

Prerequisites​

To follow this tutorial, you'll need:

Getting Started with Python and Docker​

Step 1: Create a Simple Python Application​

Let's start with a simple Flask application. Create a directory for your project and add a file named app.py:

python
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return "Hello, Docker!"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Step 2: Create Requirements File​

Create a requirements.txt file listing the dependencies:

flask==2.0.1

Step 3: Create a Dockerfile​

The Dockerfile is a text document that contains all the commands needed to build a Docker image. Create a file named Dockerfile (no extension) with the following content:

dockerfile
# Use official Python image as base
FROM python:3.9-slim

# Set working directory
WORKDIR /app

# Copy requirements and install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy the application code
COPY . .

# Expose port for the application
EXPOSE 5000

# Command to run the application
CMD ["python", "app.py"]

Let's understand each line:

  • FROM python:3.9-slim: Starts with the official Python 3.9 image (slim version to reduce size)
  • WORKDIR /app: Sets the working directory inside the container
  • COPY requirements.txt .: Copies the requirements file to the container
  • RUN pip install...: Installs the Python dependencies
  • COPY . .: Copies all application files to the container
  • EXPOSE 5000: Informs Docker that the container listens on port 5000
  • CMD ["python", "app.py"]: Specifies the command to run when the container starts

Step 4: Build the Docker Image​

Now let's build the Docker image with:

bash
docker build -t python-flask-app .

Output (example):

Sending build context to Docker daemon  4.096kB
Step 1/7 : FROM python:3.9-slim
 ---> 254d4a61b201
Step 2/7 : WORKDIR /app
 ---> Using cache
 ---> a7e62539f1a3
Step 3/7 : COPY requirements.txt .
 ---> Using cache
 ---> 8e5871cb744b
Step 4/7 : RUN pip install --no-cache-dir -r requirements.txt
 ---> Using cache
 ---> f7b7ab30d3e1
Step 5/7 : COPY . .
 ---> 7f7e61b283d5
Step 6/7 : EXPOSE 5000
 ---> Running in 7a3e4bea2648
Removing intermediate container 7a3e4bea2648
 ---> 264fa370ea96
Step 7/7 : CMD ["python", "app.py"]
 ---> Running in 15c0e53cb7c9
Removing intermediate container 15c0e53cb7c9
 ---> 1e6a3027fc1d
Successfully built 1e6a3027fc1d
Successfully tagged python-flask-app:latest

Step 5: Run the Docker Container​

Now run the container with:

bash
docker run -p 5000:5000 python-flask-app

This maps port 5000 of the container to port 5000 on your host machine. You can now access the application at http://localhost:5000 in your web browser.

Output (example):

 * Serving Flask app 'app' (lazy loading)
 * Environment: production
   WARNING: This is a development server. Do not use it in a production deployment.
   Use a production WSGI server instead.
 * Debug mode: off
 * Running on all addresses.
   WARNING: This is a development server. Do not use it in a production deployment.
 * Running on http://172.17.0.2:5000/ (Press CTRL+C to quit)

Best Practices for Python Docker Integration​

Use Alpine-based Images for Smaller Footprint​

If you're concerned about image size, you can use Alpine-based Python images:

dockerfile
FROM python:3.9-alpine

# Install dependencies required for some Python packages
RUN apk add --no-cache gcc musl-dev linux-headers

# Rest of your Dockerfile

Multi-stage Builds for Smaller Images​

For production applications, you can use multi-stage builds to reduce image size:

dockerfile
# Build stage
FROM python:3.9 AS builder

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

# Final stage
FROM python:3.9-slim

WORKDIR /app
COPY --from=builder /usr/local/lib/python3.9/site-packages /usr/local/lib/python3.9/site-packages
COPY . .

CMD ["python", "app.py"]

Use Docker Compose for Multi-container Applications​

For more complex applications with databases or other services, use Docker Compose. Create a file named docker-compose.yml:

yaml
version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - .:/app
    environment:
      - FLASK_ENV=development
  
  db:
    image: postgres:13
    environment:
      - POSTGRES_PASSWORD=secretpassword
      - POSTGRES_USER=pguser
      - POSTGRES_DB=flaskapp
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

Run with:

bash
docker-compose up

Real-world Example: Dockerizing a Data Science Application​

Let's create a more comprehensive example: a Flask API that uses pandas and scikit-learn for predictions.

Project Structure​

data-science-app/
├── app.py
├── model.py
├── requirements.txt
└── Dockerfile

app.py​

python
from flask import Flask, request, jsonify
import pandas as pd
from model import predict_price

app = Flask(__name__)

@app.route('/predict', methods=['POST'])
def predict():
    data = request.get_json()
    features = pd.DataFrame([data])
    prediction = predict_price(features)
    return jsonify({"predicted_price": prediction})

@app.route('/health', methods=['GET'])
def health():
    return jsonify({"status": "healthy"})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

model.py​

python
import pandas as pd
import pickle
import os

# In a real application, you would train and save your model
# For this example, we'll create a simple mock model
def train_model():
    # Mock training
    def simple_model(features):
        # Very simple price prediction based on area and rooms
        return features['area'].iloc[0] * 1000 + features['rooms'].iloc[0] * 20000
    
    return simple_model

def predict_price(features):
    # Load or train model
    model = train_model()
    return float(model(features))

requirements.txt​

flask==2.0.1
pandas==1.3.3
scikit-learn==1.0

Dockerfile​

dockerfile
FROM python:3.9-slim

WORKDIR /app

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

# Copy application
COPY . .

# Expose port
EXPOSE 5000

# Run the application
CMD ["python", "app.py"]

Build and Run​

bash
docker build -t data-science-app .
docker run -p 5000:5000 data-science-app

Testing the API​

You can test the API using curl:

bash
curl -X POST \
  http://localhost:5000/predict \
  -H 'Content-Type: application/json' \
  -d '{"area": 100, "rooms": 3}'

Expected output:

json
{"predicted_price": 160000.0}

Deploying Python Docker Containers​

To a Cloud Provider​

Most cloud providers support Docker deployments:

  1. AWS: Use Elastic Container Service (ECS) or Elastic Kubernetes Service (EKS)
  2. Google Cloud: Use Google Kubernetes Engine (GKE) or Cloud Run
  3. Azure: Use Azure Kubernetes Service (AKS) or Azure Container Instances

Example for deploying to AWS ECS:

  1. Push your image to Amazon ECR:

    bash
    aws ecr create-repository --repository-name python-flask-app
    aws ecr get-login-password | docker login --username AWS --password-stdin <your-account-id>.dkr.ecr.<region>.amazonaws.com
    docker tag python-flask-app <your-account-id>.dkr.ecr.<region>.amazonaws.com/python-flask-app
    docker push <your-account-id>.dkr.ecr.<region>.amazonaws.com/python-flask-app

  2. Create an ECS cluster and task definition (via AWS Console or CLI)

  3. Run the task or create a service

Continuous Integration/Continuous Deployment (CI/CD)​

Integrate Docker builds into your CI/CD pipeline using tools like GitHub Actions:

yaml
name: Build and Deploy

on:
  push:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v2
    
    - name: Build and push Docker image
      uses: docker/build-push-action@v2
      with:
        context: .
        push: true

Tips for Debugging Docker Containers​

  1. Interactive Shell: Access a running container

    bash
    docker exec -it <container_id> /bin/bash

  2. View Logs: Stream container logs

    bash
    docker logs -f <container_id>

  3. Inspect Container: Get detailed information

    bash
    docker inspect <container_id>

Summary​

In this guide, we've explored how to integrate Python applications with Docker:

  1. We started with a simple Flask application and containerized it
  2. We explored best practices for creating efficient Dockerfiles
  3. We built a more complex data science application with Docker
  4. We covered deployment options and debugging techniques

Docker simplifies Python application deployment by standardizing environments and dependencies. This approach reduces the "works on my machine" problem and makes scaling applications easier.

Additional Resources​

Practice Exercises​

  1. Containerize a Python web scraper that saves data to a MongoDB database (hint: use docker-compose)
  2. Create a multi-stage Dockerfile for a Django application to minimize the image size
  3. Build a CI/CD pipeline using GitHub Actions to automatically build and deploy your Python Docker container
  4. Add volume mounts to your Docker setup to persist data outside the container lifecycle
  5. Implement healthchecks in your Dockerfile to ensure your application is running correctly

By mastering Python Docker integration, you'll have added a valuable skill to your DevOps toolkit that simplifies deployment and makes your applications more portable and scalable.


If you spot any mistakes on this website, please let me know at [email protected]. I’d greatly appreciate your feedback! :)