Docker containerization in Flask - Step-by-Step Execution

Concept Flow - Docker containerization

Write Flask app code

↓

Create Dockerfile

↓

Build Docker image

↓

Run Docker container

↓

App runs inside container

↓

Access app via browser or curl

This flow shows how you write a Flask app, create a Dockerfile, build an image, run a container, and access the app.

Execution Sample

Flask

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

This Dockerfile sets up a Python 3.12 environment, installs dependencies, copies app files, and runs the Flask app.

Execution Table

Step	Action	Details	Result
1	Write Flask app	Create app.py with Flask code	Flask app code ready
2	Create Dockerfile	Define base image and commands	Dockerfile ready
3	Build image	Run 'docker build -t flask-app .'	Docker image 'flask-app' created
4	Run container	Run 'docker run -p 5000:5000 flask-app'	Container runs Flask app on port 5000
5	Access app	Open http://localhost:5000 in browser	Flask app page loads
6	Stop container	Ctrl+C or 'docker stop <container_id>'	Container stops
7	Exit	No more commands	Process ends

💡 Process ends after container stops and no further commands run

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	Final
Flask app code	None	app.py created	app.py present	app.py in image	app.py running in container	app.py serving requests	app.py stopped
Dockerfile	None	None	Dockerfile created	Dockerfile used in image	Dockerfile not needed now	Dockerfile not needed	Dockerfile not needed
Docker image	None	None	None	Image 'flask-app' built	Image running as container	Image running	Image remains
Docker container	None	None	None	None	Container running	Container running	Container stopped

Key Moments - 3 Insights

Why do we need a Dockerfile after writing the Flask app?

The Dockerfile tells Docker how to build the image with the app and its environment. Without it, Docker doesn't know what to include or how to run the app. See execution_table step 2.

What happens when we run 'docker build'?

Docker reads the Dockerfile and creates an image with all files and dependencies. This image is like a snapshot of the app environment. See execution_table step 3.

Why do we map ports when running the container?

Mapping ports (like 5000:5000) connects the container's internal port to the host machine, so you can access the Flask app from your browser. See execution_table step 4.

Visual Quiz - 3 Questions

Look at the execution table, what is the result after step 3?

A Docker container stopped

B Flask app code running

C Docker image 'flask-app' created

D Dockerfile deleted

💡 Hint

Check the 'Result' column for step 3 in the execution_table

At which step does the Flask app start running inside the container?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look for when the container runs the Flask app in the execution_table

If you forget to map ports when running the container, what changes in the execution?

A The container will not start

B You cannot access the app from the browser

C The Docker image will not build

D The Flask app code will be missing

💡 Hint

Think about the port mapping explained in key_moments and execution_table step 4

Concept Snapshot

Docker containerization with Flask:
1. Write Flask app code (app.py).
2. Create Dockerfile to define environment.
3. Build Docker image with 'docker build'.
4. Run container with port mapping 'docker run -p'.
5. Access app via localhost port.
6. Container isolates app and dependencies.

Full Transcript

Docker containerization for a Flask app involves writing the app code, creating a Dockerfile to specify the environment, building a Docker image from that Dockerfile, and running a container from the image. The container runs the Flask app isolated from the host system. Port mapping allows access to the app from a browser. The process stops when the container is stopped.

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