Introduction

Managing Flask project environments can be challenging, especially when working across different development, staging, and production setups. Docker simplifies this by providing consistent, isolated, and reproducible environments for your Flask applications.

In this guide, we will cover:

✅ Dockerizing a Flask project
✅ Managing dependencies and environment variables
✅ Running Flask in development and production with Docker
✅ Optimizing images for performance and security

Why Use Docker for Flask?

Docker provides several benefits for Flask applications:

  • Consistency: Eliminates “works on my machine” issues
  • Isolation: Ensures independent environments for different stages
  • Scalability: Easily deploy and scale applications
  • Efficiency: Faster setup, testing, and deployment

Setting Up Docker for Flask

Install Docker

First, install Docker by following the official documentation.

Verify the installation:

docker --version

Create a Flask Project

Let’s start with a simple Flask application.

mkdir flask-docker && cd flask-docker

Create app.py:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def home():
return "Hello, Dockerized Flask!"

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

Writing the Dockerfile

A Dockerfile defines how the Flask application is built and run.

Create a Dockerfile in the project root:

# Use a lightweight Python image
FROM python:3.9-slim

# Set the working directory
WORKDIR /app

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

# Copy project files
COPY . .

# Expose the application port
EXPOSE 5000

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

Create requirements.txt

flask

Building and Running the Docker Container

Build the Docker image:

docker build -t flask-app .

Run the container:

docker run -p 5000:5000 flask-app

Now, visit http://localhost:5000 in your browser! 🎉

Using Docker Compose for Multi-Container Setup

For more complex applications, use Docker Compose to manage multiple services like Flask, PostgreSQL, and Redis.

Create docker-compose.yml

version: '3.8'

services:
web:
build: .
ports:
- "5000:5000"
volumes:
- .:/app
environment:
- FLASK_ENV=development

redis:
image: "redis:alpine"

Run the application:

docker-compose up -d

Managing Environment Variables

Instead of hardcoding values, use a .env file:

Create .env:

FLASK_ENV=development
SECRET_KEY=mysecretkey

Modify docker-compose.yml to load .env:

environment:
- FLASK_ENV=${FLASK_ENV}
- SECRET_KEY=${SECRET_KEY}

Optimizing Flask Docker Images

Use a Production WSGI Server

For production, use Gunicorn instead of Flask’s built-in server.

Update requirements.txt:

gunicorn

Modify Dockerfile:

CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:5000", "app:app"]

Reduce Image Size

Use multi-stage builds to keep images lightweight:

# Build stage
FROM python:3.9-slim AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Final image
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 . .
EXPOSE 5000
CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:5000", "app:app"]

Conclusion

By Dockerizing Flask applications, you gain:

✅ Consistent environments across development and production
✅ Scalable multi-container setups with Docker Compose
✅ Efficient deployments using optimized images

With these best practices, you can build scalable, portable, and production-ready Flask applications! 🚀