Bootcamp i FastAPI-backendudvikling · Lektion

Forbind FastAPI til PostgreSQL

Opsæt en forbindelse mellem Deres FastAPI-applikation og en PostgreSQL-database ved hjælp af SQLAlchemy.

Lektion 2 af 411 trin

Forbind FastAPI til PostgreSQL er en gratis Bootcamp i FastAPI-backendudvikling-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Bootcamp i FastAPI-backendudvikling, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Bootcamp i FastAPI-backendudvikling-kurset indeholder 4 lektioner i alt.

Hvorfor oprette forbindelse til en database?

Webapplikationer har ofte brug for at gemme og hente data permanent. Det kan være brugerprofiler, produktlister eller transaktionsposter.

I stedet for at miste data, når din app genstarter, opretter du forbindelse til en database. Databaser giver en struktureret og effektiv måde at håndtere store mængder information på.

Introduktion til PostgreSQL

PostgreSQL er et effektivt open source-relationsdatabasesystem. Det er kendt for sin robusthed, sine mange funktioner og sin ydeevne.

Pålidelig: Sikrer dataintegritet.
Skalerbar: Håndterer store datamængder og mange samtidige brugere.
Udvidelig: Understøtter brugerdefinerede datatyper og funktioner.

Mange FastAPI-applikationer bruger PostgreSQL som deres primære datalager.

URL til databaseforbindelsen

Hvis du vil oprette forbindelse til en database, skal du bruge en forbindelsesstreng eller URL. Denne URL fortæller SQLAlchemy (vores ORM), hvordan databasen findes og godkendelsen gennemføres.

For PostgreSQL ser en typisk URL sådan ud:

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

Det er god praksis at gemme denne URL i en miljøvariabel af hensyn til sikkerhed og fleksibilitet.

Oprettelse af SQLAlchemy-motoren

Det første trin i SQLAlchemy er at oprette en Engine. Motoren står for kommunikationen med databasen.

Du bruger create_engine fra sqlalchemy til at oprette denne forbindelse. I vores kørbare eksempel bruger du SQLite, men princippet er det samme for PostgreSQL – det er kun URL'en, der ændres.

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!")

Håndtering af databasesessioner

Det er ikke ideelt at interagere direkte med databasen gennem motoren for hver forespørgsel. I stedet bruger du sessioner.

En session er som et midlertidigt arbejdsområde til dine databasehandlinger. Den håndterer transaktioner og sikrer, at ændringer enten gennemføres eller rulles tilbage korrekt.

Du opretter klassen SessionLocal ved hjælp af sessionmaker, som producerer session-instansers.

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!")

Den deklarative base (gennemgang)

Husk fra den forrige lektion, at den deklarative base bruges til at definere dine SQLAlchemy-modeller. Alle dine ORM-modeller nedarver fra denne base.

Selvom du ikke definerer en ny model her, er den en vigtig del af opsætningen til enhver ORM-interaktion.

from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

print("Declarative Base initialized.")

FastAPI-afhængighed: get_db()

FastAPIs effektive system til afhængighedsinjektion er perfekt til håndtering af databasesessioner.

Du opretter en funktion, get_db, der opretter en ny databasesession for hver forespørgsel, bruger den og derefter lukker den automatisk. Nøgleordet yield er centralt her!

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.")

Brug af sessionen i et slutpunkt

Nu kan du injicere databasesessionen direkte i dine FastAPI-funktioner for slutpunkter ved hjælp af Depends.

FastAPI kalder get_db(), sender sessionen til din rute og sørger for, at den lukkes, når forespørgslen er behandlet.

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.")

Komplet FastAPI-PostgreSQL-opsætning

Her er et komplet eksempel, der samler det hele. Denne app opretter forbindelsen til en database (ved hjælp af SQLite til lokal test, som nemt kan udskiftes med PostgreSQL) og stiller et slutpunkt til rådighed, der bruger en databasesession.

Hvis du vil køre dette med en rigtig PostgreSQL-database, skal du erstatte SQLALCHEMY_DATABASE_URL og sikre dig, at din PostgreSQL-server kører.

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)

Hurtigt tjek: databasesession

Overvej afhængighedsfunktionen get_db:

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

Hvad er den primære grund til at bruge yield db i stedet for return db i denne FastAPI-afhængighed?

Besvar den i den interaktive lektion

Opsummering: Forbindelse mellem FastAPI og PostgreSQL

I denne lektion lærte du de vigtigste trin til at forbinde din FastAPI-applikation med en database med særligt fokus på PostgreSQL (med kørbare SQLite-eksempler for nemheds skyld).

Du definerede database-URL'en for at finde databasen.
Du brugte create_engine til at oprette forbindelsen.
Du konfigurerede SessionLocal til at håndtere databasesessioner.
Du oprettede en get_db-afhængighed ved hjælp af yield for at injicere og håndtere sessioner pr. forespørgsel i FastAPI.

Nu er din FastAPI-app klar til at interagere med en database! Næste gang lærer du, hvordan du udfører CRUD-handlinger.

Gratis at komme i gang

Lær Bootcamp i FastAPI-backendudvikling med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 21
Lektioner: 84

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Forbind FastAPI til PostgreSQL” gratis?

Ja — alle 3 lektioner i læringssporet Bootcamp i FastAPI-backendudvikling, inklusive “Forbind FastAPI til PostgreSQL”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Bootcamp i FastAPI-backendudvikling-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Forbind FastAPI til PostgreSQL”?

Opsæt en forbindelse mellem Deres FastAPI-applikation og en PostgreSQL-database ved hjælp af SQLAlchemy. Du øver dig i Bootcamp i FastAPI-backendudvikling med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Bootcamp i FastAPI-backendudvikling?

Der kræves ingen tidligere erfaring. Bootcamp i FastAPI-backendudvikling på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Forbind FastAPI til PostgreSQL”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Bootcamp i FastAPI-backendudvikling-lektion?

Ja. Alle Bootcamp i FastAPI-backendudvikling-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Bootcamp i FastAPI-backendudvikling