Hvordan strukturerer du en stor app med APIRouter?

Question

IT Interview Practice · Accepted Answer

**`APIRouter`** lader dig opdele en stor FastAPI-app i flere moduler — hver router grupperer relaterede endpoints (f.eks. alle `/users`-ruter), og hovedappen inkluderer dem. Dette holder en voksende kodebasis organiseret og vedligeholdelsesbar.

## Definering af en router i sit eget modul

```python
# routers/users.py
from fastapi import APIRouter

router = APIRouter(
    prefix="/users",          # all routes here start with /users
    tags=["users"],           # grouped under "users" in the docs
)

@router.get("/")              # GET /users/
def list_users(): ...

@router.get("/{user_id}")     # GET /users/{user_id}
def get_user(user_id: int): ...
```

En `APIRouter` fungerer som en mini-app — du definerer path operations på den med de samme dekoratorer, og et `prefix` gælder for alle dem.

## Inklusion af routere i hovedappen

```python
# main.py
from fastapi import FastAPI
from routers import users, items, auth

app = FastAPI()
app.include_router(users.router)     # mounts /users/* endpoints
app.include_router(items.router)
app.include_router(auth.router)
```

`app.include_router()` monterer hver routers endpoints i hovedappen — samler det fulde API fra modulære dele.

## En typisk projektstruktur

```text
app/
  main.py              # creates the app, includes routers
  routers/
    users.py           # APIRouter for /users
    items.py           # APIRouter for /items
    auth.py            # APIRouter for /auth
  models.py            # Pydantic models
  database.py          # DB setup
  dependencies.py      # shared dependencies
```

Hver funktion/domæne får sit eget routermodul — holder relaterede ruter og kodebasen velorganiseret.

## Router-niveau afhængigheder og konfiguration

```python
router = APIRouter(
    prefix="/admin",
    dependencies=[Depends(verify_admin)],   # apply a dependency to ALL routes in the router
)
# you can also nest routers via include_router on a router
```

Routere kan bære delte afhængigheder (f.eks. kræver admin-auth for en hel gruppe af ruter) — anvendt på alle deres endpoints på en gang.

## Hvorfor det er vigtigt

`APIRouter` er væsentlig for at bygge noget ud over en triviel FastAPI-app — uden den ville alle endpoints leve i én fil, hvilket bliver umuligt at håndtere når API'et vokser.

Forståelse heraf er vigtig for **kodorganisering og vedligeholdelsesbarhed**: opdeling af endpoints i feature-baserede routermoduler (brugere, varer, godkendelse) holder relateret kode sammen, gør projektet navigerbar og lader teams arbejde på forskellige områder uafhængigt.

`prefix` og `tags` holder ruter og dokumentation organiseret, og **router-niveau afhængigheder** (som at kræve admin-auth for en hel gruppe) giver rent, gruppevidt adfærd.

Denne modulære struktur er standardpraksis for rigtige FastAPI-applikationer, hvilket gør `APIRouter` og projektorganiseringsmønstre omkring det vigtig, praktisk-essensiel viden for at bygge skalerbare, vedligeholdelsesbare API'er.

Definering af en router i sit eget modul

Inklusion af routere i hovedappen

En typisk projektstruktur

Router-niveau afhængigheder og konfiguration

Hvorfor det er vigtigt

Relaterede spørgsmål