Boost FastAPI Performance: 9 Proven Techniques with Code Samples

FastAPI is known for its high performance and ease of use, but there is still room for optimization. This article explores various techniques to improve FastAPI application performance and provides practical code examples.

1. Use Asynchronous Endpoints

FastAPI's support for asynchronous programming is one of its main advantages. Using async endpoints can handle more requests concurrently.

Example: Synchronous vs Asynchronous

Synchronous endpoint:

<code>from fastapi import FastAPI

app = FastAPI()

@app.get("/sync")
def sync_endpoint():
    import time
    time.sleep(1)
    return {"message": "This is a synchronous endpoint"}
</code>

Asynchronous endpoint:

<code>from fastapi import FastAPI
import asyncio

app = FastAPI()

@app.get("/async")
async def async_endpoint():
    await asyncio.sleep(1)
    return {"message": "This is an asynchronous endpoint"}
</code>

2. Use Database Connection Pool

Connection pools efficiently manage multiple database connections. For SQLAlchemy, configure a pool as follows:

Example: Database Connection Pool

<code>from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "postgresql://user:password@localhost/dbname"

engine = create_engine(
    DATABASE_URL,
    pool_size=20,
    max_overflow=0
)

SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
</code>

3. Implement Caching

Caching frequently accessed data can significantly reduce database load and speed up responses. Redis is a common choice.

Example: Using Redis Cache

<code>pip install aioredis
</code>

<code>import aioredis
from fastapi import FastAPI, Depends

app = FastAPI()
redis = aioredis.from_url("redis://localhost")

async def get_redis():
    return redis

@app.get("/cached")
async def get_cached_data(redis=Depends(get_redis)):
    cached_value = await redis.get("my_key")
    if cached_value:
        return {"value": cached_value}
    data = "some expensive operation result"
    await redis.set("my_key", data)
    return {"value": data}
</code>

4. Optimize Query Performance

Ensure database queries are optimized, use indexes, and write efficient SQL. With ORMs like SQLAlchemy, avoid N+1 queries by using eager loading.

Example: SQLAlchemy Eager Loading

<code>from sqlalchemy.orm import joinedload

@app.get("/users/{user_id}")
async def get_user(user_id: int, db: Session = Depends(get_db)):
    user = db.query(User).options(joinedload(User.items)).filter(User.id == user_id).first()
    return user
</code>

5. Use Gzip Middleware

Gzip compression reduces response size, decreasing network transfer and improving performance.

Example: Enable Gzip

<code>from fastapi.middleware.gzip import GZipMiddleware

app = FastAPI()
app.add_middleware(GZipMiddleware, minimum_size=1000)
</code>

6. Use FastAPI Background Tasks

For long‑running operations, FastAPI background tasks prevent blocking the main thread.

Example: Background Task

<code>from fastapi import BackgroundTasks, FastAPI

app = FastAPI()

def write_log(message: str):
    with open("log.txt", "a") as log_file:
        log_file.write(message + "\n")

@app.post("/log")
async def log_message(message: str, background_tasks: BackgroundTasks):
    background_tasks.add_task(write_log, message)
    return {"message": "Message will be logged in the background"}
</code>

7. Profile and Monitor the Application

Use profiling tools to identify bottlenecks and monitor performance in real time.

Example: Using py-spy for Profiling

<code>pip install py-spy
</code>

<code>py-spy top --pid <your-app-pid>
</code>

8. Use a Content Delivery Network (CDN)

Serving static files via a CDN reduces latency and speeds up loading.

Example: Configure CDN for Static Files

<code>from fastapi.staticfiles import StaticFiles

app = FastAPI()
app.mount("/static", StaticFiles(directory="static"), name="static")
</code>

9. Optimize Data Serialization

FastAPI uses Pydantic for validation and serialization, which is fast, but using ujson can make it even quicker.

Example: Using ujson

<code>pip install ujson
</code>

<code>from fastapi import FastAPI
import ujson

app = FastAPI(default_response_class=UJSONResponse)

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

Conclusion

Optimizing a FastAPI application can significantly boost performance. By implementing asynchronous endpoints, connection pools, caching, query optimization, Gzip compression, background tasks, proper monitoring, CDN static file serving, and faster JSON serialization, you can ensure your FastAPI service runs efficiently under high load.