Dockerize FastAPI Application

Introduction

This documentation provides a step-by-step guide on how to Dockerize a FastAPI application. Docker is a powerful tool that allows you to package your application and its dependencies into a container, ensuring consistent and reproducible deployments across different environments. By following this guide, you'll be able to containerize your FastAPI application, making it more portable and easier to manage.

Tutorial

Step 1: Exisitng code

Begin by moving to project directory for your FastAPI application. Ensure that your FastAPI application is working correctly in this directory before proceeding.

.
├── Pipfile
├── Pipfile.lock
└── main.py

Step 2: Create Dockerfile

A Dockerfile is used to define the configuration for building a Docker image. Create a file named Dockerfile (with no file extension) in your project directory. Here is a sample Dockerfile for a FastAPI application:

# Pull the base docker image of python with tag 3.10.12
FROM python:3.10.12

# Install Pipenv
RUN pip install pipenv

# Change the working dir inside the container - cd /app
WORKDIR /app

# Copy main.py as source cod and req.txt as dependency
COPY main.py ./

COPY Pipfile Pipfile.lock ./
# Install the dependency
RUN pipenv install --system --deploy --ignore-pipfile

### Container Env same as local at this point
EXPOSE 8000

CMD ["gunicorn" ,"-w", "4", "-k", "uvicorn.workers.UvicornWorker" , "--bind", "0.0.0.0:8000", "main:app"]
# gunicorn command to run the service with 4 worker nodes binding localhost/0.0.0.0 on port 8000 refering app inside the main.py

Step 3: Building the Docker Image

To create a Docker image for your FastAPI application, use the docker build command. Navigate to your project directory and run the following command:

docker build -t fastapi_demo:v1 .

Here's a breakdown of the command:

• docker build: This command is used to build a Docker image.

• -t fastapi_demo:v1: The -t flag allows you to specify a name and optionally a tag for your image. In this example, we're naming the image fastapi_demo and giving it the tag v1. You can choose your own image name and tag.

• .: The dot (.) at the end of the command specifies the build context, which is the current directory. This tells Docker to look for the Dockerfile in the current directory and use it to build the image.

The Docker image will be built using the instructions in your Dockerfile. You'll see output in the terminal as each step is executed. If there are any errors during the build process, Docker will report them, and you can address them accordingly

[+] Building 1.0s (12/12) FINISHED                                                                                                                                                              docker:default
 => [internal] load build definition from Dockerfile                                                                                                                                                      0.0s
 => => transferring dockerfile: 701B                                                                                                                                                                      0.0s
 => [internal] load .dockerignore                                                                                                                                                                         0.0s
 => => transferring context: 2B                                                                                                                                                                           0.0s
 => [internal] load metadata for docker.io/library/python:3.10.12                                                                                                                                         0.9s
 => [auth] library/python:pull token for registry-1.docker.io                                                                                                                                             0.0s
 => [1/6] FROM docker.io/library/python:3.10.12@sha256:bac3a0e0d16125977e351c861e2f4b12ecafeaa6f72431dc970d0b9155103232                                                                                   0.0s
 => [internal] load build context                                                                                                                                                                         0.0s
 => => transferring context: 89B                                                                                                                                                                          0.0s
 => CACHED [2/6] RUN pip install pipenv                                                                                                                                                                   0.0s
 => CACHED [3/6] WORKDIR /app                                                                                                                                                                             0.0s
 => CACHED [4/6] COPY main.py ./                                                                                                                                                                          0.0s
 => CACHED [5/6] COPY Pipfile Pipfile.lock ./                                                                                                                                                             0.0s
 => CACHED [6/6] RUN pipenv install --system --deploy --ignore-pipfile                                                                                                                                    0.0s
 => exporting to image                                                                                                                                                                                    0.0s
 => => exporting layers                                                                                                                                                                                   0.0s
 => => writing image sha256:c6965620db94b6c47264e25a8ccdbb069d93c1bace54cc85f0b5392979c2fee3                                                                                                              0.0s
 => => naming to docker.io/library/fastapi_demo:v1                                                                                                                                                        0.0s

What's Next?
  View a summary of image vulnerabilities and recommendations → docker scout quickview

Step 4: Verify the Built Image

Once the build process is complete, you can verify that the image was created successfully by running:

docker images

You should see your newly created image listed with the name and tag you specified (fastapi_demo:v1 in this example).

REPOSITORY                     TAG       IMAGE ID       CREATED        SIZE
fastapi_demo                   v1        c6965620db94   19 hours ago   9.07GB

Step 5: Running the Docker Image

Now that you have built your Docker image, you can run it as a container. To do this, use the docker run command. In your terminal, navigate to the project directory, and execute the following command:

docker run -p 8090:8000 fastapi_demo:v1

Here's what each part of the command does:

• docker run: This command starts a Docker container based on a Docker image.
• -p 8090:8000: The -p flag is used to map ports between the host machine and the container. In this example, it maps port 8090 on your host to port 8000 in the container. You can adjust the host port (left side) as needed.
• fastapi_demo:v1: This specifies the Docker image you want to run. Replace fastapi_demo:v1 with the name and tag of your Docker image.

Step 6: Access Your FastAPI Application

After running the command, your FastAPI application should be up and running inside a Docker container. You can access it by opening a web browser and navigating to: http://localhost:8090/docs

Step 7: Stopping the Container

To stop the Docker container, you can press Ctrl+C in the terminal where it is running, or you can open a new terminal window and run the following command:

docker stop <container_id_or_name>

Replace container_id_or_name with the actual container ID or name, which you can find using the docker ps command.

$ docker ps
CONTAINER ID   IMAGE                          COMMAND                  CREATED         STATUS                 PORTS                                              NAMES
fb83d5eb2bec   fastapi_demo:v1                "gunicorn -w 4 -k uv…"   6 minutes ago   Up 6 minutes           0.0.0.0:8090->8000/tcp                             stoic_dijkstra

docker stop fb83d5eb2bec

Conclusion

In this guide, you've learned how to Dockerize your FastAPI application, creating a Docker image and running it as a container. Dockerization simplifies deployment, enhances scalability, and streamlines the development process by encapsulating your application and its environment. With your FastAPI application now containerized, you have the flexibility to deploy it in various environments with confidence. This marks the beginning of a more efficient and maintainable development and deployment workflow for your FastAPI projects. Feel free to explore further Docker features and optimizations to suit your specific application needs.