Hvordan strukturerer du en stor app med APIRouter?

Question

Accepted Answer

**`APIRouter`** lar deg dele en stor FastAPI-app opp i flere moduler — hver router grupperer relaterte endepunkter (f.eks. alle `/users`-ruter), og hovedappen inkluderer dem. Dette holder en voksende kodebase organisert og vedlikeholdbar.

## Definere en router i sin egen 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 dekoratørene, og en `prefix` brukes på alle dem.

## Inkludere 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 endepunkter inn i hovedappen — og setter sammen hele API-et fra modulære biter.

## En typisk prosjektstruktur

```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 funksjon/domene får sin egen router-modul — som holder relaterte ruter, og kodebasen, velorganisert.

## Router-nivå avhengigheter og konfigurasjon

```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 ha delte avhengigheter (f.eks. krever admin-autentisering for en helt gruppe med ruter) — brukt på alle deres endepunkter samtidig.

## Hvorfor det er viktig

`APIRouter` er essensielt for å bygge noe utover en triviell FastAPI-app — uten det ville alle endepunkter bo i én fil, noe som blir uoverkommelig når API-et vokser.

Å forstå det er viktig for **kodeorganisering og vedlikeholdbarhet**: å dele endepunkter inn i funksjon-baserte router-moduler (users, items, auth) holder relatert kode sammen, gjør prosjektet navigerbart, og lar team jobbe på ulike områder uavhengig.

`prefix` og `tags` holder ruter og dokumentasjon organisert, og **router-nivå avhengigheter** (som å kreve admin-autentisering for en helt gruppe) gir ren, gruppe-bred atferd.

Denne modulære strukturen er standard praksis for sanntids FastAPI-applikasjoner, noe som gjør `APIRouter` og prosjektorganiserings-mønstrene rundt det viktig, praktisk-essensielt kunnskap for å bygge skalerbare, vedlikeholdbare API-er.