FastAPI Backend Development Bootcamp · Lekcja

Łączenie FastAPI z PostgreSQL

Skonfigurują Państwo połączenie między aplikacją FastAPI a bazą danych PostgreSQL za pomocą SQLAlchemy.

Łączenie FastAPI z PostgreSQL to bezpłatna lekcja FastAPI Backend Development Bootcamp na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej FastAPI Backend Development Bootcamp, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs FastAPI Backend Development Bootcamp zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

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.

Często zadawane pytania

Czy lekcja „Łączenie FastAPI z PostgreSQL” jest bezpłatna?

Tak — pełny tekst „Łączenie FastAPI z PostgreSQL” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu FastAPI Backend Development Bootcamp, przejdź na CoddyKit PRO. Kurs FastAPI Backend Development Bootcamp zawiera 4 lekcji w sumie.

Co nauczysz się w „Łączenie FastAPI z PostgreSQL”?

Skonfigurują Państwo połączenie między aplikacją FastAPI a bazą danych PostgreSQL za pomocą SQLAlchemy. Ćwiczysz FastAPI Backend Development Bootcamp z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć FastAPI Backend Development Bootcamp?

Nie wymagamy żadnego doświadczenia. FastAPI Backend Development Bootcamp w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Łączenie FastAPI z PostgreSQL”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji FastAPI Backend Development Bootcamp?

Tak. Każda lekcja FastAPI Backend Development Bootcamp zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do FastAPI Backend Development Bootcamp