ทำไม FastAPI ถึงเร็ว และคุณจะรักษาความเร็วนั้นไว้ได้อย่างไร?

Question

Accepted Answer

FastAPI เป็นหนึ่งใน framework ของ Python ที่เร็วที่สุดเพราะมันสร้างบน **Starlette** (ASGI framework ที่เบา) และเป็น **async-native** จัดการ request ที่เป็น I/O-bound จำนวนมากพร้อมกันได้อย่างมีประสิทธิภาพ แต่การรักษาความเร็วต้องใช้ async อย่างถูกต้อง — ความผิดพลาดที่พบบ่อยที่สุดคือการ block event loop

## ทำไมมันถึงเร็ว

```text
✓ ASGI + Starlette — a modern async foundation (vs older WSGI sync frameworks)
✓ Async-native — one process handles thousands of concurrent I/O-bound requests
  by overlapping wait times, instead of one-at-a-time
✓ Pydantic v2 — validation/serialization core is now in Rust (very fast)
✓ Minimal overhead per request
```

โมเดล async คือกุญแจสำคัญ: ขณะที่ request หนึ่ง await query ฐานข้อมูลหรือการเรียก API server จะจัดการตัวอื่น ๆ — ให้ throughput สูงสำหรับงานที่เป็น I/O-bound

## วิธีอันดับ 1 ในการรักษาความเร็ว: อย่า block event loop

```python
# ❌ blocking call inside async def → freezes the event loop, serializing ALL requests
@app.get("/bad")
async def bad():
    return requests.get(url).json()       # SYNC/blocking → kills concurrency

# ✅ use an async client and await it
@app.get("/good")
async def good():
    async with httpx.AsyncClient() as c:
        return (await c.get(url)).json()  # non-blocking

# ✅ OR use a plain def — FastAPI runs it in a thread pool (safe for blocking code)
@app.get("/also-good")
def also_good():
    return requests.get(url).json()
```

นี่คือกฎด้านประสิทธิภาพที่สำคัญที่สุดเพียงข้อเดียว: การเรียกแบบ blocking ภายใน `async def` จะ block event loop ทั้งหมด บังคับให้ requests ทำงานทีละตัว ใช้ async libraries กับ `await` หรือ `def` ธรรมดา (รันใน thread pool)

## การรักษาความเร็ว — checklist

```text
✓ Use async DB drivers / async libraries (httpx, asyncpg) in async endpoints
✓ Run blocking code in plain def (thread pool) or via run_in_executor
✓ Avoid heavy CPU work on the event loop → offload to workers/processes
✓ Add caching (Redis) for expensive repeated work
✓ Optimize the database (fix N+1, add indexes) — often the real bottleneck
✓ Run multiple worker processes (uvicorn/gunicorn workers) to use all CPU cores
✓ Use connection pooling; paginate large results
✓ MEASURE first (profiling, load testing) — fix the actual bottleneck
```

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

ความเร็วของ FastAPI เป็นเหตุผลหลักที่ทีมเลือกใช้มัน แต่การบรรลุความเร็วนั้นในทางปฏิบัติขึ้นอยู่กับ **การใช้ async อย่างถูกต้อง** — และกฎที่สำคัญที่สุดและถูกละเมิดบ่อยที่สุดคือ **อย่า block event loop เด็ดขาด**

การเข้าใจ *ว่าทำไม* FastAPI ถึงเร็ว (รากฐาน ASGI ที่เป็น async-native, I/O concurrency ที่มีประสิทธิภาพ, แกน Pydantic v2 ที่เร็ว) ทำให้ชัดเจนว่าความได้เปรียบด้านประสิทธิภาพของมันใช้กับงานที่เป็น I/O-bound ที่จัดการพร้อมกัน

การรู้วิธี *รักษา* ความเร็วเป็นทักษะในทางปฏิบัติที่สำคัญ: การหลีกเลี่ยงความผิดพลาดร้ายแรงของการใส่การเรียกแบบ blocking ใน `async def` (ซึ่งทำให้ requests ทั้งหมดต่อแถวอยู่หลัง event loop ที่ค้าง), การใช้ async libraries ใน async endpoints (หรือ `def` ธรรมดาสำหรับโค้ด blocking), การ offload งาน CPU, การ caching, การ optimize ฐานข้อมูล (มักเป็น bottleneck ที่แท้จริง) และการรัน workers หลายตัวสำหรับ core หลายตัว

การรวมกันนี้ — การใช้ประโยชน์จาก async อย่างเหมาะสมและการวัดเพื่อหา bottleneck ที่แท้จริง — คือสิ่งที่ทำให้คุณบรรลุศักยภาพด้านประสิทธิภาพของ FastAPI ได้ ทำให้เป็นความรู้ระดับ senior ที่สำคัญสำหรับการสร้าง API ที่เร็วและขยายขนาดได้จริง แทนที่จะเป็นแบบที่ดูเหมือน async แต่ทำงานเหมือนโค้ด blocking