Hello Coders!
This article explains how to start with FastAPI and later, properly Dockerize a FastAPI project. For newcomers, FastAPI is a modern, high-performance, web framework for building APIs with Python.
It's designed to be easy to use, and efficient, and to provide automatic generation of interactive documentation. FastAPI is built on top of Starlette and Pydantic, and it leverages Python 3.6+ type hints for request and response validation. Thanks for reading!
✅ Installation
You can install FastAPI using pip:
pip install fastapi
You'll also want to install a web server like uvicorn to serve your FastAPI application:
pip install uvicorn
✅ Creating a FastAPI App
Here's a basic example of a FastAPI application:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def read_root():
return {"message": "Hello, World"}
Save this code to a Python file (e.g., main.py).
✅ Running the FastAPI App
You can run your FastAPI app using uvicorn:
uvicorn main:app --reload
This command tells uvicorn to run the app instance in the main.py file and enables auto-reloading for development.
✅ Routes and Path Parameters
FastAPI makes it easy to define routes and path parameters. Here's an example that includes path parameters:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def read_root():
return {"message": "Hello, World"}
@app.get("/items/{item_id}")
async def read_item(item_id: int, query_param: str = None):
return {"item_id": item_id, "query_param": query_param}
In this example, we define a route /items/{item_id} that takes an item_id as a path parameter and an optional query_param as a query parameter.
✅ Request and Response Models
FastAPI allows you to define request and response models using Pydantic models. Here's an example:
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Item(BaseModel):
name: str
description: str = None
price: float
tax: float = None
@app.post("/items/")
async def create_item(item: Item):
return item
In this example, we define a Pydantic model Item for the request body of the POST request to /items/.
FastAPI automatically validates and parses the incoming JSON data based on this model.
✅ Automatic Documentation
One of FastAPI's standout features is its automatic generation of interactive API documentation.
To access the documentation, go to http://localhost:8000/docs in your web browser while your FastAPI app is running.
✅ Validation and Serialization
FastAPI automatically validates incoming requests and serializes responses based on the Pydantic models you define. If data doesn't match the expected model, FastAPI will return validation errors.
Dockerizing a FastAPI project involves creating a Docker image that contains your FastAPI application and its dependencies.
Here's a step-by-step guide on how to dockerize a FastAPI project:
✅ Create a Dockerfile
In your FastAPI project directory, create a file named Dockerfile (without any file extension) with the following content:
# Use a base Python image
FROM python:3.x
# Set environment variables
ENV PYTHONUNBUFFERED 1
ENV PYTHONDONTWRITEBYTECODE 1
# Set the working directory inside the container
WORKDIR /app
# Copy the requirements file into the container
COPY requirements.txt /app/
# Install project dependencies
RUN pip install -r requirements.txt
# Copy the rest of the application code into the container
COPY . /app/
# Expose the port your FastAPI app will run on
EXPOSE 8000
# Command to run your FastAPI app with uvicorn
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
Make sure to replace 3.x with the Python version you are using. This Dockerfile sets up a basic environment for running a FastAPI application.
✅ Create a .dockerignore File
In the same directory as your Dockerfile, create a .dockerignore file to specify files and directories that should be excluded when copying files into the Docker image. For example:
__pycache__
*.pyc
*.pyo
*.pyd
*.db
*.sqlite3
This helps keep unnecessary files out of the Docker image.
✅ Build the Docker Image
Open a terminal and navigate to your project directory containing the Dockerfile. Run the following command to build the Docker image:
docker build -t my-fastapi-app .
Replace my-fastapi-app with a name you choose for your Docker image. The . at the end specifies the build context (current directory).
✅ Run the Docker Container
Once the image is built, you can run a Docker container from it:
docker run -d -p 8000:8000 my-fastapi-app
This command maps port 8000 inside the container to port 8000 on your host system. Adjust the port mapping as needed.
✅ Access Your FastAPI App
Your FastAPI app should now be running inside a Docker container. You can access it by visiting http://localhost:8000 in your web browser or making API requests to that address.
✅ In Summary
These are just some of the basics of FastAPI. It provides many more features for building robust and efficient APIs, including dependency injection, authentication, and more.
FastAPI's official documentation is excellent and provides in-depth information on all of its features - FastAPI Official Documentation.
✅ Resources
- 👉 Access AppSeed and start fast your next project
- 👉 Deploy Projects on Aws, Azure and Digital Ocean via DeployPRO
- 👉 Create an amazing landing page with Simpllo, an open-source site builder
- 👉 Django App Generator - A 2nd generation App Builder
Top comments (0)