Docker containerization in FastAPI - Step-by-Step Execution

Concept Flow - Docker containerization

Write FastAPI app code

↓

Create Dockerfile

↓

Build Docker image

↓

Run Docker container

↓

App runs inside container

↓

Access app via browser or API client

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

Execution Sample

FastAPI

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt ./
RUN pip install -r requirements.txt
COPY . .
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "80"]

This Dockerfile sets up a FastAPI app environment, installs dependencies, copies code, and runs the app with Uvicorn.

Execution Table

Step	Action	Details	Result
1	Read Dockerfile	Start parsing Dockerfile instructions	Ready to build image
2	FROM python:3.12-slim	Base image with Python 3.12	Base image pulled or cached
3	WORKDIR /app	Set working directory inside container	Working directory set to /app
4	COPY requirements.txt ./	Copy requirements file to /app	requirements.txt available in /app
5	RUN pip install -r requirements.txt	Install Python dependencies	Dependencies installed
6	COPY . .	Copy all app files to /app	App source code copied
7	CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "80"]	Set container start command	Container will run FastAPI app on port 80
8	Build image	Docker builds image with above steps	Image created successfully
9	Run container	Start container from image	FastAPI app running inside container
10	Access app	Open browser or API client to container IP:80	FastAPI app responds to requests
11	Exit	Stop container or close app	Container stops, app no longer running

💡 Container stops or user closes app, ending execution

Variable Tracker

Variable	Start	After Step 4	After Step 6	After Step 9	Final
Working Directory	None	/app	/app	/app	/app
requirements.txt	Not present	Copied	Copied	Copied	Copied
Dependencies Installed	No	No	Yes	Yes	Yes
App Source Code	Not present	Not present	Copied	Copied	Copied
Container State	Not running	Not running	Not running	Running	Stopped

Key Moments - 3 Insights

Why do we set WORKDIR before copying files?

WORKDIR sets the folder where commands run and files copy. See execution_table step 3 and 4 where files copy into /app after setting WORKDIR.

What happens if dependencies are not installed before running the app?

The app will fail to start because required packages are missing. Step 5 installs dependencies before copying app code and running it (steps 6 and 7).

Why do we expose the app on 0.0.0.0 instead of localhost?

0.0.0.0 allows the app to accept connections from outside the container. Step 7 CMD uses this so the app is reachable from the host machine.

Visual Quiz - 3 Questions

Look at the execution_table, what is the working directory after step 4?

A /app

B /

C /root

D Not set yet

💡 Hint

Check the 'Working Directory' variable in variable_tracker after step 4

At which step does the container start running the FastAPI app?

A Step 7

B Step 9

C Step 8

D Step 10

💡 Hint

Look at execution_table rows describing container state and app running

If we skip the RUN pip install step, what will happen when running the container?

A App runs normally

B Container fails to build

C App fails due to missing dependencies

D App runs but with errors logged

💡 Hint

Refer to key_moments about dependency installation importance

Concept Snapshot

Docker containerization with FastAPI:
- Write FastAPI app code
- Create Dockerfile with base image, WORKDIR, copy files
- RUN installs dependencies
- CMD runs app with uvicorn on 0.0.0.0:80
- Build image and run container
- Access app via container IP and port
- Container isolates app environment for easy deployment

Full Transcript

Docker containerization for FastAPI involves writing your app code, then creating a Dockerfile that sets a Python base image, sets the working directory, copies your requirements and app files, installs dependencies, and finally runs the app with Uvicorn. The Docker build process reads these instructions step-by-step, creating an image. Running a container from this image starts the FastAPI app inside an isolated environment. You can then access the app through the container's IP and port. This method ensures your app runs the same everywhere, simplifying deployment and scaling.

Practice

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

easy

A. To package the app and its environment so it runs the same everywhere

B. To write the FastAPI code faster

C. To replace the need for Python in the app

D. To automatically generate API documentation

Solution

1. Step 1: Understand Docker's role

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

2. Step 2: Recognize the benefit for FastAPI

   This container runs the app the same way on any machine, avoiding environment issues.

3. Final Answer:

   To package the app and its environment so it runs the same everywhere -> Option A

