FastAPI-তে request lifecycle কীভাবে কাজ করে?

Question

IT Interview Practice · Accepted Answer

FastAPI **ASGI**-এর উপর চলে, তাই একটি request একটি async pipeline-এর মধ্য দিয়ে যায়: ASGI server এটি গ্রহণ করে, middleware এটিকে মুড়ে দেয়, router একটি path মেলায়, **dependency-গুলি resolve হয়**, আপনার 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 resolve করে
   ▼
Path operation function  ── আপনার handler চলে
   ▼
Response model  ── validate + JSON-এ serialize
   ▼
Background tasks  ── response পাঠানোর পরে চলে
   ▼
Response ──▶ client
```

1. **ASGI server** (uvicorn/hypercorn) সংযোগ গ্রহণ করে এবং app-কে একটি `scope` ও `receive`/`send` callable পাঠায়।
2. **Middleware** ঢোকার সময় বাইরে-থেকে-ভিতরে এবং বেরোনোর সময় ভিতরে-থেকে-বাইরে চলে (`BaseHTTPMiddleware` বা বিশুদ্ধ ASGI middleware)। CORS, GZip, এবং custom timing এখানে থাকে।
3. **Routing** HTTP method + path-কে একটি path operation-এর সাথে মেলায়; path/query/body param গুলি **Pydantic** দ্বারা extract ও validate হয়।
4. **Dependency injection** — `Depends(...)` প্রতিটি dependency (DB session, current user, settings) resolve করে, request-এর মধ্যে cache করে। `yield` সহ একটি dependency handler-এর আগে setup ও পরে teardown চালায়।
5. **Path operation** — আপনার `async def` (বা `def`, একটি threadpool-এ চলে) business logic চালায়।
6. **Response** — return value ঘোষিত `response_model`-এ coerce হয়, validate হয়, এবং JSON-এ serialize হয়; status code ও header প্রয়োগ হয়।
7. **Background tasks** যা `BackgroundTasks`-এর মাধ্যমে register করা হয়, 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
```

**exception handler** (`@app.exception_handler(...)` / `HTTPException`) দ্বারা exception ধরা হয়, যা request ক্র্যাশ করানোর বদলে সেগুলিকে response-এ রূপান্তর করে।

## এটি কেন গুরুত্বপূর্ণ

request lifecycle হলো সেই জায়গা যেখানে FastAPI-এর প্রধান feature-গুলি আসলে ঘটে: async I/O, Pydantic validation, এবং dependency injection সবই নির্দিষ্ট ধাপে hook করে। ক্রমটি জানা — middleware, তারপর routing, তারপর dependency, তারপর handler, তারপর serialization — আপনাকে cross-cutting logic সঠিক জায়গায় রাখতে দেয় (auth একটি dependency হিসেবে, timing middleware হিসেবে, cleanup একটি `yield` dependency-তে), কেন একটি validation বা auth error আপনার code চলার আগেই ঘটে তা debug করতে, এবং একটি async handler-এর ভিতরে event loop block করা এড়াতে দেয়।

ধাপগুলি

এটি কেন গুরুত্বপূর্ণ

সম্পর্কিত প্রশ্ন