Vòng đời của một request trong FastAPI hoạt động như thế nào?

Question

IT Interview Practice · Accepted Answer

FastAPI chạy trên **ASGI**, nên một request đi qua một pipeline bất đồng bộ: ASGI server tiếp nhận, middleware bao quanh, router khớp path, **các dependency được giải quyết**, hàm path operation của bạn chạy, và giá trị trả về được serialize thành response.

## Các giai đoạn

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── khớp method + path → path operation
   ▼
Dependencies (Depends)  ── giải sub-deps, security, yield-setup
   ▼
Path operation function  ── handler của bạn chạy
   ▼
Response model  ── validate + serialize sang JSON
   ▼
Background tasks  ── chạy sau khi response đã gửi
   ▼
Response ──▶ client
```

1. **ASGI server** (uvicorn/hypercorn) tiếp nhận kết nối và truyền một `scope` cùng hai callable `receive`/`send` cho app.
2. **Middleware** chạy ngoài-vào lúc đi vào và trong-ra lúc đi ra (`BaseHTTPMiddleware` hoặc ASGI middleware thuần). CORS, GZip, và đo thời gian tùy biến nằm ở đây.
3. **Routing** khớp HTTP method + path tới một path operation; tham số path/query/body được trích và validate bởi **Pydantic**.
4. **Dependency injection** — `Depends(...)` giải từng dependency (DB session, user hiện tại, settings), có cache trong phạm vi request. Một dependency dùng `yield` chạy phần setup trước và teardown sau handler.
5. **Path operation** — `async def` (hoặc `def`, chạy trong threadpool) của bạn thực thi logic nghiệp vụ.
6. **Response** — giá trị trả về được ép về `response_model` đã khai báo, validate, và serialize thành JSON; status code và headers được áp.
7. **Background tasks** đăng ký qua `BackgroundTasks` chạy *sau* khi response đã gửi.

```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 qua response_model
```

Ngoại lệ được bắt bởi **exception handler** (`@app.exception_handler(...)` / `HTTPException`), biến chúng thành response thay vì làm sập request.

## Tại sao điều này quan trọng

Vòng đời request chính là nơi các tính năng chủ đạo của FastAPI thực sự diễn ra: I/O bất đồng bộ, validate bằng Pydantic, và dependency injection đều móc vào những giai đoạn cụ thể. Biết thứ tự — middleware, rồi routing, rồi dependencies, rồi handler, rồi serialization — cho phép bạn đặt logic xuyên suốt đúng chỗ (auth là một dependency, đo thời gian là middleware, dọn dẹp trong dependency `yield`), gỡ lỗi vì sao một lỗi validate hay auth kích hoạt trước cả code của bạn, và tránh chặn event loop bên trong một handler async.

Các giai đoạn

Tại sao điều này quan trọng

Câu hỏi liên quan