Docker containerization in Flask

Introduction

Docker containerization helps you package your Flask app with everything it needs to run. This makes it easy to share and run your app anywhere without setup problems.

You want to share your Flask app with others and ensure it runs the same on their computers.

You need to deploy your Flask app to a server or cloud without worrying about missing software.

You want to test your Flask app in a clean environment that matches production.

You want to run multiple Flask apps on the same machine without conflicts.

You want to simplify updating your Flask app by replacing containers.

Syntax

Flask

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

FROM sets the base image with Python installed.

WORKDIR sets the folder inside the container where commands run.

Examples

Basic Dockerfile to run a Flask app named app.py.

Flask

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

Installs Flask directly without a requirements file.

Flask

FROM python:3.12-slim
WORKDIR /app
COPY . .
RUN pip install flask
CMD ["python", "app.py"]

Adds EXPOSE 5000 to tell Docker the app listens on port 5000.

Flask

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt ./
RUN pip install -r requirements.txt
COPY . .
EXPOSE 5000
CMD ["python", "app.py"]

Sample Program

This Dockerfile and Flask app show how to containerize a simple Flask app. The app listens on all network interfaces so Docker can route requests. Port 5000 is exposed for access.

Flask

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt ./
RUN pip install -r requirements.txt
COPY . .
EXPOSE 5000
CMD ["python", "app.py"]

# app.py
from flask import Flask
app = Flask(__name__)

@app.route('/')
def home():
    return "Hello from Flask in Docker!"

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

Important Notes

Always set host='0.0.0.0' in app.run() so the Flask app is reachable outside the container.

Use EXPOSE in the Dockerfile to document which port your app uses.

Keep your dependencies in requirements.txt for easy installation.

Summary

Docker packages your Flask app and its environment into a container.

This makes your app easy to run anywhere without setup issues.

Use a Dockerfile to define how to build and run your Flask app container.

Practice

1. What is the main purpose of using Docker with a Flask application?

easy

A. To package the Flask app and its environment so it runs consistently anywhere

B. To write Flask application code faster

C. To replace Flask's routing system

D. To automatically generate HTML templates

Solution

1. Step 1: Understand Docker's role

   Docker packages an app with all its dependencies into a container.

2. Step 2: Connect Docker to Flask app usage

   This packaging ensures the Flask app runs the same on any machine without setup issues.

3. Final Answer:

   To package the Flask app and its environment so it runs consistently anywhere -> Option A

4. Quick Check:

   Docker packages app + environment = B [OK]

Hint: Docker ensures app runs same everywhere by packaging environment [OK]

Common Mistakes:

• Thinking Docker speeds up coding
• Confusing Docker with Flask features
• Assuming Docker changes app logic

2. Which of the following is the correct first line in a Dockerfile for a Flask app using Python 3.12?

easy

A. EXPOSE 5000

B. RUN python3.12 install flask

C. COPY app.py /app

D. FROM python:3.12-slim

Solution

1. Step 1: Identify Dockerfile base image syntax

   The Dockerfile must start with a FROM statement specifying the base image.

2. Step 2: Choose correct Python version image

   "FROM python:3.12-slim" correctly sets Python 3.12 as base.

3. Final Answer:

   FROM python:3.12-slim -> Option D

4. Quick Check:

   Dockerfile starts with FROM base image = D [OK]

Hint: Dockerfile always starts with FROM base image line [OK]

Common Mistakes:

• Using RUN before FROM
• Copying files before setting base image
• Exposing ports before base image

3. Given this Dockerfile snippet for a Flask app:

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

What happens when you run docker build . and then docker run?

medium

A. The app fails because requirements.txt is not copied

B. The Flask app runs inside a container using Python 3.12 with dependencies installed

C. The container runs but does not start the Flask app

D. The build command installs Flask globally on the host machine

Solution

1. Step 1: Analyze Dockerfile commands

   It sets Python 3.12 base, copies requirements.txt, installs dependencies, copies app files, and runs app.py.

2. Step 2: Understand build and run effects

   docker build creates image with dependencies; docker run starts container running Flask app.

3. Final Answer:

   The Flask app runs inside a container using Python 3.12 with dependencies installed -> Option B

4. Quick Check:

   Build installs deps, run starts app = A [OK]

Hint: COPY then RUN pip install ensures dependencies inside container [OK]

Common Mistakes:

• Thinking dependencies install on host
• Assuming app.py is not copied
• Believing container runs without CMD

4. You wrote this Dockerfile for your Flask app:

FROM python:3.12-slim
COPY app.py /app/
CMD ["python", "app.py"]

When you run the container, the app crashes with "ModuleNotFoundError: flask". What is the problem?

medium

A. Flask is not installed inside the container

B. app.py is not copied to the container

C. CMD syntax is incorrect

D. Python version 3.12-slim does not support Flask

Solution

1. Step 1: Check Dockerfile for dependency installation

   No RUN command installs Flask or dependencies inside container.

2. Step 2: Understand error cause

   ModuleNotFoundError means Flask package missing in container environment.

3. Final Answer:

   Flask is not installed inside the container -> Option A

4. Quick Check:

   Missing Flask install causes ModuleNotFoundError = C [OK]

Hint: Always RUN pip install for dependencies inside Dockerfile [OK]

Common Mistakes:

• Assuming Flask is preinstalled in base image
• Thinking app.py copy is missing
• Believing CMD syntax causes import errors

5. You want to containerize a Flask app that reads environment variables for configuration. Which Dockerfile addition ensures environment variables set at runtime are accessible inside the Flask app?

hard

A. Hardcode variables inside app.py before building image

B. Use ENV in Dockerfile to set variables permanently

C. Pass variables with docker run -e VAR=value and access via os.environ in Flask

D. Add EXPOSE for environment variables

Solution

1. Step 1: Understand environment variable usage

   Flask app reads variables at runtime from OS environment.

2. Step 2: Identify Docker method to pass runtime variables

   Using docker run -e VAR=value passes variables dynamically to container.

3. Final Answer:

   Pass variables with docker run -e VAR=value and access via os.environ in Flask -> Option C

4. Quick Check:

   Runtime env vars via docker run -e = A [OK]

Hint: Use docker run -e to pass env vars dynamically to container [OK]

Common Mistakes:

• Confusing ENV for runtime variable passing
• Hardcoding vars loses flexibility
• Thinking EXPOSE relates to env vars