request lifecycle ทำงานอย่างไรใน FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI ทำงานบน **ASGI** ดังนั้น request จะเดินทางผ่าน async pipeline: ASGI server รับ request เข้ามา, middleware ห่อหุ้มมัน, router จับคู่ path, **dependencies ถูก resolve**, path operation ของคุณทำงาน, และค่าที่ return จะถูก serialize เป็น response

## ขั้นตอนต่างๆ

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── จับคู่ method + path → path operation
   ▼
Dependencies (Depends)  ── resolve sub-deps, security, yield-setup
   ▼
Path operation function  ── handler ของคุณทำงาน
   ▼
Response model  ── validate + serialize เป็น JSON
   ▼
Background tasks  ── ทำงานหลังจากส่ง response แล้ว
   ▼
Response ──▶ client
```

1. **ASGI server** (uvicorn/hypercorn) รับการเชื่อมต่อและส่ง `scope` พร้อมกับ callable `receive`/`send` ให้กับแอป
2. **Middleware** ทำงานจากนอกเข้าในตอนขาเข้า และจากในออกนอกตอนขาออก (`BaseHTTPMiddleware` หรือ ASGI middleware ล้วน) CORS, GZip และการวัดเวลาแบบกำหนดเองอยู่ตรงนี้
3. **Routing** จับคู่ HTTP method + path เข้ากับ path operation; พารามิเตอร์ path/query/body ถูกดึงออกมาและ validate โดย **Pydantic**
4. **Dependency injection** — `Depends(...)` resolve แต่ละ dependency (DB session, ผู้ใช้ปัจจุบัน, settings) โดย cache ภายใน request หนึ่งๆ dependency ที่ใช้ `yield` จะทำ setup ก่อนและ teardown หลัง handler
5. **Path operation** — `async def` ของคุณ (หรือ `def` ที่รันใน threadpool) ประมวลผล business logic
6. **Response** — ค่าที่ return จะถูกแปลงเป็น `response_model` ที่ประกาศไว้, validate, และ serialize เป็น JSON; status code และ headers จะถูกนำมาใช้
7. **Background tasks** ที่ลงทะเบียนผ่าน `BackgroundTasks` จะทำงาน *หลังจาก* ส่ง 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. serialize ผ่าน response_model
```

ข้อยกเว้น (exceptions) ถูกจับโดย **exception handlers** (`@app.exception_handler(...)` / `HTTPException`) ซึ่งแปลงมันเป็น response แทนที่จะทำให้ request ล่ม

## ทำไมจึงสำคัญ

request lifecycle คือที่ที่ฟีเจอร์เด่นของ FastAPI เกิดขึ้นจริง: async I/O, Pydantic validation และ dependency injection ล้วนเชื่อมเข้ากับขั้นตอนเฉพาะเจาะจง การรู้ลำดับ — middleware, แล้ว routing, แล้ว dependencies, แล้ว handler, แล้ว serialization — ช่วยให้คุณวาง logic แบบ cross-cutting ไว้ในที่ที่ถูกต้อง (auth เป็น dependency, การวัดเวลาเป็น middleware, การ cleanup ใน `yield` dependency), debug ว่าทำไม validation หรือ auth error จึงเกิดก่อนที่โค้ดของคุณจะทำงาน, และหลีกเลี่ยงการ block event loop ภายใน async handler

ขั้นตอนต่างๆ

ทำไมจึงสำคัญ

คำถามที่เกี่ยวข้อง