Python FastAPI สร้าง API เร็วกว่า Flask 3 เท่า

FastAPI: Python Framework สร้าง API เร็วกว่า Flask 3 เท่า จริงหรือ?

พื้นฐานความรู้ที่ควรรู้ก่อนเริ่มใช้ FastAPI

Async/Await คืออะไร ทำไมถึงสำคัญ?

import asyncio

async def fetch_data(url: str):
    # Simulate network request
    await asyncio.sleep(1)
    return f"Data from {url}"

async def main():
    task1 = asyncio.create_task(fetch_data("https://example.com/data1"))
    task2 = asyncio.create_task(fetch_data("https://example.com/data2"))

    data1 = await task1
    data2 = await task2

    print(data1)
    print(data2)

if __name__ == "__main__":
    asyncio.run(main())

Pydantic คืออะไร ทำไม FastAPI ถึงใช้?

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None

item_data = {
    "name": "Foo",
    "description": "A very nice Item",
    "price": 35.4,
    "tax": 3.2
}

item = Item(**item_data)

print(item.name)
print(item.price)

Dependency Injection คืออะไร ทำไมต้องใช้?

from fastapi import FastAPI, Depends

app = FastAPI()

async def get_db():
    db = "Database Connection"
    try:
        yield db
    finally:
        pass # Cleanup connection

@app.get("/items/")
async def read_items(db: str = Depends(get_db)):
    return {"db": db}

🎬 YouTube @icafefx

ติดตั้งและใช้งาน FastAPI แบบ Step-by-Step

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"Hello": "World"}

@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str | None = None):
    return {"item_id": item_id, "q": q}

เทคนิคขั้นสูง / Configuration

Dependency Injection

from fastapi import FastAPI, Depends

app = FastAPI()

def get_db():
    db = "Database Connection"  # สมมติว่าเป็น database connection
    try:
        yield db
    finally:
        pass # ปิด connection เมื่อใช้งานเสร็จ

@app.get("/items/")
async def read_items(db: str = Depends(get_db)):
    return {"db": db, "items": ["Item 1", "Item 2"]}

Middleware

from fastapi import FastAPI, Request
from starlette.middleware.base import BaseHTTPMiddleware
import time

app = FastAPI()

class TimingMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next):
        start_time = time.time()
        response = await call_next(request)
        process_time = time.time() - start_time
        response.headers["X-Process-Time"] = str(process_time)
        return response

app.add_middleware(TimingMiddleware)

@app.get("/")
async def read_root():
    return {"message": "Hello World"}

Custom Exception Handlers

from fastapi import FastAPI, HTTPException
from fastapi.responses import JSONResponse

app = FastAPI()

class CustomException(Exception):
    def __init__(self, name: str):
        self.name = name

@app.exception_handler(CustomException)
async def custom_exception_handler(request, exc):
    return JSONResponse(
        status_code=418,
        content={"message": f"Oops! {exc.name} did something unexpected."},
    )

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    if item_id == 42:
        raise CustomException(name="Item")
    return {"item_id": item_id}

Configuration Files

DATABASE_URL=postgresql://user:password@host:port/database
API_KEY=your_secret_api_key

from fastapi import FastAPI
from dotenv import load_dotenv
import os

load_dotenv()

app = FastAPI()

DATABASE_URL = os.getenv("DATABASE_URL")
API_KEY = os.getenv("API_KEY")

@app.get("/")
async def read_root():
    return {"database_url": DATABASE_URL, "api_key": API_KEY}

เปรียบเทียบ

ข้อควรระวัง Troubleshooting

"ในการพัฒนา API ด้วย FastAPI สิ่งที่สำคัญที่สุดคือการทำความเข้าใจ async/await อย่างถ่องแท้ หากไม่เข้าใจ concept นี้ อาจทำให้เกิดปัญหา performance หรือ deadlock ได้"

ตัวอย่างจากประสบการณ์ 20 ปี

