How to Build High-Performance API Services with FastAPI

FastAPI is a modern, fast (high-performance) web framework designed for building APIs. It is based on Python type hints and supports asynchronous programming, allowing developers to build high-performance, highly available, low-latency API services. This article will provide you with a detailed guide on how to use FastAPI to build high-performance API services, with step-by-step explanations to help you achieve the entire process from environment setup to deployment.

Step 1: Environment Preparation

You need to ensure that Python 3.6+ is installed in your development environment. If you haven't installed it yet, you can visit the Python official website to download and install it.

Install FastAPI and Uvicorn

FastAPI itself does not provide a service and requires an ASGI server to host it. Here we use Uvicorn, a high-performance ASGI server. You can install FastAPI and Uvicorn using the following command:

pip install fastapi uvicorn

Step 2: Build Basic API

Let's create a simple FastAPI application.

Create Application File

In your project directory, create a Python file, such as main.py, and write the following code in it:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"message": "Hello, World!"}

In the above code, we first import FastAPI and create an app instance. Then, we define a GET route that returns a simple JSON response when accessing the root path /.

Start the Server

Start your FastAPI server with the following command:

uvicorn main:app --reload

main: refers to the filename without the .py extension.
app: refers to the FastAPI instance.
--reload: in development mode, automatically restarts the server when files are changed.

Step 3: Define Routes and Data Models

To build complex APIs, you need to use Pydantic to define data models.

Create Data Model

Add the following content to main.py:

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    is_available: bool = True

This code uses Pydantic to create a data model Item, which includes three attributes: item name, price, and availability.

Add New Route

Next, we can define a new POST route to receive data of type Item:

@app.post("/items/")
async def create_item(item: Item):
    return {"item_name": item.name, "item_price": item.price}

In this route, FastAPI will automatically validate the incoming data and map it to the Item model.

Step 4: Automatic Documentation Generation

One of the greatest advantages of FastAPI is its ability to automatically generate API documentation. You can view it by accessing the following addresses:

Swagger UI: http://127.0.0.1:8000/docs
ReDoc: http://127.0.0.1:8000/redoc

In these generated documents, you can interactively test the API and see the request and response formats for each route.

Step 5: Add Authentication

In practical applications, authentication is an important aspect. Let's add a simple role-based authentication.

Add Security Dependencies

Use FastAPI's Depends method and OAuth2PasswordBearer to implement authentication:

from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

async def fake_decode_token(token):
    return {"sub": token}

async def get_current_user(token: str = Depends(oauth2_scheme)):
    user = fake_decode_token(token)
    if user is None:
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid authentication credentials")
    return user

Protect Routes

Then, you can add authentication to the routes that need protection:

@app.get("/users/me")
async def read_users_me(current_user: dict = Depends(get_current_user)):
    return current_user

Step 6: Deploy FastAPI Application

Once you have completed development, you may need to deploy the application to a cloud server. You can choose to deploy using Docker.

Create Dockerfile

Create a file named Dockerfile in your project directory and enter the following content:

FROM tiangolo/uvicorn-gunicorn-fastapi:python3.8

COPY ./app /app

Build Docker Image

In your terminal, use the following command to build the Docker image:

docker build -t myfastapiapp .

Run Docker Container

Run your FastAPI application:

docker run -d --name fastapi -p 80:80 myfastapiapp

Conclusion

In this article, we detailed how to use FastAPI to build high-performance API services, from environment preparation to creating basic APIs, defining routes and data models, adding authentication, and the complete deployment process. FastAPI provides many powerful features that make building modern APIs simple and efficient. You can further explore more features and capabilities through the official documentation. We hope this article helps you get started with FastAPI quickly and effectively improves your project development efficiency!