Mzunguko wa maisha wa request unafanyaje kazi katika FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI hufanya kazi kwenye **ASGI**, kwa hivyo request husafiri kupitia pipeline ya async: ASGI server huipokea, middleware huifunika, router hulinganisha path, **dependencies hutatuliwa**, path operation yako huendeshwa, na thamani inayorejeshwa hubadilishwa (serialize) kuwa response.

## Hatua

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── linganisha method + path → path operation
   ▼
Dependencies (Depends)  ── tatua sub-deps, security, yield-setup
   ▼
Path operation function  ── handler yako huendeshwa
   ▼
Response model  ── validate + serialize kwenda JSON
   ▼
Background tasks  ── huendeshwa baada ya response kutumwa
   ▼
Response ──▶ client
```

1. **ASGI server** (uvicorn/hypercorn) hupokea muunganisho na kupitisha `scope` pamoja na callable za `receive`/`send` kwa app.
2. **Middleware** huendeshwa nje-kwenda-ndani wakati wa kuingia na ndani-kwenda-nje wakati wa kutoka (`BaseHTTPMiddleware` au ASGI middleware halisi). CORS, GZip, na upimaji muda maalum viko hapa.
3. **Routing** hulinganisha HTTP method + path na path operation; parameta za path/query/body hutolewa na kuthibitishwa na **Pydantic**.
4. **Dependency injection** — `Depends(...)` hutatua kila dependency (DB session, mtumiaji wa sasa, settings), ikihifadhi cache ndani ya request. Dependency yenye `yield` huendesha setup kabla na teardown baada ya handler.
5. **Path operation** — `async def` yako (au `def`, inayoendeshwa katika threadpool) huendesha mantiki ya biashara.
6. **Response** — thamani inayorejeshwa hulazimishwa kuwa `response_model` iliyotangazwa, huthibitishwa, na kubadilishwa kuwa JSON; status code na headers hutumika.
7. **Background tasks** zilizosajiliwa kupitia `BackgroundTasks` huendeshwa *baada* ya response kutumwa.

```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. serialize kupitia response_model
```

Hitilafu (exceptions) hunaswa na **exception handlers** (`@app.exception_handler(...)` / `HTTPException`), ambazo huzibadilisha kuwa responses badala ya kuanguka kwa request.

## Kwa nini ni muhimu

Mzunguko wa maisha wa request ndipo vipengele muhimu vya FastAPI hutokea kwa kweli: async I/O, uthibitishaji wa Pydantic, na dependency injection vyote hujiunganisha kwenye hatua mahususi. Kujua mpangilio — middleware, kisha routing, kisha dependencies, kisha handler, kisha serialization — hukuruhusu kuweka mantiki inayovuka tabaka mahali pake sahihi (auth kama dependency, upimaji muda kama middleware, usafishaji katika dependency ya `yield`), kutatua kwa nini hitilafu ya validation au auth hutokea kabla ya code yako kuendeshwa, na kuepuka kuzuia event loop ndani ya handler ya async.

Hatua

Kwa nini ni muhimu

Maswali yanayohusiana