Creating serverless FastAPI applications with AWS Lambda and Mangum is a game-changer for modern web development. I’ve been tinkering with this setup recently, and I’m excited to share what I’ve learned.

Let’s start with the basics. FastAPI is a high-performance web framework for building APIs with Python. It’s fast, easy to use, and comes with automatic API documentation. AWS Lambda, on the other hand, is a serverless compute service that lets you run code without provisioning or managing servers. Mangum acts as the glue between FastAPI and AWS Lambda, allowing your FastAPI app to run seamlessly in a serverless environment.

To get started, you’ll need to set up your development environment. Make sure you have Python 3.7+ installed, along with pip. Then, install the necessary packages:

pip install fastapi mangum aws-lambda-powertools

Now, let’s create a simple FastAPI application. Create a file named main.py:

from fastapi import FastAPI
from mangum import Mangum

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Hello, serverless FastAPI!"}

handler = Mangum(app)

This code creates a basic FastAPI app with a single endpoint that returns a JSON response. The Mangum handler wraps our FastAPI app, making it compatible with AWS Lambda.

Next, we need to package our application for deployment. Create a requirements.txt file listing all the dependencies:

fastapi
mangum
aws-lambda-powertools

Now, let’s set up the AWS Lambda function. In the AWS Console, create a new Lambda function, choose Python 3.9 as the runtime, and set the handler to main.handler. This tells Lambda to use the handler function in our main.py file as the entry point.

To deploy our code, we need to create a deployment package. Zip your main.py and requirements.txt files, then upload the zip to your Lambda function.

But wait, there’s more! To make our serverless FastAPI app accessible via HTTP, we need to set up an API Gateway. Create a new REST API in API Gateway, and integrate it with your Lambda function. Configure a catch-all {proxy+} resource with the ANY method to route all requests to your Lambda function.

Now comes the fun part - testing our serverless FastAPI app! Deploy your API Gateway, and you’ll get a URL. Try accessing it in your browser or with curl. You should see the “Hello, serverless FastAPI!” message.

Let’s make things more interesting by adding some dynamic routes and request handling. Update your main.py:

from fastapi import FastAPI, HTTPException
from mangum import Mangum
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float

@app.get("/")
async def root():
    return {"message": "Hello, serverless FastAPI!"}

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id}

@app.post("/items")
async def create_item(item: Item):
    return {"item": item}

handler = Mangum(app)

This expanded version includes a GET route with a path parameter and a POST route that accepts JSON data. Remember to redeploy your Lambda function after making changes.

One of the coolest things about this setup is that you still get all the FastAPI goodies, like automatic API documentation. Just append /docs to your API Gateway URL, and you’ll see the Swagger UI with your API endpoints.

Now, let’s talk about some advanced features and best practices. Error handling is crucial in any application. FastAPI makes it easy with built-in exception handling. For example:

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    if user_id not in users_db:
        raise HTTPException(status_code=404, detail="User not found")
    return {"user": users_db[user_id]}

This code raises a 404 error if the user isn’t found, which FastAPI automatically converts to an appropriate HTTP response.

Another important aspect is logging. AWS Lambda has its own logging system that integrates with CloudWatch. You can use the aws-lambda-powertools library to enhance your logging capabilities:

from aws_lambda_powertools import Logger

logger = Logger()

@app.get("/log-test")
async def log_test():
    logger.info("This is an info log")
    logger.warning("This is a warning")
    return {"message": "Check the logs!"}

This code sets up structured logging that works well with CloudWatch, making it easier to debug and monitor your application.

When it comes to database access, you might think serverless and databases don’t mix well. But fear not! You can use AWS RDS Proxy to maintain a pool of database connections that your Lambda function can use. Here’s a quick example using SQLAlchemy:

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "postgresql://user:password@rds-proxy-endpoint:5432/dbname"

engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

@app.get("/db-test")
async def db_test():
    db = SessionLocal()
    try:
        result = db.execute("SELECT 1").fetchone()
        return {"result": result[0]}
    finally:
        db.close()

This code sets up a database connection using RDS Proxy, executes a simple query, and returns the result.

One thing to keep in mind with serverless applications is cold starts. When your Lambda function hasn’t been invoked for a while, it might take a bit longer to respond the first time. You can mitigate this by using provisioned concurrency, which keeps a certain number of instances warm and ready to respond quickly.

As your application grows, you might want to split it into multiple files for better organization. FastAPI supports this with its router feature:

# items.py
from fastapi import APIRouter

router = APIRouter()

@router.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id}

# main.py
from fastapi import FastAPI
from mangum import Mangum
from items import router as items_router

app = FastAPI()
app.include_router(items_router)

handler = Mangum(app)

This approach allows you to organize your routes into separate files, making your codebase more manageable.

Security is always a top concern. With AWS Lambda, you get a lot of security features out of the box, but there are still things you need to consider. For example, you should always use environment variables for sensitive information like API keys or database credentials. AWS Lambda lets you set these directly in the console or through CloudFormation.

import os

API_KEY = os.environ.get("API_KEY")

@app.get("/secured")
async def secured_route(api_key: str):
    if api_key != API_KEY:
        raise HTTPException(status_code=403, detail="Invalid API key")
    return {"message": "Welcome to the secured route!"}

This code checks for a valid API key in the request, with the actual key stored safely as an environment variable.

Testing is another crucial aspect of development. With FastAPI, you can easily write unit tests for your routes using the TestClient:

from fastapi.testclient import TestClient

client = TestClient(app)

def test_read_main():
    response = client.get("/")
    assert response.status_code == 200
    assert response.json() == {"message": "Hello, serverless FastAPI!"}

You can run these tests locally before deploying, ensuring that your code works as expected.

As your API grows, you might need to implement rate limiting to prevent abuse. While AWS API Gateway provides some rate limiting features, you can also implement it in your FastAPI app using a library like slowapi:

from fastapi import FastAPI
from slowapi import Limiter, _rate_limit_exceeded_handler
from slowapi.util import get_remote_address
from slowapi.errors import RateLimitExceeded

limiter = Limiter(key_func=get_remote_address)
app = FastAPI()
app.state.limiter = limiter
app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)

@app.get("/limited")
@limiter.limit("5/minute")
async def limited_route():
    return {"message": "This route is rate limited"}

This code limits the /limited route to 5 requests per minute per IP address.

Remember, one of the main advantages of serverless is scalability. Your FastAPI app on AWS Lambda can automatically scale to handle traffic spikes without any additional configuration. However, you should be aware of AWS Lambda’s limits, such as the maximum execution time of 15 minutes.

In conclusion, combining FastAPI with AWS Lambda and Mangum opens up a world of possibilities for building scalable, efficient, and cost-effective APIs. It’s a powerful combo that leverages the best of both worlds - the simplicity and performance of FastAPI with the scalability and cost-effectiveness of serverless computing. As you continue to explore this setup, you’ll discover even more ways to optimize and enhance your applications. Happy coding!