Deploying Serverless Functions on AWS with FastAPI and AWS Lambda

In the ever-evolving landscape of web development, serverless architecture has emerged as a game-changing approach that allows developers to build and deploy applications without the need to manage servers. AWS Lambda, combined with FastAPI—a modern, fast (high-performance) web framework for building APIs with Python—provides a powerful synergy for creating serverless applications. In this article, we'll explore how to deploy serverless functions on AWS using FastAPI and AWS Lambda, complete with code examples and actionable insights.

What is Serverless Architecture?

Serverless architecture is a cloud computing model that allows developers to build and run applications without managing infrastructure. Instead of provisioning and maintaining servers, developers can focus on writing code. Key benefits include:

• Cost Efficiency: You pay only for the compute time you consume, not for idle server capacity.
• Scalability: Automatically scales applications based on demand.
• Reduced Operational Overhead: Less time spent on server management means more time for development.

Why Choose FastAPI?

FastAPI is an ideal choice for building APIs due to its:

• High Performance: Built on ASGI, it is one of the fastest Python frameworks, significantly outperforming traditional frameworks.
• Ease of Use: Simple syntax and automatic generation of OpenAPI documentation.
• Asynchronous Capabilities: Designed to support async and await, making it suitable for I/O-bound operations.

Setting Up Your Environment

Before we dive into deploying serverless functions, ensure you have the following prerequisites installed:

• Python 3.7 or later
• AWS CLI: Used for interacting with AWS services.
• AWS Account: Sign up if you don’t have one.
• Docker: Needed for creating a deployment package.

Step 1: Create a FastAPI Application

Let’s create a simple FastAPI application. Create a directory for your project and navigate into it:

mkdir fastapi-lambda
cd fastapi-lambda

Then, create a file named main.py and add the following code:

from fastapi import FastAPI

app = FastAPI()

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

@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "query": q}

Step 2: Create a Requirements File

Create a requirements.txt file to specify the dependencies:

fastapi
uvicorn

Step 3: Create a Lambda Function Handler

AWS Lambda requires a specific handler function. Create a new file called handler.py and add the following content:

import json
from mangum import Mangum
from main import app

handler = Mangum(app)

def lambda_handler(event, context):
    return handler(event, context)

The Mangum adapter allows FastAPI to run on AWS Lambda by converting AWS API Gateway events into ASGI events.

Step 4: Dockerize Your Application

To deploy your FastAPI app to AWS Lambda, you need to create a Docker container. Create a Dockerfile in your project directory:

FROM public.ecr.aws/lambda/python:3.8

# Copy the requirements file and install dependencies
COPY requirements.txt ./
RUN pip install -r requirements.txt

# Copy the application files
COPY main.py ./
COPY handler.py ./

# Command to run the Lambda function
CMD ["handler.lambda_handler"]

Step 5: Build and Push Docker Image to ECR

1. Log in to AWS ECR:

bash aws ecr get-login-password --region <your-region> | docker login --username AWS --password-stdin <your-account-id>.dkr.ecr.<your-region>.amazonaws.com

1. Create an ECR repository:

bash aws ecr create-repository --repository-name fastapi-lambda

1. Build the Docker image:

bash docker build -t fastapi-lambda .

1. Tag the Docker image:

bash docker tag fastapi-lambda:latest <your-account-id>.dkr.ecr.<your-region>.amazonaws.com/fastapi-lambda:latest

1. Push the Docker image to ECR:

bash docker push <your-account-id>.dkr.ecr.<your-region>.amazonaws.com/fastapi-lambda:latest

Step 6: Create the Lambda Function

Now, let’s create the Lambda function using the AWS Console or AWS CLI:

aws lambda create-function --function-name fastapi-lambda \
--package-type Image --code ImageUri=<your-account-id>.dkr.ecr.<your-region>.amazonaws.com/fastapi-lambda:latest \
--role arn:aws:iam::<your-account-id>:role/<your-lambda-execution-role> \
--region <your-region>

Step 7: Configure API Gateway

1. Create a new API in API Gateway.
2. Set up a new resource and method (GET, POST, etc.) linking to your Lambda function.
3. Deploy the API and note the endpoint.

Step 8: Test Your Lambda Function

Use a tool like Postman or simply curl to test your API:

curl https://<api-id>.execute-api.<your-region>.amazonaws.com/<stage>/

You should see a response like:

{"Hello": "World"}

Conclusion

Deploying serverless functions on AWS using FastAPI and AWS Lambda is a straightforward process that allows you to leverage the benefits of serverless architecture while building high-performance APIs. By following the steps outlined in this guide, you can create, deploy, and test your serverless application effectively.

Troubleshooting Tips

• Cold Start Issues: Optimize the size of your Docker image and reduce initialization code to minimize cold start times.
• Permissions: Ensure your Lambda execution role has the required permissions for any AWS resources it needs to access.
• API Gateway Limitations: Be aware of API Gateway limits, such as payload size and request rates.

By adopting FastAPI and AWS Lambda, you can streamline your development process, reduce costs, and focus on what matters most: building fantastic applications!