เครื่องมือแนะนำ

Uvicorn และ Gunicorn

# ติดตั้ง Uvicorn
pip install uvicorn

# รัน FastAPI application ด้วย Uvicorn
uvicorn main:app --reload

Pydantic

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None

SQLAlchemy

from sqlalchemy import create_engine, Column, Integer, String, Float
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

# กำหนด database engine
engine = create_engine("sqlite:///./test.db")
Base = declarative_base()

# Define data model
class Item(Base):
    __tablename__ = "items"

    id = Column(Integer, primary_key=True, index=True)
    name = Column(String)
    description = Column(String)
    price = Column(Float)

pytest

from fastapi.testclient import TestClient
from .main import app

client = TestClient(app)

def test_read_item():
    response = client.get("/items/1")
    assert response.status_code == 200
    assert response.json() == {"item_id": 1, "q": None}

Case Study ประสบการณ์จริง

FAQ คำถามที่พบบ่อย

FastAPI เหมาะกับโปรเจกต์แบบไหน?

FastAPI ต่างจาก Flask อย่างไร? เลือกใช้อะไรดี?

FastAPI รองรับ database อะไรบ้าง?

FastAPI deploy ขึ้น production อย่างไร?

FastAPI มี community support ดีไหม?

FastAPI เรียนรู้ยากไหม?

สรุป

Tips จากประสบการณ์ 20 ปีในการพัฒนา API ด้วย FastAPI

1. ใช้ Dependency Injection ให้เป็นประโยชน์สูงสุด

from fastapi import FastAPI, Depends
from sqlalchemy import create_engine, Session

DATABASE_URL = "sqlite:///./test.db"
engine = create_engine(DATABASE_URL)

def get_db():
    db = Session(engine)
    try:
        yield db
    finally:
        db.close()

app = FastAPI()

@app.get("/items/")
async def read_items(db: Session = Depends(get_db)):
    # Your database query here
    return {"message": "Items retrieved successfully"}

2. Validate Data ด้วย Pydantic อย่างเข้มงวด

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None

@app.post("/items/")
async def create_item(item: Item):
    if item.price <= 0:
        raise HTTPException(status_code=400, detail="Price must be greater than zero")
    return item

3. ใช้ Asynchronous Programming อย่างเหมาะสม

import asyncio
from fastapi import FastAPI

app = FastAPI()

async def slow_operation():
    await asyncio.sleep(2)
    return {"message": "Operation completed after 2 seconds"}

@app.get("/slow_endpoint/")
async def slow_endpoint():
    result = await slow_operation()
    return result

4. จัดการ Errors อย่างมีประสิทธิภาพ

from fastapi import FastAPI, HTTPException
from fastapi.responses import JSONResponse

app = FastAPI()

@app.exception_handler(HTTPException)
async def http_exception_handler(request, exc):
    return JSONResponse(
        status_code=exc.status_code,
        content={"message": exc.detail},
    )

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    if item_id > 100:
        raise HTTPException(status_code=404, detail="Item not found")
    return {"item_id": item_id}

5. Document API ด้วย Swagger UI และ ReDoc

6. Test Code อย่างละเอียด

from fastapi.testclient import TestClient
from .main import app  # Assuming your FastAPI app is in main.py

client = TestClient(app)

def test_read_main():
    response = client.get("/")
    assert response.status_code == 200
    assert response.json() == {"message": "Hello World"}

7. Monitor Performance และ Optimize Code

8. เลือก Database ที่เหมาะสมกับ Use Case

FAQ เกี่ยวกับ FastAPI

H3: FastAPI เหมาะกับ Project ประเภทไหน?

H3: FastAPI ต่างจาก Flask และ Django อย่างไร?

H3: จะ Deploy FastAPI Application ขึ้น Production ได้อย่างไร?

H3: มี Resources อะไรบ้างที่ช่วยให้เรียนรู้ FastAPI ได้เร็วขึ้น?