Docker containerization in Flask - Performance & Optimization

Performance: Docker containerization

MEDIUM IMPACT

Docker containerization affects application startup time, resource usage, and deployment speed, impacting how quickly a Flask app becomes responsive.

Packaging a Flask app for deployment

Flask

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

Uses a smaller base image and installs dependencies before copying app code to leverage Docker cache and reduce image size.

📈 Performance GainReduces image size by 300MB+, container starts 2-3 seconds faster

Packaging a Flask app for deployment

Flask

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

This uses a large base image and copies all files including unnecessary ones, increasing image size and startup time.

📉 Performance CostAdds 500MB+ to image size, blocks container start for 5+ seconds

Performance Comparison

Pattern	Image Size	Startup Time	Resource Usage	Verdict
Large base image with full copy	500MB+	5+ seconds	High CPU and memory	[X] Bad
Slim base image with layered caching	200MB	2 seconds	Optimized CPU and memory	[OK] Good

Rendering Pipeline

Docker containerization impacts the server-side environment setup before the Flask app can respond to requests, affecting the time until the first byte is sent.

→Container Build

→Container Start

→App Initialization

⚠️ BottleneckContainer Start time due to image size and dependency installation

Core Web Vital Affected

LCP

Docker containerization affects application startup time, resource usage, and deployment speed, impacting how quickly a Flask app becomes responsive.

Optimization Tips

1Use minimal base images like python:3.12-slim to reduce image size.

2Install dependencies before copying app code to leverage Docker cache.

3Avoid copying unnecessary files to keep the image lean and startup fast.

Performance Quiz - 3 Questions

What is a key factor that affects Docker container startup time for a Flask app?

A The number of Flask routes

B The size of the Docker image

C The color scheme of the app UI

D The version of Python used

DevTools: Docker CLI and Docker Desktop

How to check: Use 'docker images' to check image size and 'docker stats' to monitor container resource usage during startup.

What to look for: Look for smaller image sizes and lower CPU/memory spikes during container start to confirm better performance.

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