Create an App using Postgres, SQL Alchemy, Async, and more with this Fast API Crash Course Code-along

In this tutorial, we will be building a FastAPI app that interacts with a Postgres database using SQL Alchemy. We will be using asynchronous programming to make our app more performant and scalable. We will also be covering various other tools and libraries that are commonly used in building FastAPI apps.

Let’s get started!

Step 1: Install necessary dependencies

First, we need to install the necessary dependencies for our project. We will be using FastAPI, SQL Alchemy, Uvicorn, and other libraries. You can install them using pip:

pip install fastapi uvicorn asyncpg sqlalchemy databases

Step 2: Set up the database

Next, we need to set up our Postgres database. You can create a new database in Postgres using a tool like pgAdmin or by running the following command in your terminal:

createdb myapp

Step 3: Create the FastAPI app

Now, let’s create our FastAPI app. Create a new file called main.py and add the following code:

from fastapi import FastAPI, HTTPException
from sqlalchemy import create_engine, Column, Integer, String, MetaData, Table
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "postgresql://localhost/myapp"

engine = create_engine(DATABASE_URL)

Base = declarative_base()

metadata = MetaData()

users = Table(
    "users",
    metadata,
    Column("id", Integer, primary_key=True, index=True),
    Column("name", String),
    Column("email", String),
)

Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Step 4: Create the models

Next, let’s create the models for our app. Add the following code to main.py:

class User(Base):
    __table__ = users

Step 5: Create the API routes

Now, let’s create the API routes for our app. Add the following code to main.py:

app = FastAPI()

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    async with Session() as session:
        user = await session.execute(users.select().where(users.c.id == user_id))
        user = user.fetchone()
        if user is None:
            raise HTTPException(status_code=404, detail="User not found")
        return user

@app.post("/users")
async def create_user(name: str, email: str):
    async with Session() as session:
        new_user = User(name=name, email=email)
        session.add(new_user)
        await session.commit()
        return new_user

Step 6: Run the app

Finally, we can run our FastAPI app using Uvicorn. Run the following command in your terminal:

uvicorn main:app --reload

You should see output indicating that the server is running. You can now navigate to http://localhost:8000/docs in your browser to see the Swagger documentation for your API.

That’s it! You have successfully built a FastAPI app that interacts with a Postgres database using SQL Alchemy. You have also learned how to use asynchronous programming to make your app more performant and scalable.

I hope you found this tutorial helpful. Happy coding!