FastAPI is a high-performance web framework for building APIs with Python. It was created to make the process of developing web applications and APIs faster, simpler, and more efficient. It's a great option for creating strong and well-documented APIs.

If you are looking for other deployment tutorials checkout out one of these:

In this post:

Key benefits of FastAPI

The primary purpose of FastAPI is to enable developers to build APIs quickly and efficiently. Also, its focus on performance makes it a great choice for high-throughput apps and services.

Things to know about FastAPI: 1. Fast: FastAPI is built on top of Starlette, a high-performance asynchronous web framework. This enables FastAPI to handle many concurrent connections.

  1. With help of type hints FastAPI validates incoming request data and helps avoid errors.

  2. FastAPI generates interactive API documentation based on the provided type hints. Uses It offers an interactive Swagger UI and ReDoc.

FastAPI vs Django

Django is a full-featured web framework that follows the "batteries-included" philosophy. While Django is excellent for building complete web applications, it might be overkill if you only need to create APIs. FastAPI, is specifically designed for API development and is more lightweight and faster.

FastAPI versus Flask

Flask is a micro web framework. It is minimalistic and gives developers the flexibility to choose extra libraries. Flask is fine for small to medium-sized projects and offers simplicity and ease of use. Yet, absence of async support can limit Flask's performance in certain scenarios.

If you are building a high-performance API FastAPI is an excellent option.

Create a FastAPI app

Here is the link to the demo repository:

Setup the environment

  1. First create an app directory
mkdir fastapi_demo
cd fastapi_demo
  1. Create virtual environment and install packages, then save all dependencies to the requirements.txt file for deployment to work.
python3 -m venv env
source env/bin/activate
pip install fastapi uvicorn sqlalchemy psycopg2-binary
pip freeze > requirements.txt
  1. Create a file with the following code:
import os

import uvicorn
from fastapi import FastAPI
from pydantic import BaseModel
from sqlalchemy import Column, Integer, String, create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from starlette.responses import HTMLResponse

app = FastAPI()

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

class Message(Base):
    __tablename__ = "messages"
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String, index=True)
    email = Column(String, index=True)
    message = Column(String, index=True)

# Create the table in the database

class MessageIn(BaseModel):
    name: str
    email: str
    message: str"/messages/", response_model=MessageIn)
def create_message(message: MessageIn):
    db_message = Message(**message.model_dump())
    db = SessionLocal()
    return db_message

@app.get("/healthcheck/", response_model=str)
def healthcheck():
    return "OK"

if __name__ == "__main__":
        port = os.environ.get("PORT", "5000")
        port = int(port)
    except ValueError:
        port = 5000"main:app", host='', port=port, log_level="info")

What this code does: 1. app = FastAPI() this creates an instance of FastAPI app 2. Set up database connection:

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

This grabs the database connection string from the environment variable DATABASE_URL. It will throw an exception if environment variable is not set. Then creates SQLAlchemy engine with the provided DATABASE_URL and creates a database session. 3. Message class represents the table in the database 4. Base.metadata.create_all(bind=engine): This line creates the "messages" table in the database if it doesn't exist yet, based on the Message model. 5. MessageIn: A Pydantic model that will be used to validate the input data for creating messages. 6. Two endpoints create_message, which accepts POST requests and writes data to the database table Messages and the healthcheck endpoint that simply returns OK . It can be useful to make verify that app is running. 7. Finally, we launch our app using uvicorn. We do it in the code of the app itself, not in command line to make sure it respects the environment variable PORT. If it is not set, then the default port 5000 will be used.

Now create the Procfile next to your It will be used to run your app when deployed with Appliku:

web: python

Also create the .gitgnore file. Main thing to include in this file is python cache files, virtual env and your editor of choice dot directory. Extend the following list for your own setup.


Now we need to initialize a git repository and commit it.

git init
git add .
git commit -m'Initial commit'

Create a GitHub or GitLab repository, add the remote and let's deploy it with Appliku.

Deploy FastAPI on AWS EC2 Instance

If you haven't already – create an account in Appliku ([]

Appliku automates the server setup and application deployment. It also takes care of the database creation, managing environment variables and automatically builds and deploys your FastAPI app when you push new changes to the attached git repository.

In this post I will show you how to deploy the FastAPI app on an AWS EC2 instance.

In Appliku dashboard go to the Servers tab.

If you haven't set up AWS connection then follow instructions to generate required credentials and add them to your team.

When it is done you will be able to create an AWS EC2 Instance.

Select AWS provider.


Select the region, instance type and the disk size. To fit in AWS Free Tier make sure the disk size to be <30GB.



Click "Create EC2 Instance".

You will be taken to the server page where you will see the setup process. When it is finished, go to Applications tab and create a new app from GitHub (or GitLab if you hosted your repository there)

Give application a name, pick your repository and the branch, select the server you have just created. image

After clicking on "Create Application" you will be taken to the application overview.

Go to databases Management to create a Postgres Database on your your server.



Wait for it to finish deploying and go back to application overview



Click "Deploy now". It might take a bit to finish the first deployment as it will have to install all requirements for the first time.


The app is deployed, you can click on the "View application" button and it will open the app on a subdomain with the app's name.

image image If you add /healthcheck/ to the URL you will see that app responds with our "OK", which means app is deployed fine.

Now go to terminal and run a CURL command to save a message.

curl --request POST \
  --url \
  --header 'Content-Type: application/json' \
  --data '{
    "name" : "john Snow",
    "email": "",
    "message": "hello"


You can now go back to the database and copy the credentials.


Using a PostgreSQL client of your choosing connect to the DB.

I will do it from terminal:


You can see that table is created and there is a record with our message.

Congratulations! You have deployed a fully functional FastAPI with a PostgreSQL database!