FastAPI मध्ये request lifecycle कसे काम करते?

Question

IT Interview Practice · Accepted Answer

FastAPI **ASGI** वर चालते, त्यामुळे request एका async pipeline मधून प्रवास करते: ASGI server ते स्वीकारतो, middleware ते गुंडाळते, router एका path शी जुळवतो, **dependencies resolve केल्या जातात**, तुमचे 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 resolve करा
   ▼
Path operation function  ── तुमचा handler चालतो
   ▼
Response model  ── validate + JSON मध्ये serialize
   ▼
Background tasks  ── response पाठवल्यानंतर चालतात
   ▼
Response ──▶ client
```

1. **ASGI server** (uvicorn/hypercorn) कनेक्शन स्वीकारतो आणि 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 resolve करते (DB session, current user, settings), request च्या आत caching करत. `yield` असलेली dependency handler आधी setup आणि नंतर teardown चालवते.
5. **Path operation** — तुमचे `async def` (किंवा `def`, threadpool मध्ये चालणारे) business logic कार्यान्वित करते.
6. **Response** — return value घोषित केलेल्या `response_model` मध्ये रूपांतरित, validate, आणि JSON मध्ये serialize केली जाते; status code आणि headers लावले जातात.
7. **Background tasks** जे `BackgroundTasks` द्वारे नोंदवले जातात ते 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
```

Exceptions **exception handlers** (`@app.exception_handler(...)` / `HTTPException`) द्वारे पकडले जातात, जे request क्रॅश करण्याऐवजी त्यांना responses मध्ये रूपांतरित करतात.

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

Request lifecycle हेच ठिकाण आहे जिथे FastAPI ची प्रमुख वैशिष्ट्ये प्रत्यक्षात घडतात: async I/O, Pydantic validation, आणि dependency injection हे सर्व विशिष्ट टप्प्यांना hook होतात. क्रम जाणून घेणे — आधी middleware, मग routing, मग dependencies, मग handler, मग serialization — तुम्हाला cross-cutting logic योग्य ठिकाणी ठेवू देते (auth ला dependency म्हणून, timing ला middleware म्हणून, cleanup ला `yield` dependency मध्ये), तुमचा code चालण्याआधी validation किंवा auth error का उडते हे debug करू देते, आणि async handler मध्ये event loop block होणे टाळू देते.

टप्पे

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

संबंधित प्रश्न