आप APIRouter के साथ एक बड़े ऐप को कैसे संरचित करते हैं?

Question

Accepted Answer

**`APIRouter`** आपको एक बड़े FastAPI ऐप को कई मॉड्यूल में विभाजित करने देता है — प्रत्येक राउटर संबंधित एंडपॉइंट्स को समूहबद्ध करता है (उदाहरण के लिए, सभी `/users` मार्ग), और मुख्य ऐप उन्हें शामिल करता है। यह एक बढ़ते कोडबेस को संगठित और रखरखाव योग्य रखता है।

## एक राउटर को अपने मॉड्यूल में परिभाषित करना

```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` एक मिनी-ऐप की तरह काम करता है — आप समान डेकोरेटर के साथ इस पर पाथ ऑपरेशन परिभाषित करते हैं, और `prefix` सभी पर लागू होता है।

## मुख्य ऐप में राउटर शामिल करना

```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()` प्रत्येक राउटर के एंडपॉइंट्स को मुख्य ऐप में माउंट करता है — मॉड्यूलर टुकड़ों से पूर्ण 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
```

प्रत्येक फीचर/डोमेन को अपना राउटर मॉड्यूल मिलता है — संबंधित मार्गों को रखता है, और कोडबेस को अच्छी तरह से संगठित रखता है।

## राउटर-स्तरीय निर्भरता और कॉन्फ़िगरेशन

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

राउटर साझा निर्भरताओं को ले सकते हैं (उदाहरण के लिए, मार्गों के पूरे समूह के लिए admin auth आवश्यक) — उनके सभी एंडपॉइंट्स पर एक साथ लागू होते हैं।

## यह क्यों महत्वपूर्ण है

`APIRouter` एक साधारण FastAPI ऐप से अधिक कुछ भी बनाने के लिए आवश्यक है — इसके बिना, सभी एंडपॉइंट्स एक फ़ाइल में रहते, जो API बढ़ने के साथ प्रबंधन योग्य नहीं रहता।

इसे समझना **कोड संगठन और रखरखाव योग्यता** के लिए महत्वपूर्ण है: एंडपॉइंट्स को फीचर-आधारित राउटर मॉड्यूल में विभाजित करना (उपयोगकर्ता, आइटम, auth) संबंधित कोड को एक साथ रखता है, प्रोजेक्ट को नेविगेट करने योग्य बनाता है, और टीमों को विभिन्न क्षेत्रों में स्वतंत्र रूप से काम करने देता है।

`prefix` और `tags` मार्गों और डॉक्यूमेंटेशन को संगठित रखते हैं, और **राउटर-स्तरीय निर्भरताएं** (जैसे पूरे समूह के लिए admin auth की आवश्यकता) स्वच्छ, समूह-व्यापी व्यवहार प्रदान करते हैं।

यह मॉड्यूलर संरचना वास्तविक FastAPI एप्लिकेशन के लिए मानक अभ्यास है, जो `APIRouter` और इसके आसपास की परियोजना-संगठन पैटर्न को स्केलेबल, रखरखाव योग्य APIs बनाने के लिए महत्वपूर्ण, व्यावहारिक-आवश्यक ज्ञान बनाता है।