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) ले connection स्वीकार गर्छ र app लाई एउटा `scope` सँगै `receive`/`send` callables पास गर्छ।
2. **Middleware** भित्र जाँदा बाहिर-देखि-भित्र र बाहिर निस्कँदा भित्र-देखि-बाहिर चल्छ (`BaseHTTPMiddleware` वा शुद्ध ASGI middleware)। CORS, GZip, र custom timing यहाँ बस्छन्।
3. **Routing** ले HTTP method + path लाई एउटा path operation सँग मिलाउँछ; path/query/body params **Pydantic** द्वारा निकालिन्छ र validate हुन्छ।
4. **Dependency injection** — `Depends(...)` ले प्रत्येक dependency (DB session, current user, settings) हल गर्छ, request भित्र cache गर्दै। `yield` भएको dependency ले handler अघि setup र पछि teardown चलाउँछ।
5. **Path operation** — तपाईंको `async def` (वा `def`, threadpool मा चल्ने) ले business logic execute गर्छ।
6. **Response** — return value घोषित गरिएको `response_model` मा coerce हुन्छ, validate हुन्छ, र JSON मा serialize हुन्छ; status code र headers लागू हुन्छन्।
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 हरू **exception handlers** (`@app.exception_handler(...)` / `HTTPException`) द्वारा समातिन्छन्, जसले तिनलाई request क्र्यास गर्नुको सट्टा response मा रूपान्तरण गर्छ।

## यो किन महत्त्वपूर्ण छ

Request lifecycle नै त्यो ठाउँ हो जहाँ FastAPI का प्रमुख विशेषताहरू वास्तवमा घट्छन्: async I/O, Pydantic validation, र dependency injection सबै विशिष्ट चरणहरूमा जोडिन्छन्। क्रम थाहा पाउनु — middleware, त्यसपछि routing, त्यसपछि dependencies, त्यसपछि handler, त्यसपछि serialization — ले तपाईंलाई cross-cutting logic सही ठाउँमा राख्न (auth लाई dependency को रूपमा, timing लाई middleware को रूपमा, cleanup लाई `yield` dependency मा) दिन्छ, तपाईंको code चल्नुअघि नै किन कुनै validation वा auth error आउँछ भनेर debug गर्न दिन्छ, र async handler भित्र event loop block नगर्न मद्दत गर्छ।

चरणहरू

यो किन महत्त्वपूर्ण छ

सम्बन्धित प्रश्नहरू