Hur strukturerar du en stor app med APIRouter?

Question

IT Interview Practice · Accepted Answer

**`APIRouter`** låter dig dela upp en stor FastAPI-app i flera moduler — varje router grupperar relaterade endpoints (t.ex. alla `/users`-rutter), och huvudappen inkluderar dem. Detta håller en växande kodbas organiserad och underhållbar.

## Definiera 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` fungerar som en mini-app — du definierar path operations på den med samma decorators, och ett `prefix` appliceras på alla.

## Inkludera routers i huvudappen

```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()` monterar varje routers endpoints i huvudappen — och sätter ihop hela API:et från modulära delar.

## 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
```

Varje feature/domän får sin egen routermodul — vilket håller relaterade rutter och koden väl organiserad.

## Routernivå-beroenden och 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
```

Routrar kan bära gemensamma beroenden (t.ex. kräva adminauth för en hel grupp av rutter) — applicerad på alla deras endpoints på en gång.

## Varför det spelar roll

`APIRouter` är essentiell för att bygga något mer än en trivial FastAPI-app — utan den skulle alla endpoints bo i en fil, vilket blir omöjligt att hantera när API:et växer.

Att förstå det är viktigt för **kodorganisation och underhållbarhet**: att dela upp endpoints i funktionsbaserade routermoduler (users, items, auth) håller relaterad kod tillsammans, gör projektet navigerbar, och låter team arbeta på olika områden oberoende.

`prefix` och `tags` håller rutter och dokumentation organiserade, och **routernivå-beroenden** (som att kräva adminauth för en hel grupp) tillhandahåller rent, gruppomfattande beteende.

Denna modulär struktur är standardpraxis för verkliga FastAPI-applikationer, vilket gör `APIRouter` och projektorganisationsmönstren runt det till viktigt, praktiskt-essentiell kunskap för att bygga skalbara, underhållbara API:er.

Definiera en router i sin egen modul

Inkludera routers i huvudappen

En typisk projektstruktur

Routernivå-beroenden och konfiguration

Varför det spelar roll

Relaterade frågor