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

Question

Accepted Answer

FastAPI में **middleware** वह कोड है जो **प्रत्येक request और response** के लिए चलता है — आपके endpoints को लपेटता है logging, timing, CORS, और headers जोड़ने जैसे cross-cutting concerns को संभालने के लिए। FastAPI Starlette की middleware system का उपयोग करता है (यह ASGI-आधारित है)।

## कस्टम 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 को लपेटता है — यहाँ, सभी responses में एक timing header जोड़ना।

## request/response प्रवाह

```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 / common 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 को compress करना), और 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** के लिए सही तंत्र है — तर्क जो हर request और response पर लागू होना चाहिए, जैसे logging, request timing, CORS, compression, और custom headers।

इसे समझना applications को सही तरीके से structure करने के लिए महत्वपूर्ण है: middleware सभी endpoints को लपेटता है (before और after चलता है, both request और response को modify करने की क्षमता के साथ), इसे app-wide behavior के लिए आदर्श बनाता है जो हर endpoint में दोहराना tedious और error-prone होता।

**Middleware** (global, raw request/response level) और **dependencies** (per-endpoint, parsed/typed values और DI की access के साथ — auth और validation के लिए बेहतर) के बीच अंतर जानना सही tool चुनने के लिए key है।

CORS और compression जैसी आम जरूरतें built-in middleware द्वारा handle की जाती हैं, जबकि custom middleware logging और instrumentation को cover करता है — यह practical, frequently-used knowledge को well-structured, observable APIs बनाने के लिए बनाता है।