FastAPI లో middleware ఎలా పని చేస్తుంది?

Question

Accepted Answer

**Middleware** in FastAPI అనేది **ప్రతి request మరియు response** కోసం నడిచే కోడ్ — మీ endpoints లను logging, timing, CORS, మరియు headers జోడించడం వంటి cross-cutting concerns నిర్వహించడానికి wrap చేస్తుంది. FastAPI Starlette యొక్క middleware system ను ఉపయోగిస్తుంది (ఇది ASGI-based).

## Custom middleware రాయడం

```python
import time

@app.middleware("http")
async def add_timing(request: Request, call_next):
    start = time.time()
    response = await call_next(request)        # call the endpoint (and any inner middleware)
    response.headers["X-Process-Time"] = str(time.time() - start)   # modify the response
    return response
```

ప్యాటర్న్: `await call_next(request)` కు ముందున్న కోడ్ **ఇన్‌సైడ్** (endpoint కు ముందు) నడుస్తుంది, `call_next` endpoint ను invoke చేస్తుంది, మరియు తర్వాత కోడ్ **బయటకు** (response ని modify చేస్తూ) నడుస్తుంది. ఇది ప్రతి request ను wrap చేస్తుంది — ఇక్కడ, అన్ని responses కు timing header జోడిస్తూ.

## Request/response flow

```text
Request  → MW1 → MW2 → endpoint
Response ← MW1 ← MW2 ← endpoint
Middleware wraps the endpoint; runs in order on the way in, reverse on the way out.
```

## Built-in / సాధారణ middleware

```python
from fastapi.middleware.cors import CORSMiddleware
from fastapi.middleware.gzip import GZipMiddleware

app.add_middleware(CORSMiddleware, allow_origins=["https://app.example.com"], ...)  # CORS
app.add_middleware(GZipMiddleware, minimum_size=1000)                               # compression
```

Middleware సాధారణంగా `add_middleware` ద్వారా జోడించబడుతుంది — CORS (cross-origin requests అనుమతించండి), GZip (responses కంప్రెస్ చేయండి), మరియు trusted-host checks సాధారణ built-ins.

## Middleware యొక్క సాధారణ ఉపయోగాలు

```text
✓ Logging / request timing / metrics
✓ CORS (cross-origin request handling)
✓ Adding security or custom headers
✓ Response compression (GZip)
✓ Request ID / correlation ID injection
```

## Middleware vs dependencies

```text
Middleware   → runs for ALL requests; works at the raw request/response level (headers,
               timing, the whole response). Best for truly global concerns.
Dependencies → per-endpoint (or grouped) logic with access to parsed params, DI, and
               typed values. Best for auth, validation, shared parameters.
→ Use middleware for global cross-cutting concerns; dependencies for endpoint logic.
```

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

Middleware FastAPI లో **global, cross-cutting concerns** కోసం సరైన mechanism — logging, request timing, CORS, compression, మరియు custom headers వంటి ప్రతి request మరియు response కు వర్తించే logic.

ఇది అర్థం చేసుకోవడం applications ను సరిగ్గా నిర్మించడానికి ముఖ్యమైనది: middleware అన్ని endpoints ను wrap చేస్తుంది (ముందు మరియు తర్వాత నడుస్తూ, request మరియు response రెండింటినీ modify చేసే సామర్థ్యం కలిగి), ఇది app-wide behavior కోసం ఆదర్శమైనది, ఇది ప్రతి endpoint లో పునరావృత్తి చేయడానికి దుర్లభమైన మరియు error-prone గా ఉంటుంది.

**Middleware** (global, raw request/response level) మరియు **dependencies** (per-endpoint, parsed/typed values మరియు DI కు access కలిగి — auth మరియు validation కోసం మెరుగైనది) మధ్య తేడాను తెలుసుకోవడం సరైన tool ఎంచుకోవడానికి కీలకమైనది.

CORS మరియు compression వంటి సాధారణ needs built-in middleware ద్వారా నిర్వహించబడతాయి, custom middleware logging మరియు instrumentation ను కవర్ చేస్తుంది — ఇది well-structured, observable APIs నిర్మించడానికి ఆచరణాత్మక, frequently-used జ్ఞానం.