4. Quick Check:

   Docker ensures consistent app environment = A [OK]

Hint: Docker ensures your app runs identically on any machine [OK]

Common Mistakes:

• Thinking Docker speeds up coding
• Believing Docker replaces Python
• Confusing Docker with API doc tools

2. Which line correctly sets the base image in a Dockerfile for a FastAPI app using Python 3.12?

easy

A. BASE python:3.12

B. FROM python:3.12-slim

C. IMAGE python:latest

D. START python:3.12

Solution

1. Step 1: Recall Dockerfile syntax for base image

   The correct keyword to set the base image is FROM followed by the image name.

2. Step 2: Match the correct Python version format

   python:3.12-slim is a valid lightweight Python 3.12 image.

3. Final Answer:

   FROM python:3.12-slim -> Option B

4. Quick Check:

   Base image line starts with FROM = A [OK]

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

Common Mistakes:

• Using BASE or IMAGE instead of FROM
• Omitting the version tag
• Using START which is invalid

3. Given this Dockerfile snippet for FastAPI, what will happen when you run the container?

FROM python:3.12-slim
WORKDIR /app
COPY . /app
RUN pip install fastapi uvicorn
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

medium

A. The container will fail because pip install is missing requirements.txt

B. The app will start but only listen on localhost inside the container

C. The FastAPI app will start and listen on port 8000 inside the container

D. The container will build but not run the app automatically

Solution

1. Step 1: Analyze the CMD command

   The CMD runs uvicorn with host 0.0.0.0 and port 8000, which means it listens on all interfaces inside the container.

2. Step 2: Check the RUN command

   pip installs fastapi and uvicorn directly, so dependencies are present for the app to run.

3. Final Answer:

   The FastAPI app will start and listen on port 8000 inside the container -> Option C

4. Quick Check:

   CMD runs uvicorn on 0.0.0.0:8000 = B [OK]

Hint: uvicorn host 0.0.0.0 means listen on all container interfaces [OK]

Common Mistakes:

• Assuming pip install needs requirements.txt always
• Thinking 0.0.0.0 means localhost only
• Believing CMD does not run automatically

4. You wrote this Dockerfile but your FastAPI app does not start inside the container:

FROM python:3.12-slim
WORKDIR /app
COPY . /app
RUN pip install -r requirements.txt
CMD uvicorn main:app --host 0.0.0.0 --port 8000

What is the likely error?

medium

A. CMD should be a JSON array, not a plain string

B. WORKDIR should be set after COPY

C. pip install command is missing fastapi package

D. COPY command should use absolute paths

Solution

1. Step 1: Check CMD syntax

   CMD should be given as a JSON array to avoid shell parsing issues in Dockerfiles.

2. Step 2: Identify the correct CMD format

   Correct CMD is: ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

3. Final Answer:

   CMD should be a JSON array, not a plain string -> Option A

4. Quick Check:

   CMD must be JSON array for correct execution = C [OK]

Hint: Use JSON array for CMD to run commands properly in Docker [OK]

Common Mistakes:

• Writing CMD as a plain string instead of array
• Changing WORKDIR order unnecessarily
• Assuming pip install misses fastapi if requirements.txt exists

5. You want to optimize your FastAPI Docker image to be smaller and faster to build. Which approach is best?

hard

A. Use the latest Python image without specifying a version

B. Install all packages globally on your host machine before building

C. Copy the entire project including unnecessary files into the image

D. Use a multi-stage Dockerfile with a build stage and a slim final stage

Solution

1. Step 1: Understand multi-stage builds

   Multi-stage builds allow building dependencies in one stage and copying only needed files to a smaller final image.

2. Step 2: Recognize benefits for FastAPI Docker images

   This reduces image size and speeds up build by excluding build tools and caches from the final image.

3. Final Answer:

   Use a multi-stage Dockerfile with a build stage and a slim final stage -> Option D

4. Quick Check:

   Multi-stage builds optimize image size and build speed = D [OK]

Hint: Multi-stage Dockerfiles keep images small and fast to build [OK]

Common Mistakes:

• Installing packages on host instead of inside container
• Copying unnecessary files bloats image
• Using latest tag risks unexpected changes