FastAPI Backend Development Bootcamp · Aula

Conectando o FastAPI ao PostgreSQL

Configure uma conexão entre sua aplicação FastAPI e um banco de dados PostgreSQL usando o SQLAlchemy.

Conectando o FastAPI ao PostgreSQL é uma aula grátis de FastAPI Backend Development Bootcamp no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de FastAPI Backend Development Bootcamp, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de FastAPI Backend Development Bootcamp inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Why Connect to a Database?

Web applications often need to store and retrieve data persistently. This data could be user profiles, product listings, or transaction records.

Instead of losing data when your app restarts, we connect to a database. Databases provide a structured and efficient way to manage large amounts of information.

Introducing PostgreSQL

PostgreSQL is a powerful, open-source relational database system. It's known for its robustness, feature set, and performance.

Reliable: Ensures data integrity.
Scalable: Handles large data volumes and high user loads.
Extensible: Supports custom data types and functions.

Many FastAPI applications use PostgreSQL as their primary data store.

The Database Connection URL

To connect to any database, you need a connection string or URL. This URL tells SQLAlchemy (our ORM) how to find and authenticate with your database.

For PostgreSQL, a typical URL looks like this:

postgresql://user:password@host:port/database_name

It's best practice to store this URL in an environment variable for security and flexibility.

Creating the SQLAlchemy Engine

The first step in SQLAlchemy is to create an Engine. The Engine is responsible for communicating with the database.

We use create_engine from sqlalchemy to establish this connection. For our runnable example, we'll use SQLite, but the principle for PostgreSQL is the same – just the URL changes.

from sqlalchemy import create_engine

# For PostgreSQL, this would be:
# SQLALCHEMY_DATABASE_URL = "postgresql://user:password@localhost/dbname"
# For a runnable example, we'll use SQLite:
SQLALCHEMY_DATABASE_URL = "sqlite:///./sql_app.db"

engine = create_engine(
    SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
)

print("Engine created successfully!")

Managing Database Sessions

Directly interacting with the database through the engine isn't ideal for every request. Instead, we use Sessions.

A Session is like a temporary workspace for your database operations. It handles transactions and ensures changes are committed or rolled back properly.

We create a SessionLocal class using sessionmaker, which will produce session instances.

from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine

# Using SQLite for a runnable example
SQLALCHEMY_DATABASE_URL = "sqlite:///./sql_app.db"
engine = create_engine(
    SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
)

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

print("SessionLocal configured!")

The Declarative Base (Review)

Recall from the previous lesson that declarative base is used to define your SQLAlchemy models. All your ORM models will inherit from this base.

Even though we won't define a new model here, it's an essential part of the setup for any ORM interaction.

from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

print("Declarative Base initialized.")

FastAPI Dependency: get_db()

FastAPI's powerful Dependency Injection system is perfect for managing database sessions.

We'll create a function, get_db, that creates a new database session for each request, uses it, and then closes it automatically. The yield keyword is key here!

from sqlalchemy.orm import Session
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

# Assuming these are defined elsewhere or imported
SQLALCHEMY_DATABASE_URL = "sqlite:///./sql_app.db"
engine = create_engine(
    SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

print("get_db dependency function defined.")

Using the Session in an Endpoint

Now, you can inject the database session directly into your FastAPI endpoint functions using Depends.

FastAPI will call get_db(), pass the session to your route, and ensure it's closed after the request is handled.

from fastapi import FastAPI, Depends
from sqlalchemy.orm import Session

# For this snippet, we'll use a mock get_db to make it runnable
class MockSession:
    def close(self): pass

def get_db_mock():
    yield MockSession()

app = FastAPI()

@app.get("/db-status")
def read_db_status(db: Session = Depends(get_db_mock)):
    # In a real app, 'db' would be your actual SQLAlchemy session
    return {"message": "Database session received!"}

print("FastAPI endpoint defined using DB dependency.")

Full FastAPI-PostgreSQL Setup

Here's a complete example bringing everything together. This app sets up the connection to a database (using SQLite for local testing, but easily swappable for PostgreSQL) and exposes an endpoint that uses a database session.

To run this with a real PostgreSQL, replace the SQLALCHEMY_DATABASE_URL and ensure your PostgreSQL server is running.

from fastapi import FastAPI, Depends
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, Session
from sqlalchemy.ext.declarative import declarative_base
import uvicorn

# --- Database Configuration (for PostgreSQL, replace URL) ---
# For a runnable example, we'll use SQLite in-memory:
SQLALCHEMY_DATABASE_URL = "sqlite:///./sql_app.db"
# For PostgreSQL, it would be:
# SQLALCHEMY_DATABASE_URL = "postgresql://user:password@localhost/dbname"

engine = create_engine(
    SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

# --- Dependency to get DB session ---
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

# --- FastAPI Application ---
app = FastAPI()

@app.get("/connect-test")
def connect_test(db: Session = Depends(get_db)):
    # We've successfully received a DB session 'db'
    # In a real app, you'd perform DB operations here.
    return {"status": "Connected to DB", "db_type": SQLALCHEMY_DATABASE_URL.split('://')[0]}

# To run this, save as 'main.py' and run 'uvicorn main:app --reload'
# if __name__ == "__main__":
#    uvicorn.run(app, host="0.0.0.0", port=8000)

Quick Check: DB Session

Consider the get_db dependency function:

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

What is the primary reason for using yield db instead of return db in this FastAPI dependency?

Recap: Connecting FastAPI to PostgreSQL

In this lesson, you learned the essential steps to connect your FastAPI application to a database, specifically focusing on PostgreSQL (with runnable SQLite examples for convenience).

We defined the Database URL to locate the database.
We used create_engine to establish the connection.
We set up SessionLocal for managing database sessions.
We created a get_db dependency using yield to inject and manage sessions per request in FastAPI.

Now your FastAPI app is ready to interact with a database! Next, we'll learn how to perform CRUD operations.

Perguntas Frequentes

A aula “Conectando o FastAPI ao PostgreSQL” é grátis?

Sim — o texto completo de “Conectando o FastAPI ao PostgreSQL” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de FastAPI Backend Development Bootcamp, atualize para CoddyKit PRO. O curso de FastAPI Backend Development Bootcamp inclui 4 aulas no total.

O que vou aprender em “Conectando o FastAPI ao PostgreSQL”?

Configure uma conexão entre sua aplicação FastAPI e um banco de dados PostgreSQL usando o SQLAlchemy. Você pratica FastAPI Backend Development Bootcamp com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar FastAPI Backend Development Bootcamp?

Nenhuma experiência prévia é necessária. FastAPI Backend Development Bootcamp no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Conectando o FastAPI ao PostgreSQL”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de FastAPI Backend Development Bootcamp?

Sim. Cada aula de FastAPI Backend Development Bootcamp inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para FastAPI Backend Development Bootcamp