APIRouter ఉపయోగించి పెద్ద యాప్‌ను ఎలా నిర్మిస్తారు?

Question

Accepted Answer

**`APIRouter`** ఒక పెద్ద FastAPI యాప్‌ను బహుళ మాడ్యూల్‌లుగా విభజించడానికి మిమ్మల్ని అనుమతిస్తుంది — ప్రతిটి రౌటర్ సంబంధిత endpoints లను సమూహం చేస్తుంది (ఉదా. అన్ని `/users` మార్గాలు), మరియు main యాప్ వాటిని చేర్చుకుంటుంది. ఇది పెరుగుతున్న codebase ను నిర్వహణీయంగా సংఘటితం చేస్తుంది.

## మాడ్యూల్‌లో రౌటర్‌ను నిర్వచించడం

```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): ...
```

ఒక `APIRouter` mini-app లాగా పనిచేస్తుంది — మీరు దానిపై path operations లను same decorators తో నిర్వచిస్తారు, మరియు `prefix` వాటి అన్నింటికి వర్తిస్తుంది.

## Main యాప్‌లో రౌటర్‌లను చేర్చడం

```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()` ప్రతిটి రౌటర్ యొక్క endpoints లను main యాప్‌లో mount చేస్తుంది — మాడ్యూలర్ భాగాల నుండి full API ని సమీకరిస్తుంది.

## సాధారణ ప్రాజెక్ట్ నిర్మాణం

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

ప్రతిটి feature/domain దానికదే router module పొందుతుంది — సంబంధిత routes లను, మరియు codebase ను, well-organized గా ఉంచుతుంది.

## రౌటర్-స్థరీయ dependencies మరియు config

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

రౌటర్‌లు shared dependencies లను కలిగి ఉండవచ్చు (ఉదా. routes యొక్క సమগ్ర సమూహం కోసం admin auth అవసరం) — ఒకసారిగా వాటి అన్ని endpoints కు వర్తిస్తుంది.

## ఇది ఎందుకు ముఖ్యమైనది

`APIRouter` trivial FastAPI యాప్‌ను అంతకుమించిన ఏదైనా నిర్మించడానికి అవసరమైనది — దానిలేకుండా, అన్ని endpoints ఒక ఫైల్‌లో ఉండవలసి ఉంటుంది, ఇది API పెరిగేకొద్దీ నిర్వహణీయం కాదు.

దీన్ని అర్థం చేసుకోవడం **code organization మరియు maintainability** కోసం ముఖ్యమైనది: endpoints లను feature-based router modules (users, items, auth) లో విభజించడం సంబంధిత code ని ఒకచోట ఉంచుతుంది, ప్రాజెక్ట్‌ను నావిగేట్ చేయదగినదిగా చేస్తుంది, మరియు teams విభిన్న అంశాలపై స్వతంత్రంగా పని చేయనివ్వుతుంది.

`prefix` మరియు `tags` routes లను మరియు documentation ని organized గా ఉంచుతాయి, మరియు **router-level dependencies** (ఒక సమూహం కోసం admin auth అవసరమైనవి) clean, group-wide behavior ను అందిస్తాయి.

ఈ modular structure real FastAPI applications కోసం standard practice, `APIRouter` మరియు దానికి చుట్టూ ఉన్న project-organization patterns లను scalable, maintainable APIs నిర్మించడానికి ముఖ్యమైన, practically-essential knowledge గా చేస్తుంది.