How to deploy your FastAPI application on AWS Lambda with Serverless

Author: Adem Usta

Published on 2021-04-10

How to deploy your FastAPI application on AWS Lambda with Serverless


FastAPI, the python package created by Sebastián Ramírez, is a great framework that allows you to create REST APIs.

It’s quite straightforward to take the control of it.

If you didn’t know this package, I wisely invite you to visit the official documentation and create your APIs with it !

If you came accross this article, you are probably looking for a way to deploy your FastAPI application on AWS Lambda, the Amazon serverless ecosystem.

Good pick ! We will try to explain to you how to proceed.


Step 1 - Create a simple FastAPI app

By following the official guide, we can code an application with a few lines of code.

Let’s create a file that declares the app and a /hello route:

from fastapi import FastAPI

app = FastAPI(title="MyAwesomeApp")

def hello_world():
    return {"message": "Hello World"}

Step 2 - Test your application locally

To test the app locally, let’s create a virtual environment and install what’s inside the requirements.txt file:


Some commands to do that:

python3.8 -m venv .virtualenv   # Creates a virtual environment
source .virtualenv/bin/activate # Activates it in the current shell
pip install -r requirements.txt # Installs python packages

Deploy your application locally:

uvicorn main:app

You should see some logs like these:

INFO:     Started server process [87999]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on (Press CTRL+C to quit)

Your app is available here:

You can check the autogenerated documentation here:

A small overview:

FastAPI autogenerated documentation

Is your app fully functionnal locally ? Perfect, we are ready for the rest.

Step 3 - Adapt your FastAPI application with the AWS Lambda ecosystem

To make your application compatible with Lambda, we will use a small package called Mangum.

Add it in your requirements.txt file, it will be essential in the next steps.


We will modify to wrap up the app object:

from fastapi import FastAPI
from mangum import Mangum

app = FastAPI(title="MyAwesomeApp")

def hello_world():
    return {"message": "Hello World"}

handler = Mangum(app)


At this point, the app is ready and will be functionnal with Lambda, but one of the features won’t be accessible: the autogenerated documentation.

Indeed, when deployed, the application will be accessible with an endpoint that has this shape:

Out, to generate the documentation, FastAPI needs, by default, to be served through a domain, not a path.

To solve this problem, we will modify the python code:

import os

from fastapi import FastAPI
from mangum import Mangum

stage = os.environ.get('STAGE', None)
openapi_prefix = f"/{stage}" if stage else "/"

app = FastAPI(title="MyAwesomeApp", openapi_prefix=openapi_prefix) # Here is the magic

def hello_world():
    return {"message": "Hello World"}

handler = Mangum(app)

In summary:

We changed the path that is used to serve openapi.json, that will allow the documentation page to be generated without any issue.

At this point, your python code is ready ! Let’s deploy that with serverless.

Step 4 - Use serverless to deploy the application

You need to install the serverless CLI and configure it with your AWS credentials.

Install the CLI with npm:

npm install -g serverless

It’s a tool that facilitate the deployment of applications and services in the cloud, by describing them in a YAML file.

It’s compatible with AWS Lambda, and more generally with AWS Cloudformation.

For more info about this tool, go check

Configure serverless with your credentials:

serverless config credentials --provider aws --key <YOUR_KEY> --secret <YOUR_SECRET_KEY>

Let’s create a serverless.yaml file that contains all the specifications of our app:

service: my-awesome-app

  individually: true

  name: aws
  runtime: python3.8
  region: eu-west-1
  stage: ${opt:stage, "dev"}

  - serverless-python-requirements

    dockerizePip: true
      name: my-awesome-app-layer
      description: My awesome app layer
        - python3.8

        - ""
        - "requirements.txt"
        - "package.json"
        - "package-lock.json"
        - ".serverless/**"
        - ".virtualenv/**"
        - "node_modules/**"

    handler: main.handler
      STAGE: ${self:provider.stage}
      - { Ref: PythonRequirementsLambdaLayer }
      - http:
          method: any
          path: /{proxy+}

And, at the same level, create a package.json file:

    "name": "my-awesome-app",
    "version": "1.0.0",
    "author": "<YOUR_NAME>",
    "dependencies": {
        "serverless-python-requirements": "^5.0.1"

This file will help us install some JavaScript plugins that are used in our YAML file.

Install these plugins:

npm install

And, let’s deploy our application !

sls deploy --stage staging # "stage" indicates which stage you are deploying. It could be anything.

serverless does its magic.

After some minutes (no more than 5 usually), you will see some logs like these:

Service Information
service: my-awesome-app
stage: staging
region: eu-west-1
stack: my-awesome-app-staging
resources: 12
api keys:
  app: my-awesome-app-staging-app

By checking these logs, you will find your application endpoint !

Here, it’s (XXXXXX is usually a mix of numbers and letters).

If you visit, you will see your application documentation !

To update your app (e.g add a new route, etc.), you just need to modify your code, and deploy again:

sls deploy --stage staging

To completely delete your application from the cloud:

sls remove --stage staging

You now have all the information to create FastAPI apps and host them on AWS Lambda !

[Bonus] Step 5 - Use your own domain with your app

If you want your application to be available through your own domain, you’re a few steps from doing it !

Some prerequisites are necessary:

  • a domain name hosted on AWS Route53
  • a certificate linked to this domain (for HTTPS), generated with AWS Certificate Manager (if you don’t have it, create a new one and host it on the AWS default region us-east-1, as it is considered as global for certificates).

We will use a plugin to make our life easier: serverless-domain-manager.

Install it:

npm install serverless-domain-manager

Add it in the list of plugins, in your serverless.yaml file:

  - serverless-python-requirements
  - serverless-domain-manager

We need to configure the plugin, so add these few lines in the custom section of serverless.yaml:

    domainName: YOUR_DOMAIN_HERE
    stage: ${self:provider.stage}
    endpointType: "edge"
    securityPolicy: tls_1_2
    apiType: rest
    autoDomain: true
    autoDomainWaitFor: 120

(Don’t forget to fill the fields with your own values).

Once it’s done, deploy:

sls deploy --stage staging

After a few minutes, we can access to our app with our own domain !

… Really ?

Try to access to the documentation page located at /docs, you see the trap ?

FastAPI documentation error

This error occurs because of what we did previously to access the documentation page with the lambda default endpoint.

We just need to rollback:

app = FastAPI(title="MyAwesomeApp", openapi_prefix=openapi_prefix) # Change this

app = FastAPI(title="MyAwesomeApp") # With this

Deploy again.

Tada GIF

You now have your application running on AWS Lambda, with your own domain !


Through this article written in the form of a tutorial, you are now capable of creating a FastAPI application, test it locallly and deploy it on the cloud !

If you have any questions, feel free to contact me. Don’t hesitate !

See you soon,