FastAPI ਵਿੱਚ request lifecycle ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ?

Question

IT Interview Practice · Accepted Answer

FastAPI **ASGI** ਉੱਤੇ ਚੱਲਦਾ ਹੈ, ਇਸ ਲਈ ਇੱਕ request ਇੱਕ async pipeline ਵਿੱਚੋਂ ਲੰਘਦਾ ਹੈ: ASGI server ਇਸਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ, middleware ਇਸਨੂੰ ਲਪੇਟਦਾ ਹੈ, router ਇੱਕ path ਨਾਲ ਮੇਲ ਕਰਦਾ ਹੈ, **dependencies 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) 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, ਮੌਜੂਦਾ user, settings) ਨੂੰ resolve ਕਰਦਾ ਹੈ, request ਦੇ ਅੰਦਰ cache ਕਰਦੇ ਹੋਏ। `yield` ਵਾਲੀ ਇੱਕ dependency handler ਤੋਂ ਪਹਿਲਾਂ setup ਅਤੇ ਬਾਅਦ ਵਿੱਚ teardown ਚਲਾਉਂਦੀ ਹੈ।
5. **Path operation** — ਤੁਹਾਡਾ `async def` (ਜਾਂ `def`, ਜੋ ਇੱਕ threadpool ਵਿੱਚ ਚੱਲਦਾ ਹੈ) business logic ਨੂੰ execute ਕਰਦਾ ਹੈ।
6. **Response** — return ਕੀਤੀ value ਨੂੰ ਘੋਸ਼ਿਤ ਕੀਤੇ `response_model` ਵਿੱਚ ਢਾਲਿਆ ਜਾਂਦਾ ਹੈ, 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
```

ਅਪਵਾਦ (Exceptions) ਨੂੰ **exception handlers** (`@app.exception_handler(...)` / `HTTPException`) ਦੁਆਰਾ ਫੜਿਆ ਜਾਂਦਾ ਹੈ, ਜੋ request ਨੂੰ crash ਕਰਨ ਦੀ ਬਜਾਏ ਉਹਨਾਂ ਨੂੰ responses ਵਿੱਚ ਬਦਲ ਦਿੰਦੇ ਹਨ।

## ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

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 ਵਿੱਚ), debug ਕਰਨ ਦਿੰਦਾ ਹੈ ਕਿ ਤੁਹਾਡੇ code ਦੇ ਚੱਲਣ ਤੋਂ ਪਹਿਲਾਂ ਕੋਈ validation ਜਾਂ auth error ਕਿਉਂ ਫਾਇਰ ਹੁੰਦੀ ਹੈ, ਅਤੇ ਇੱਕ async handler ਦੇ ਅੰਦਰ event loop ਨੂੰ block ਕਰਨ ਤੋਂ ਬਚਣ ਦਿੰਦਾ ਹੈ।

ਪੜਾਅ

ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

ਸੰਬੰਧਿਤ ਸਵਾਲ