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-இன் முக்கிய அம்சங்கள் உண்மையில் நிகழும் இடம் request lifecycle தான்: async I/O, Pydantic validation, மற்றும் dependency injection அனைத்தும் குறிப்பிட்ட நிலைகளில் இணைக்கின்றன. வரிசையை அறிவது — middleware, பிறகு routing, பிறகு dependencies, பிறகு handler, பிறகு serialization — குறுக்குவெட்டு logic-ஐ சரியான இடத்தில் வைக்க உதவுகிறது (auth ஒரு dependency ஆக, நேர அளவீடு middleware ஆக, சுத்தம் செய்தல் ஒரு `yield` dependency-இல்), உங்கள் code இயங்குவதற்கு முன் ஒரு validation அல்லது auth பிழை ஏன் தூண்டப்படுகிறது என்பதை debug செய்ய, மற்றும் ஒரு async handler-க்குள் event loop-ஐ block செய்வதைத் தவிர்க்க உதவுகிறது.

நிலைகள்

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

தொடர்புடைய கேள்விகள்