FastAPI માં middleware કેવી રીતે કાર્ય કરે છે?

Question

Accepted Answer

FastAPI માં **middleware** એ કોડ છે જે **દરેક વિનંતી અને પ્રતિક્રિયા** માટે ચાલે છે — તમારા endpoints ને આવરી રહ્યો છે લોગિંગ, ટાઇમિંગ, CORS, અને હેડર્સ ઉમેરવા જેવી ક્રોસ-કટીંગ સમસ્યાઓ સંભાળવા માટે। FastAPI Starlette ની middleware સિસ્ટમ વાપરે છે (તે 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 ને આહ્વાન કરે છે, અને તેમાંથી પછીનો કોડ રસ્તા **બહાર** ચાલે છે (પ્રતિક્રિયાને સંશોધિત કરે છે). આ દરેક વિનંતીને આવરી રહ્યો છે — અહીં, બધી પ્રતિક્રિયાઓમાં ટાઇમીંગ હેડર ઉમેરવું.

## વિનંતી/પ્રતિક્રિયા પ્રવાહ

```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.
```

## બિલ્ટ-ઇન / સામાન્ય 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 (ક્રોસ-ઓરિજિન વિનંતીઓ સ્વીકારો), GZip (પ્રતિક્રિયાઓ સંકુચિત કરો), અને વિશ્વાસી-હોસ્ટ ચેક સામાન્ય બિલ્ટ-ઇન છે.

## 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 નિર્ભરતા

```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 માં **વૈશ્વિક, ક્રોસ-કટીંગ સમસ્યાઓ** માટે યોગ્ય મંત્ર છે — તર્ક જે દરેક વિનંતી અને પ્રતિક્રિયા પર લાગુ થવો જોઈએ, જેમ કે લોગિંગ, વિનંતી ટાઇમીંગ, CORS, સંકોચન, અને કસ્ટમ હેડર્સ.

તેને સમજવું એપ્લિકેશન્સને યોગ્ય રીતે સંરચવા માટે મહત્વપૂર્ણ છે: middleware બધા endpoints ને આવરી રહ્યો છે (પહેલે અને પછીથી ચાલે છે, બંને વિનંતી અને પ્રતિક્રિયાને સંશોધિત કરવાની ક્ષમતા સાથે), તે એપ્લિકેશન-વ્યાપી વર્તન માટે આદર્શ બનાવે છે જે દરેક endpoint માં પુનરાવર્તન કરવું કંટાળી અને ભૂલ-સંભવ હોત.

**Middleware** (વૈશ્વિક, કાચી વિનંતી/પ્રતિક્રિયા સ્તર) અને **નિર્ભરતા** (પ્રતિ-endpoint, પાર્સ/ટાઇપ કરેલા મૂલ્યો અને DI ની ઍક્સેસ સાથે — auth અને માન્યતા માટે વધુ સારું) વચ્ચે તફાવત જાણવો યોગ્ય સાધન પસંદ કરવા માટે કી છે.

CORS અને સંકોચન જેવી સામાન્ય જરૂરિયાતો બિલ્ટ-ઇન middleware દ્વારા સંભાળવામાં આવે છે, જ્યારે કસ્ટમ middleware લોગિંગ અને ઇન્સ્ટ્રુમેન્ટેશન આવરી રહ્યો છે — આ વ્યવહારિક, વારંવાર-ઉપયોગી જ્ઞાનને સારી રીતે-સંરચિત, અવલોકનીય APIs બાંધવા માટે બનાવે છે.