Yaya rayuwar request (request lifecycle) ke aiki a FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI na gudana a kan **ASGI**, don haka request na tafiya ta cikin async pipeline: ASGI server na karɓarsa, middleware na naɗe shi, router na daidaita path, sannan **ana warware dependencies**, path operation ɗinka na gudana, sai a serialize ƙimar da aka mayar zuwa cikin response.

## Matakan

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, na musamman)
   ▼
Routing  ── daidaita method + path → path operation
   ▼
Dependencies (Depends)  ── warware sub-deps, security, yield-setup
   ▼
Path operation function  ── handler ɗinka na gudana
   ▼
Response model  ── validate + serialize zuwa JSON
   ▼
Background tasks  ── gudana bayan an aika response
   ▼
Response ──▶ client
```

1. **ASGI server** (uvicorn/hypercorn) na karɓar haɗin sannan ya wuce `scope` da callables ɗin `receive`/`send` zuwa app ɗin.
2. **Middleware** na gudana daga waje-zuwa-ciki lokacin shiga sannan ciki-zuwa-waje lokacin fita (`BaseHTTPMiddleware` ko middleware ɗin ASGI mai tsafta). CORS, GZip, da auna lokaci na musamman na zama a nan.
3. **Routing** na daidaita HTTP method + path zuwa path operation; ana ciro sannan a validate params ɗin path/query/body ta hanyar **Pydantic**.
4. **Dependency injection** — `Depends(...)` na warware kowace dependency (DB session, mai amfani na yanzu, settings), tare da caching cikin request. Dependency mai `yield` na gudanar da setup kafin sannan teardown bayan handler.
5. **Path operation** — `async def` ɗinka (ko `def`, wanda ke gudana cikin threadpool) na aiwatar da business logic.
6. **Response** — ana tilasta ƙimar da aka mayar zuwa `response_model` da aka bayyana, a validate, sannan a serialize zuwa JSON; ana amfani da status code da headers.
7. **Background tasks** da aka rajista ta hanyar `BackgroundTasks` na gudana *bayan* an aika 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. an serialize ta response_model
```

Ana kama exceptions ta hanyar **exception handlers** (`@app.exception_handler(...)` / `HTTPException`), waɗanda ke mayar da su zuwa responses maimakon ɓata request ɗin.

## Me ya sa yake da muhimmanci

Rayuwar request ita ce inda manyan fasalolin FastAPI ke faruwa da gaske: async I/O, Pydantic validation, da dependency injection duk suna haɗawa da takamaiman matakai. Sanin tsarin — middleware, sannan routing, sannan dependencies, sannan handler, sannan serialization — na ba ka damar sanya cross-cutting logic a wurin da ya dace (auth a matsayin dependency, auna lokaci a matsayin middleware, tsaftacewa cikin dependency mai `yield`), da gyara dalilin da ya sa kuskuren validation ko auth ke faruwa kafin code ɗinka ya gudana, da kuma guje wa toshe event loop cikin async handler.

Matakan

Me ya sa yake da muhimmanci

Tambayoyi masu alaƙa