FastAPI માં request lifecycle કેવી રીતે કામ કરે છે?

Question

IT Interview Practice · Accepted Answer

FastAPI **ASGI** પર ચાલે છે, તેથી એક request એક async pipeline માંથી પસાર થાય છે: ASGI server તેને સ્વીકારે છે, middleware તેને લપેટે છે, router એક path ને મેચ કરે છે, **dependencies ઉકેલાય છે**, તમારું path operation ચાલે છે, અને return value ને response માં serialize કરવામાં આવે છે.

## તબક્કાઓ

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── method + path મેચ કરો → path operation
   ▼
Dependencies (Depends)  ── sub-deps, security, yield-setup ઉકેલો
   ▼
Path operation function  ── તમારો handler ચાલે છે
   ▼
Response model  ── validate + JSON માં serialize કરો
   ▼
Background tasks  ── response મોકલ્યા પછી ચાલે છે
   ▼
Response ──▶ client
```

1. **ASGI server** (uvicorn/hypercorn) connection સ્વીકારે છે અને app ને એક `scope` તથા `receive`/`send` callables પસાર કરે છે.
2. **Middleware** આવતી વખતે બહારથી-અંદર અને જતી વખતે અંદરથી-બહાર ચાલે છે (`BaseHTTPMiddleware` અથવા શુદ્ધ ASGI middleware). CORS, GZip, અને custom timing અહીં રહે છે.
3. **Routing** HTTP method + path ને એક path operation સાથે મેચ કરે છે; path/query/body params ને **Pydantic** દ્વારા કાઢવામાં અને validate કરવામાં આવે છે.
4. **Dependency injection** — `Depends(...)` દરેક dependency (DB session, current user, settings) ને ઉકેલે છે, request ની અંદર caching કરે છે. `yield` વાળી dependency handler પહેલાં setup અને પછી teardown ચલાવે છે.
5. **Path operation** — તમારું `async def` (અથવા `def`, threadpool માં ચાલતું) business logic ને execute કરે છે.
6. **Response** — return value ને જાહેર કરેલ `response_model` માં ફેરવવામાં આવે છે, validate થાય છે, અને JSON માં serialize થાય છે; status code અને headers લાગુ થાય છે.
7. **Background tasks** કે જે `BackgroundTasks` દ્વારા register થયેલ છે તે response મોકલાયા *પછી* ચાલે છે.

```python
from fastapi import FastAPI, Depends, Request

app = FastAPI()

@app.middleware("http")
async def timing(request: Request, call_next):   # 2. middleware
    response = await call_next(request)
    response.headers["X-Time"] = "..."
    return response

async def get_db():                               # 4. dependency (yield)
    db = Session()
    try:
        yield db
    finally:
        db.close()

@app.get("/items/{id}")                           # 3. routing
async def read_item(id: int, db=Depends(get_db)): # 5. handler
    return db.get(Item, id)                        # 6. response_model દ્વારા serialize
```

Exception ને **exception handlers** (`@app.exception_handler(...)` / `HTTPException`) દ્વારા પકડવામાં આવે છે, જે તેમને request ને ક્રેશ કરવાને બદલે responses માં રૂપાંતરિત કરે છે.

## આ શા માટે મહત્વનું છે

Request lifecycle એ છે જ્યાં FastAPI ની મુખ્ય features ખરેખર થાય છે: async I/O, Pydantic validation, અને dependency injection બધા ચોક્કસ તબક્કાઓમાં hook થાય છે. ક્રમ જાણવો — middleware, પછી routing, પછી dependencies, પછી handler, પછી serialization — તમને cross-cutting logic ને યોગ્ય જગ્યાએ મૂકવા દે છે (auth ને dependency તરીકે, timing ને middleware તરીકે, cleanup ને `yield` dependency માં), શા માટે એક validation અથવા auth error તમારા code ચાલે તે પહેલાં fire થાય છે તે debug કરવા દે છે, અને async handler ની અંદર event loop ને block કરવાનું ટાળવા દે છે.

તબક્કાઓ

આ શા માટે મહત્વનું છે

સંબંધિત પ્રશ્નો