તમે 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
```

રાઉટર્સ શેર્ડ ડિપેન્ડન્સીઝ વહન કરી શકે છે (દાખલા તરીકે, માર્ગોના સમગ્ર જૂથ માટે অ્যાડમિન ઓથ આवશ્યક) — તેમના તમામ એન્ડપોઈન્ટ્સ માટે એક જ સમયે લાગુ થાય છે.

## તે શા માટે મહત્વપૂર્ણ છે

`APIRouter` એક તુચ્છ FastAPI એપ્લિકેશન કરતાં વધુ કંઈપણ બનાવવા માટે આવશ્યક છે — તેના વિના, બધા એન્ડપોઈન્ટ્સ એક ફાઇલમાં રહેતા હશે, જે API વધતાં જતાં સંચાલન અશક્ય બન જાય છે.

એને સમજવું **કોડ સંગઠન અને જાળવણીયોગ્યતા** માટે મહત્વપૂર્ણ છે: એન્ડપોઈન્ટ્સને ફીચર-આધારિત રાઉટર મોડ્યુલોમાં વિભાજિત કરવું (ব্যবহારકારી, આઇટમ્સ, ઓથ) સંબંધિત કોડને એક જ સ્થાને રાખે છે, પ્રોજેક્ટને નેવિગેટ કરવાયોગ્ય બનાવે છે, અને ટીમોને વિવિધ ક્ષેત્રોમાં સ્વતંત્ર રીતે કાર્ય કરવા દે છે.

`prefix` અને `tags` માર્ગો અને ડોક્યુમેન્ટેશનને સંગઠિત રાખે છે, અને **રાઉટર-લેવલ ડિપેન્ડન્સીઝ** (જેવું કે સમગ્ર જૂથ માટે અ્yddmin ઓથ આવશ્યક) સ્વચ્છ, જૂથ-વ્યાપી વર્તન પ્રદાન કરે છે.

યો મોડ્યુલર આર્કિટેક્ચર વાસ્તવિક FastAPI એપ્લિકેશનો માટે પ્રમાણભૂત અભ્યાસ છે, જે `APIRouter` અને તેની આસપાસના પ્રોજેક્ટ-સંગઠન પેટર્નને માપનક્ષમ, જાળવણીયોગ્ય APIs બનાવવા માટે મહત્વપૂર્ણ, વ્યવહારિક-આવશ્યક જ્ઞાન બનાવે છે.