तुम 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 प्रमाणीकरण आवश्यक करणे) — एकाच वेळी त्यांच्या सर्व एंडपॉइंट्सला लागू होते.

## हे महत्वाचे का आहे

`APIRouter` तुच्छ FastAPI अ‍ॅपपेक्षा अधिक कोणतीही गोष्ट तयार करण्यासाठी आवश्यक आहे — त्याशिवाय, सर्व एंडपॉइंट्स एका फाइलमध्ये राहिले असते, जे API वाढत असताना अव्यवस्थापनीय होते.

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

`prefix` आणि `tags` मार्ग आणि दस्तावेज व्यवस्थापित ठेवतात, आणि **राउटर-स्तरीय अवलंबिता** (जसे एकूण गटासाठी admin प्रमाणीकरण आवश्यक करणे) स्वच्छ, गट-व्यापी वर्तन प्रदान करते.

ही मॉड्यूलर रचना वास्तविक FastAPI अनुप्रयोगांसाठी मानक अभ्यास आहे, `APIRouter` आणि त्याभोवतीच्या प्रकल्प-संस्थापन पद्धतीला स्केलेबल, राखणे सुलभ API तयार करण्यासाठी महत्वाचे, व्यावहारिकरित्या आवश्यक ज्ञान बनवते.