FastAPI: Rask prototyping med Python og automatisk dokumentasjon

Ikke alt bør bygges med JavaScript. Noen ganger er Python det riktige verktøyet — spesielt når du jobber med data, maskinlæring eller trenger å bygge en API raskt uten å gi opp typesikkerhet. FastAPI er rammeverket som gjør Python til et seriøst valg for backend-utvikling, og det er det jeg bruker når oppgaven krever det Python-økosystemet tilbyr.

Hvorfor FastAPI

Python har alltid vært populært for skripting og databehandling, men web-rammeverk som Flask og Django har tradisjonelt hatt begrensninger — enten mangel på typesikkerhet, treg ytelse, eller begge deler. FastAPI løser dette.

Type hints som driver alt. FastAPI bruker Python type hints ikke bare for dokumentasjon, men som kilde til validering, serialisering og API-dokumentasjon. Du definerer en Pydantic-modell med typer, og FastAPI genererer automatisk input-validering, feilmeldinger og OpenAPI-spesifikasjon. Én kilde til sannhet.

Automatisk OpenAPI-dokumentasjon. Når du starter serveren, får du Swagger UI og ReDoc gratis på /docs og /redoc. Ingen ekstra konfigurasjon, ingen manuell dokumentasjonsskriving. API-dokumentasjonen er alltid oppdatert fordi den genereres direkte fra koden.

Asynkron støtte. FastAPI er bygget på Starlette og støtter async/await nativt. For I/O-tunge operasjoner — API-kall, databasespørringer, fillesing — gir dette betydelig bedre ytelse enn synkrone rammeverk.

Slik bruker jeg det

Jeg bruker FastAPI i prosjekter der Python-økosystemet gir en reell fordel.

Data pipelines. Jeg har bygget API-tjenester som tar inn rådata, prosesserer den med pandas og numpy, og returnerer strukturerte resultater. Python har uovertrufne biblioteker for databehandling, og FastAPI gjør det enkelt å eksponere denne funksjonaliteten som en REST API.

Learning-content-pipeline. For Nextbook har jeg en pipeline som prosesserer kursmateriell — konverterer formater, genererer metadata, validerer innholdsstruktur. FastAPI driver API-et som orkestrerer denne prosessen, med Pydantic-modeller som sikrer at data har riktig format i hvert steg.

Typet endepunkt med Pydantic

Et typisk FastAPI-endepunkt med full validering og dokumentasjon:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
from datetime import datetime

app = FastAPI(title="Content Pipeline API")

class ContentRequest(BaseModel):
    title: str = Field(min_length=1, max_length=200)
    body: str = Field(min_length=10)
    format: str = Field(pattern="^(markdown|html|plain)$")
    language: str = Field(default="no", pattern="^(no|en)$")

class ContentResponse(BaseModel):
    id: str
    title: str
    word_count: int
    processed_at: datetime

@app.post("/content/process", response_model=ContentResponse)
async def process_content(req: ContentRequest):
    word_count = len(req.body.split())
    if word_count < 50:
        raise HTTPException(status_code=422, detail="Content too short for processing")

    result = await pipeline.process(req.title, req.body, req.format, req.language)

    return ContentResponse(
        id=result.id,
        title=req.title,
        word_count=word_count,
        processed_at=datetime.now(),
    )

Alt som trengs for validering er definert i Pydantic-modellene. Field-dekoratørene setter begrensninger — minimumslengde, regex-mønstre, standardverdier. Hvis en request ikke matcher, returnerer FastAPI automatisk en detaljert 422-feilmelding som forteller klienten nøyaktig hva som er galt.

Dependency injection for database-sesjoner

FastAPI har et elegant dependency injection-system som håndterer ressurser som databaseforbindelser:

from fastapi import Depends
from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine, async_sessionmaker

engine = create_async_engine("postgresql+asyncpg://localhost/contentdb")
SessionFactory = async_sessionmaker(engine, expire_on_commit=False)

async def get_db() -> AsyncSession:
    async with SessionFactory() as session:
        try:
            yield session
            await session.commit()
        except Exception:
            await session.rollback()
            raise

@app.get("/content/{content_id}")
async def get_content(content_id: str, db: AsyncSession = Depends(get_db)):
    result = await db.execute(
        select(Content).where(Content.id == content_id)
    )
    content = result.scalar_one_or_none()
    if not content:
        raise HTTPException(status_code=404, detail="Content not found")
    return content

Depends(get_db) injiserer en database-sesjon i hvert endepunkt som trenger det. Sesjonen lukkes automatisk etter at requestet er ferdig — commit ved suksess, rollback ved feil. Du trenger aldri å huske å lukke forbindelser manuelt, og testbarhet er innebygd fordi du kan bytte ut avhengigheten i tester.

Når du IKKE bør bruke FastAPI

Python er ikke alltid riktig valg for backend.

Høy-concurrency tjenester. For tjenester som håndterer tusenvis av samtidige tilkoblinger med minimal prosessering per request — som API-gateways eller chat-servere — er Go eller Rust betydelig bedre. Pythons GIL og overhead per request gjør det uegnet for ren throughput.

Frontend-tunge applikasjoner. Hvis applikasjonen din primært er en webapp med litt API, er Next.js API-ruter eller en Node.js-backend mer praktisk. Du unngår kontekstbyttet mellom JavaScript og Python, og hele stacken lever i samme økosystem.

Enkle CRUD-apper. Hvis alt du trenger er standard CRUD mot en database, kan Supabase eller Firebase gi deg et API uten at du skriver en eneste linje backend-kode. FastAPI gir mest verdi når du har forretningslogikk som faktisk trenger å leve i kode.

Oppsummering

FastAPI er verktøyet jeg bruker når oppgaven krever Python — databehandling, maskinlæring-integrasjon, eller komplekse pipelines der Python-biblioteker sparer uker med arbeid. Typesikkerheten og den automatiske dokumentasjonen gjør at det føles som et moderne rammeverk, ikke en ettertanke. For riktig brukstilfelle er det vanskelig å slå.