Introduction
Modern serverless architectures have transformed how developers build and deploy applications, offering unprecedented scalability and cost-efficiency. FastAPI with AWS Lambda, combines the power of Python's fastest web framework with serverless computing, enabling you to build production-ready APIs that scale automatically and minimize infrastructure costs.
This guide will help you deploy a FastAPI application on an AWS Lambda and make it available to the public.
Prerequisites
- Python 3.9+ (we’ll use Python 3.12 in this tutorial, but any 3.9+ version works).
- Docker Desktop (to build and test container images locally).
- AWS account with permissions to create ECR repositories and Lambda functions.
FastAPI Setup
Create a directory for project and isolate dependencies in a virtual environment.
Make a new directory
mkdir FastApiProject
cd FastApiProject
You can use GUI to do the same as well.
Create a virtual environment
python -m venv .venv
.venv\Scripts\activate.bat
Install FastAPI and Mangum in the virtual environment
pip install "fastapi[standard]"
pip install mangum
"fastapi[standard]" installs FastAPI itself, plus Uvicorn (an ASGI server), pydantic, and other tools.
mangum is a lightweight adapter that lets AWS Lambda invoke your ASGI app seamlessly.
Create requirements.txt in root directory
pip freeze > requirements.txt
Create the app directory
Your project tree should now look like this:
FastApiProject/
├── .venv/
├── requirements.txt
└── app/
Inside the app/ folder, create main.py and insert following code inside it:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Hello, World from FastAPI on AWS Lambda!"}
Run the FastAPI app locally to verify it works
fastapi dev app/main.py
API should now be accessible at http://localhost:8000
You can also open the browser and navigate to http://localhost/docs to see the interactive Swagger UI.
Setup the Mangum handler for Lambda
from mangum import Mangum
handler = Mangum(app, lifespan="off")
Final main.py will now look like this
from fastapi import FastAPI
from mangum import Mangum
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Hello, World from FastAPI on AWS Lambda!"}
handler = Mangum(app, lifespan="off")
Docker Setup
Create a Dockerfile for Containerized Deployment and insert the following code inside it.
# Use the official AWS Lambda Python 3.12 base image
FROM public.ecr.aws/lambda/python:3.12
# Copy requirements and install dependencies
COPY requirements.txt ${LAMBDA_TASK_ROOT}
RUN pip install -r requirements.txt
# Copy application code into the container
COPY ./app ${LAMBDA_TASK_ROOT}/app
# Specify the Lambda function handler (app.main.handler)
CMD ["app.main.handler"]
ECR Setup
Create an ECR repository
- Go to Amazon ECR → Repositories.
- Click Create repository.
- Give it a name, e.g., fastapi-project.
- Leave all other settings as default and click Create repository.
Upload Project to ECR
In the repository details page, click View push commands.
Here, You will see 4 commands
- first, is used to login to AWS account
- second, builds the project (docker desktop must be started to finish this step)
- third, tags the image with latest
- fourth, push the image to ECR
After a few moments, you should see the image layers being uploaded.
In the ECR console, the fastapi-project repository will list the image with latest tag.
Lambda Setup
Create the AWS Lambda Function from the Container Image
- In the AWS Console, go to AWS Lambda → Functions, then click Create function.
- Select “Container image” as the deployment type.
- Configure function
- Function name: fastapi-function (or any descriptive name).
- Container image URI: Click Browse images, navigate to ECR, and pick the fastapi-project:latest image.
- Click “Create function” and wait a few seconds while AWS provisions resources.
- it will start the process, wait for few seconds for process to finish. it depends on the size of project.
Now to test if deployment worked, we will configure a Function URL (public HTTP endpoint):
- In your function’s Configuration tab, click Function URL on the left sidebar.
- Click Create function URL.
- Auth type: Choose NONE if you want an open, public endpoint (for testing/prototyping). For production, consider using AWS_IAM or a custom authorizer.
- Click Save.
AWS will generate a HTTPS URL which will be visible on function's home page.
Clicking this URL opens a new page that displays the output on-screen:
{
"message": "Hello, World from FastAPI on AWS Lambda!"
}
Conclusion
With this we have just built an end-to-end, production-ready FastAPI service running on AWS Lambda.
By following this guide, you now:
Initialized a FastAPI project in a clean directory with virtual environment isolation.
Developed a minimal FastAPI application and tested it locally with Uvicorn.
Containerized the app with an optimized Dockerfile, leveraging AWS’s official Lambda Python base image.
Pushed the container image to Amazon ECR and created a Lambda function that references it.
Exposed the FastAPI endpoints publicly via a Lambda Function URL for easy testing.
Happy deployment 😊
Next Steps and Best Practices
API Gateway vs. Function URL
Function URL is the quickest way to expose Lambda-backed API, but it lacks advanced features like WAF integration, custom domain mapping, or request/response transformations.
If you need features like API key management, request throttling, or granular resource policies, integrate your Lambda with Amazon API Gateway instead of using the built-in Function URL. The setup is similar: create an API Gateway REST or HTTP API, point the integration to your Lambda function, and configure routes.
Environment Variables & Configuration
Use Lambda’s Environment Variables (in the Configuration tab) to inject secrets or configuration at runtime (e.g., database URLs, third-party API keys).
If you liked this post or have any questions/comments, please leave a comment below!
Top comments (0)