FastAPI-இல் middleware எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

FastAPI-இல் **Middleware** என்பது **ஒவ்வொரு request மற்றும் response-க்கும்** இயங்கும் code — logging, timing, CORS, மற்றும் headers சேர்த்தல் போன்ற cross-cutting concerns-ஐ கையாள உங்கள் endpoints-ஐ சுற்றுகிறது. FastAPI, Starlette-இன் middleware அமைப்பைப் பயன்படுத்துகிறது (இது ASGI-அடிப்படையிலானது).

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

pattern: `await call_next(request)`-க்கு முந்தைய code உள்ளே **செல்லும்** வழியில் இயங்குகிறது (endpoint-க்கு முன்), `call_next` endpoint-ஐ invoke செய்கிறது, மற்றும் அதற்குப் பிந்தைய code **வெளியே** செல்லும் வழியில் இயங்குகிறது (response-ஐ modify செய்கிறது). இது ஒவ்வொரு request-ஐயும் சுற்றுகிறது — இங்கே, எல்லா 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.
```

## உள்ளமைந்த / பொதுவான 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.
```

## இது ஏன் முக்கியம்

FastAPI-இல் **global, cross-cutting concerns**-க்கான சரியான பொறிமுறை middleware ஆகும் — logging, request timing, CORS, compression, மற்றும் custom headers போன்ற ஒவ்வொரு request மற்றும் response-க்கும் பொருந்த வேண்டிய logic.

இதைப் புரிந்துகொள்வது applications-ஐ சரியாக structure செய்வதற்கு முக்கியமானது: middleware எல்லா endpoints-ஐயும் சுற்றுகிறது (முன்பும் பின்பும் இயங்கி, request மற்றும் response இரண்டையும் modify செய்யும் திறனுடன்), இது ஒவ்வொரு endpoint-இலும் மீண்டும் செய்ய சலிப்பானதாகவும் பிழைக்கு உள்ளாகக்கூடியதாகவும் இருக்கும் app-wide behavior-க்கு ஏற்றதாக ஆக்குகிறது.

**middleware** (global, raw request/response level) மற்றும் **dependencies** (per-endpoint, parsed/typed values மற்றும் DI-க்கான அணுகலுடன் — auth மற்றும் validation-க்கு சிறந்தது) ஆகியவற்றுக்கு இடையேயான வேறுபாட்டை அறிந்திருப்பது சரியான கருவியைத் தேர்ந்தெடுப்பதற்கு முக்கியமானது.

CORS மற்றும் compression போன்ற பொதுவான தேவைகள் built-in middleware-ஆல் கையாளப்படுகின்றன, அதே சமயம் custom middleware logging மற்றும் instrumentation-ஐ உள்ளடக்குகிறது — இது நன்கு structure செய்யப்பட்ட, observable APIs-ஐ உருவாக்குவதற்கான நடைமுறை, அடிக்கடி பயன்படுத்தப்படும் அறிவாக மாற்றுகிறது.