FastAPI में request lifecycle कैसे काम करता है?

Question

IT Interview Practice · Accepted Answer

FastAPI **ASGI** पर चलता है, इसलिए एक request एक async pipeline से होकर गुजरती है: ASGI server इसे स्वीकार करता है, middleware इसे लपेटता है, router एक path को match करता है, **dependencies resolve होती हैं**, आपका path operation चलता है, और return value को response में serialize कर दिया जाता है.

## चरण

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── method + path match करें → 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) connection स्वीकार करता है और app को एक `scope` के साथ `receive`/`send` callables पास करता है.
2. **Middleware** अंदर जाते समय बाहर-से-अंदर और बाहर आते समय अंदर-से-बाहर चलता है (`BaseHTTPMiddleware` या शुद्ध ASGI middleware). CORS, GZip, और custom timing यहाँ रहते हैं.
3. **Routing** HTTP method + path को एक path operation से match करता है; path/query/body params को **Pydantic** द्वारा extract और validate किया जाता है.
4. **Dependency injection** — `Depends(...)` प्रत्येक dependency (DB session, current user, settings) को resolve करता है, request के भीतर caching करते हुए. `yield` वाली dependency handler से पहले setup और बाद में teardown चलाती है.
5. **Path operation** — आपका `async def` (या `def`, जो threadpool में चलता है) business logic को execute करता है.
6. **Response** — return value को घोषित `response_model` में coerce किया जाता है, 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
```

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 में), यह debug करने देता है कि कोई validation या auth error आपके code के चलने से पहले क्यों fire होती है, और async handler के अंदर event loop को block करने से बचने देता है.

चरण

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

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