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) కనెక్షన్‌ను స్వీకరించి, ఒక `scope` తో పాటు `receive`/`send` callable లను app కు పంపుతుంది.
2. **Middleware** లోపలికి వెళ్లేటప్పుడు బయటి-నుండి-లోపలికి, బయటికి వచ్చేటప్పుడు లోపలి-నుండి-బయటికి నడుస్తుంది (`BaseHTTPMiddleware` లేదా స్వచ్ఛమైన ASGI middleware). CORS, GZip, మరియు కస్టమ్ టైమింగ్ ఇక్కడ ఉంటాయి.
3. **Routing** HTTP method + path ను ఒక path operation కు సరిపోల్చుతుంది; path/query/body parameter లు **Pydantic** ద్వారా వెలికితీయబడి validate చేయబడతాయి.
4. **Dependency injection** — `Depends(...)` ప్రతి dependency ని (DB session, ప్రస్తుత user, settings) పరిష్కరిస్తుంది, request లోపల cache చేస్తుంది. `yield` ఉన్న ఒక dependency handler కు ముందు setup ను, తర్వాత teardown ను నడుపుతుంది.
5. **Path operation** — మీ `async def` (లేదా threadpool లో నడిచే `def`) 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 ను crash చేయడానికి బదులుగా వాటిని response లుగా మారుస్తాయి.

## ఇది ఎందుకు ముఖ్యం

FastAPI యొక్క ప్రధాన features నిజంగా జరిగే చోటు request lifecycle: async I/O, Pydantic validation, మరియు dependency injection అన్నీ నిర్దిష్ట దశలలో అనుసంధానమవుతాయి. క్రమాన్ని తెలుసుకోవడం — middleware, తర్వాత routing, తర్వాత dependencies, తర్వాత handler, తర్వాత serialization — cross-cutting logic ను సరైన చోట ఉంచడానికి మిమ్మల్ని అనుమతిస్తుంది (auth ను ఒక dependency గా, టైమింగ్ ను middleware గా, cleanup ను `yield` dependency లో), మీ code నడవడానికి ముందు ఒక validation లేదా auth error ఎందుకు ట్రిగ్గర్ అవుతుందో debug చేయడానికి, మరియు ఒక async handler లోపల event loop ను block చేయడాన్ని నివారించడానికి.

దశలు

ఇది ఎందుకు ముఖ్యం

సంబంధిత ప్రశ్నలు