Home » วิธีสร้าง REST API ด้วย FastAPI Python แบบครบจบ
ไม่มีหมวดหมู่

วิธีสร้าง REST API ด้วย FastAPI Python แบบครบจบ

March 16, 2026
0 Views

สวัสดีครับ! ในยุคที่แอปพลิเคชันและบริการต่าง ๆ เชื่อมโยงกันอย่างแยกไม่ออก การสร้าง API (Application Programming Interface) ที่มีประสิทธิภาพและเชื่อถือได้จึงเป็นหัวใจสำคัญของการพัฒนาซอฟต์แวร์ และเมื่อพูดถึงการสร้าง API ที่ทันสมัย รวดเร็ว และใช้งานง่าย ไม่มีเครื่องมือใดจะโดดเด่นไปกว่า FastAPI ที่ทำงานบนภาษา Python อีกแล้วครับ

บทความนี้จะนำพาทุกท่านดำดิ่งสู่โลกของการสร้าง REST API ด้วย FastAPI ตั้งแต่พื้นฐานไปจนถึงระดับแอดวานซ์ โดยละเอียดและครบถ้วน เพื่อให้คุณสามารถสร้าง API ที่พร้อมใช้งานจริงได้อย่างมั่นใจ ไม่ว่าคุณจะเป็นนักพัฒนาที่เพิ่งเริ่มต้น หรือมีประสบการณ์มาบ้างแล้ว บทความนี้จะมอบความรู้และตัวอย่างโค้ดที่ใช้งานได้จริง เพื่อให้คุณเข้าใจและนำไปประยุกต์ใช้ได้ทันทีครับ

พร้อมแล้วหรือยังครับ? มาเริ่มต้นการเดินทางสู่การเป็นผู้เชี่ยวชาญ FastAPI ด้วยกันเลย!

สารบัญ

ทำความเข้าใจ REST API คืออะไร?

ก่อนที่เราจะลงมือสร้าง API ด้วย FastAPI เรามาทำความเข้าใจพื้นฐานของ REST API กันก่อนนะครับ REST ย่อมาจาก Representational State Transfer เป็นสถาปัตยกรรม (Architectural Style) สำหรับการออกแบบระบบเครือข่ายที่ไร้สถานะ (Stateless) และปรับขนาดได้ง่ายครับ

หัวใจสำคัญของ REST API คือการมองทุกสิ่งเป็น “ทรัพยากร” (Resource) เช่น ผู้ใช้, สินค้า, หรือคำสั่งซื้อ และเข้าถึงทรัพยากรเหล่านี้ผ่าน URL ที่เป็นมาตรฐาน (Uniform Resource Locators – URLs) โดยใช้ HTTP Methods ทั่วไปในการดำเนินการกับทรัพยากรเหล่านั้นครับ

  • ทรัพยากร (Resources): สิ่งที่เราต้องการจัดการ เช่น /users, /products/123
  • HTTP Methods: กริยาที่ใช้ในการดำเนินการกับทรัพยากร
    • GET: ดึงข้อมูลทรัพยากร
    • POST: สร้างทรัพยากรใหม่
    • PUT: อัปเดตข้อมูลทรัพยากรที่มีอยู่ทั้งหมด
    • PATCH: อัปเดตข้อมูลทรัพยากรบางส่วน
    • DELETE: ลบทรัพยากร
  • Statelessness: แต่ละคำขอ (Request) จากไคลเอนต์ไปยังเซิร์ฟเวอร์จะต้องมีข้อมูลที่จำเป็นทั้งหมดในการประมวลผลคำขอ โดยที่เซิร์ฟเวอร์ไม่จำเป็นต้องจำสถานะของไคลเอนต์จากการร้องขอครั้งก่อน ๆ ครับ
  • Status Codes: รหัสสถานะ HTTP (เช่น 200 OK, 201 Created, 404 Not Found, 500 Internal Server Error) เพื่อบ่งบอกผลลัพธ์ของการดำเนินการครับ

ทำไมต้อง FastAPI?

ในบรรดา Python Web Frameworks มากมาย ทำไม FastAPI ถึงได้รับความนิยมอย่างรวดเร็ว และกลายเป็นตัวเลือกอันดับต้น ๆ สำหรับการสร้าง API ในปัจจุบัน? คำตอบคือคุณสมบัติที่โดดเด่นและทันสมัยของมันครับ

คุณสมบัติเด่นของ FastAPI

FastAPI มาพร้อมกับคุณสมบัติที่ทำให้การพัฒนา API รวดเร็ว มีประสิทธิภาพ และมีความสุขยิ่งขึ้นครับ

  • ประสิทธิภาพสูง (High Performance): FastAPI สร้างขึ้นบน Starlette (สำหรับเว็บ) และ Pydantic (สำหรับการจัดการข้อมูล) ซึ่งเป็นไลบรารีที่รวดเร็วและมีประสิทธิภาพสูง ทำให้ FastAPI สามารถจัดการคำขอจำนวนมากได้ดีเยี่ยม โดยมีประสิทธิภาพเทียบเท่ากับ Node.js และ Go เลยทีเดียวครับ
  • ใช้งานง่ายและเรียนรู้เร็ว (Easy to Use & Fast to Code): ด้วยการใช้ Python Type Hints ทำให้โค้ดกระชับ อ่านง่าย และลดความผิดพลาดในการเขียนโค้ดได้อย่างมากครับ
  • การตรวจสอบข้อมูลอัตโนมัติ (Automatic Data Validation): Pydantic ช่วยให้คุณสามารถกำหนดรูปแบบข้อมูลได้อย่างง่ายดาย และ FastAPI จะทำการตรวจสอบข้อมูล (validate) ที่เข้ามาใน API โดยอัตโนมัติ หากข้อมูลไม่ตรงตามรูปแบบที่กำหนด มันจะส่งข้อผิดพลาดที่ชัดเจนกลับไปให้ไคลเอนต์ทันทีครับ
  • สร้างเอกสาร API อัตโนมัติ (Automatic API Documentation): นี่คือหนึ่งในคุณสมบัติที่น่าทึ่งที่สุด! FastAPI สร้างเอกสาร API แบบอินเทอร์แอคทีฟ (Interactive API Documentation) ในรูปแบบของ OpenAPI (Swagger UI) และ ReDoc ให้โดยอัตโนมัติ เพียงแค่เข้าถึง /docs หรือ /redoc ของ API คุณก็จะเห็นเอกสารที่สมบูรณ์แบบพร้อมสำหรับการทดสอบ API ได้ทันทีครับ
  • รองรับ Async/Await (Asynchronous Support): FastAPI รองรับการทำงานแบบ Asynchronous (async/await) เต็มรูปแบบ ทำให้สามารถจัดการ I/O-bound operations เช่น การอ่าน/เขียนฐานข้อมูล หรือการเรียก External API ได้อย่างมีประสิทธิภาพ โดยไม่บล็อกการทำงานหลักของแอปพลิเคชันครับ
  • Dependency Injection System: ระบบการจัดการ Dependency ที่ทรงพลัง ทำให้การจัดการส่วนประกอบต่าง ๆ ของ API เช่น การเชื่อมต่อฐานข้อมูล, การตรวจสอบสิทธิ์, หรือการดึงค่าจาก Header เป็นเรื่องง่ายและนำกลับมาใช้ใหม่ได้ครับ
  • ความปลอดภัย (Security): มีเครื่องมือและความสามารถในการจัดการความปลอดภัยที่หลากหลาย เช่น OAuth2, JWT, HTTP Basic Auth ที่สร้างมาให้พร้อมใช้งานครับ

FastAPI vs. Frameworks อื่นๆ (Flask, Django)

เพื่อให้เห็นภาพชัดเจนขึ้น ลองเปรียบเทียบ FastAPI กับ Python Web Frameworks ยอดนิยมอื่น ๆ เช่น Flask และ Django กันครับ

คุณสมบัติ FastAPI Flask Django
ประเภท Framework Microframework (แต่มีฟีเจอร์ครบครัน) Microframework Full-stack Framework
ความเร็ว (Performance) ยอดเยี่ยม (เทียบเท่า Node.js/Go) ด้วย Starlette + Pydantic ดี (ขึ้นอยู่กับการใช้งาน) ปานกลาง (มี Overhead สูงกว่า)
การตรวจสอบข้อมูล (Data Validation) อัตโนมัติด้วย Pydantic และ Type Hints ต้องใช้ไลบรารีภายนอก (เช่น Marshmallow) Built-in ORM และ Forms (แต่เน้นไปทาง Web App)
เอกสาร API อัตโนมัติ มีในตัว (OpenAPI/Swagger UI, ReDoc) ต้องใช้ไลบรารีภายนอก (เช่น Flask-RESTX) ต้องใช้ไลบรารีภายนอก (เช่น Django REST Framework)
รองรับ Asynchronous เต็มรูปแบบ (async/await) รองรับในเวอร์ชันใหม่ ๆ (Flask 2.0+) รองรับในเวอร์ชันใหม่ ๆ (Django 3.1+)
Dependency Injection Built-in, ทรงพลังและใช้งานง่าย ต้องสร้างเองหรือใช้ไลบรารีภายนอก Built-in ในรูปแบบของ Middleware/Decorators
การเรียนรู้ ค่อนข้างเร็ว หากเข้าใจ Type Hints เร็วมากสำหรับโปรเจกต์ขนาดเล็ก มี Curve การเรียนรู้สูงกว่าสำหรับโปรเจกต์ขนาดเล็ก
เหมาะสำหรับ API, Microservices, Real-time APIs Small APIs, Web Apps, Microservices Large Web Applications, Monolithic Systems
การจัดการฐานข้อมูล ใช้ร่วมกับ ORM/ODM ภายนอก (เช่น SQLAlchemy, Motor) ใช้ร่วมกับ ORM/ODM ภายนอก Built-in ORM (Django ORM)

จะเห็นได้ว่า FastAPI มีจุดเด่นอย่างมากในการสร้าง REST API โดยเฉพาะในเรื่องของประสิทธิภาพ การจัดการข้อมูล และการสร้างเอกสาร API อัตโนมัติ ซึ่งช่วยลดเวลาในการพัฒนาได้อย่างมหาศาลครับ

เตรียมความพร้อมก่อนเริ่มต้น

เพื่อให้การเรียนรู้เป็นไปอย่างราบรื่น คุณจำเป็นต้องมีสิ่งเหล่านี้ติดตั้งอยู่ในเครื่องคอมพิวเตอร์ของคุณครับ

  • Python 3.7+: FastAPI รองรับ Python เวอร์ชัน 3.7 ขึ้นไป แนะนำให้ใช้เวอร์ชันล่าสุด (ณ ตอนนี้คือ 3.9 หรือ 3.10) ครับ คุณสามารถดาวน์โหลดได้จาก เว็บไซต์ทางการของ Python
  • Basic Command Line/Terminal Knowledge: ความรู้พื้นฐานในการใช้งาน Command Line หรือ Terminal เพื่อรันคำสั่งต่าง ๆ เช่น การติดตั้ง packages หรือการรันสคริปต์ Python ครับ
  • Code Editor: โปรแกรมแก้ไขโค้ดที่คุณถนัด เช่น VS Code, PyCharm, Sublime Text หรือ Atom ครับ

การตั้งค่าสภาพแวดล้อมการพัฒนา

การตั้งค่าสภาพแวดล้อมที่เหมาะสมเป็นสิ่งสำคัญมากในการพัฒนาโปรเจกต์ Python ครับ

สร้างและเปิดใช้งาน Virtual Environment

Virtual Environment (venv) ช่วยให้คุณจัดการแพ็กเกจของแต่ละโปรเจกต์แยกกันได้อย่างอิสระ ป้องกันปัญหาความขัดแย้งของเวอร์ชันแพ็กเกจครับ

  1. สร้างโฟลเดอร์สำหรับโปรเจกต์: 
    
mkdir fastapi-api-project
cd fastapi-api-project
  2. สร้าง Virtual Environment: 
    
python3 -m venv venv

    คำสั่งนี้จะสร้างโฟลเดอร์ชื่อ venv ภายในโปรเจกต์ของคุณ ซึ่งจะเก็บไฟล์ที่จำเป็นสำหรับ Virtual Environment ครับ

  3. เปิดใช้งาน Virtual Environment:
    • บน macOS/Linux: 
      
source venv/bin/activate
    • บน Windows (Command Prompt): 
      
venv\Scripts\activate.bat
    • บน Windows (PowerShell): 
      
venv\Scripts\Activate.ps1

    เมื่อเปิดใช้งานแล้ว คุณจะเห็น (venv) นำหน้า prompt ของ Terminal ซึ่งหมายความว่าคุณกำลังอยู่ใน Virtual Environment แล้วครับ

ติดตั้ง FastAPI และ Uvicorn

เมื่อเปิดใช้งาน Virtual Environment แล้ว ก็ถึงเวลาติดตั้ง FastAPI และ Uvicorn ซึ่งเป็น ASGI server ที่ใช้รันแอปพลิเคชัน FastAPI ครับ


pip install fastapi uvicorn

และเพื่อเพิ่มความสามารถในการตรวจสอบข้อมูลสำหรับบางประเภท (เช่น การตรวจสอบอีเมล, URL) เราอาจติดตั้ง python-multipart เพิ่มเติมครับ


pip install python-multipart

แก่นแท้ของ FastAPI

มาดูแนวคิดหลัก ๆ ที่คุณจะพบบ่อยในการพัฒนาด้วย FastAPI กันครับ

FastAPI Instance

ทุกแอปพลิเคชัน FastAPI จะเริ่มต้นด้วยการสร้าง Object ของ FastAPI ครับ


from fastapi import FastAPI

app = FastAPI() # สร้าง FastAPI instance

Path Operations และ HTTP Methods

เรากำหนด “Path Operations” โดยใช้ decorator ของ app เพื่อระบุ HTTP Method และ Path (URL) ที่จะให้ฟังก์ชันนั้น ๆ ทำงานครับ


from fastapi import FastAPI

app = FastAPI()

@app.get("/") # Path Operation สำหรับ HTTP GET ที่ root path "/"
async def read_root():
    return {"message": "Hello, FastAPI!"}

@app.post("/items/") # Path Operation สำหรับ HTTP POST ที่ path "/items/"
async def create_item(item: dict):
    return {"item_name": item["name"], "item_price": item["price"]}

ในตัวอย่างข้างต้น @app.get("/") และ @app.post("/items/") คือ Path Operation Decorators ที่เชื่อมโยง HTTP Method (GET, POST) กับ Path (/, /items/) เข้ากับฟังก์ชัน Python ที่อยู่ถัดไปครับ

Path Parameters และ Query Parameters

Path Parameters คือพารามิเตอร์ที่เป็นส่วนหนึ่งของ Path (URL) มักใช้ในการระบุทรัพยากรเฉพาะ เช่น ID ของผู้ใช้หรือสินค้าครับ


@app.get("/items/{item_id}") # item_id เป็น Path Parameter
async def read_item(item_id: int): # กำหนด Type Hint เป็น int
    return {"item_id": item_id}

Query Parameters คือพารามิเตอร์ที่อยู่ต่อท้าย URL หลังจากเครื่องหมาย ? มักใช้ในการกรองข้อมูล, การจัดเรียง, หรือการแบ่งหน้าครับ


@app.get("/items/")
async def read_items(skip: int = 0, limit: int = 10): # skip และ limit เป็น Query Parameters
    return {"skip": skip, "limit": limit}

ในตัวอย่าง Query Parameters เราสามารถกำหนดค่าเริ่มต้น (Default Value) ได้ด้วยครับ เช่น skip: int = 0 หมายความว่าถ้าไม่มีการระบุ skip จะใช้ค่า 0 ครับ

Request Body และ Pydantic Models

เมื่อต้องการส่งข้อมูลจำนวนมากไปยัง API โดยเฉพาะอย่างยิ่งสำหรับ HTTP Methods อย่าง POST, PUT, หรือ PATCH เราจะใช้ Request Body ครับ FastAPI ใช้ Pydantic สำหรับการกำหนดรูปแบบข้อมูลและตรวจสอบ (validate) Request Body โดยอัตโนมัติ


from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

# กำหนด Pydantic Model สำหรับ Item
class Item(BaseModel):
    name: str
    description: str | None = None # description อาจมีหรือไม่มีก็ได้
    price: float
    tax: float | None = None

@app.post("/items/")
async def create_item(item: Item): # item: Item คือ Request Body ที่ใช้ Pydantic Model
    return item

เมื่อไคลเอนต์ส่ง JSON Request Body มา เช่น {"name": "Laptop", "price": 1200.0}, FastAPI จะตรวจสอบว่าข้อมูลตรงตาม Item Model หรือไม่ หากไม่ตรง จะส่งข้อผิดพลาดกลับไปโดยอัตโนมัติครับ

HTTP Status Codes

การส่ง HTTP Status Code ที่ถูกต้องกลับไปให้ไคลเอนต์เป็นสิ่งสำคัญในการสื่อสารสถานะของการดำเนินการครับ

  • 200 OK: การดำเนินการสำเร็จ
  • 201 Created: สร้างทรัพยากรใหม่สำเร็จ (มักใช้กับ POST)
  • 204 No Content: การดำเนินการสำเร็จ แต่ไม่มีเนื้อหาที่จะส่งกลับ (มักใช้กับ DELETE)
  • 400 Bad Request: คำขอไม่ถูกต้อง
  • 401 Unauthorized: ไม่ได้รับอนุญาต (ต้องมีการยืนยันตัวตน)
  • 403 Forbidden: ไม่อนุญาตให้เข้าถึง (ยืนยันตัวตนแล้ว แต่ไม่มีสิทธิ์)
  • 404 Not Found: ไม่พบทรัพยากร
  • 422 Unprocessable Entity: ข้อมูลที่ส่งมาไม่สามารถประมวลผลได้ (มักเกิดจากการตรวจสอบ Pydantic ไม่ผ่าน)
  • 500 Internal Server Error: ข้อผิดพลาดภายในเซิร์ฟเวอร์

เราสามารถกำหนด Status Code ใน Path Operation ได้โดยตรงครับ


from fastapi import FastAPI, status

app = FastAPI()

@app.post("/items/", status_code=status.HTTP_201_CREATED)
async def create_item(item: dict):
    return item

ลงมือสร้าง REST API แบบ CRUD (Create, Read, Update, Delete)

ตอนนี้เรามาสร้าง API แบบครบวงจรที่สามารถจัดการข้อมูลได้จริง โดยเริ่มต้นด้วย “ฐานข้อมูล” แบบ In-memory (ใช้ Python list/dictionary) ก่อน เพื่อให้เข้าใจหลักการทำงานของ CRUD ครับ

โครงสร้างโปรเจกต์

เพื่อความเป็นระเบียบ เราจะจัดโครงสร้างโปรเจกต์ดังนี้ครับ


fastapi-api-project/
├── venv/
├── main.py
└── models.py
  • main.py: ไฟล์หลักของแอปพลิเคชัน FastAPI
  • models.py: ไฟล์สำหรับเก็บ Pydantic Models

กำหนด Pydantic Models สำหรับข้อมูล

สร้างไฟล์ models.py และเพิ่ม Pydantic Models สำหรับ Item ครับ


# models.py
from pydantic import BaseModel
from typing import Optional

class ItemBase(BaseModel):
    name: str
    description: Optional[str] = None
    price: float
    tax: Optional[float] = None

class ItemCreate(ItemBase):
    # Model สำหรับการสร้าง Item (อาจมีฟิลด์เพิ่มเติมหรือแตกต่างจาก ItemBase)
    pass

class ItemUpdate(ItemBase):
    # Model สำหรับการอัปเดต Item (ทุกฟิลด์เป็น Optional เพื่ออัปเดตบางส่วนได้)
    name: Optional[str] = None
    description: Optional[str] = None
    price: Optional[float] = None
    tax: Optional[float] = None

class ItemInDB(ItemBase):
    id: int # เพิ่ม id เข้ามาเมื่อข้อมูลถูกบันทึกใน "DB"

    class Config:
        orm_mode = True # ใช้สำหรับเมื่อเชื่อมต่อกับ ORM จริงๆ
  • ItemBase: โมเดลพื้นฐานสำหรับคุณสมบัติของ Item
  • ItemCreate: โมเดลที่ใช้ตอนสร้าง Item ใหม่ ซึ่งอาจเหมือน ItemBase หรือเพิ่มฟิลด์อื่น ๆ ได้
  • ItemUpdate: โมเดลที่ใช้ตอนอัปเดต Item ทุกฟิลด์เป็น Optional เพื่อให้สามารถอัปเดตเพียงบางฟิลด์ได้
  • ItemInDB: โมเดลที่ใช้แสดงข้อมูล Item ที่มีอยู่ใน “ฐานข้อมูล” ซึ่งรวมถึง id ด้วย และมี Config.orm_mode = True เผื่อไว้สำหรับการใช้งานกับ SQLAlchemy ในอนาคตครับ

สร้างฐานข้อมูล In-Memory

ในไฟล์ main.py เราจะสร้าง list ของ dictionary เพื่อจำลองฐานข้อมูลของเราครับ


# main.py
from fastapi import FastAPI, HTTPException, status
from typing import List, Dict
from models import ItemCreate, ItemUpdate, ItemInDB # นำเข้า Pydantic Models ที่สร้างไว้

app = FastAPI()

# จำลองฐานข้อมูล In-memory
# เราจะใช้ Dict เพื่อให้เข้าถึงข้อมูลด้วย ID ได้ง่าย
fake_db: Dict[int, ItemInDB] = {}
next_id = 1

@app.get("/")
async def read_root():
    return {"message": "Welcome to the FastAPI CRUD API!"}

สร้าง (Create) ด้วย POST Method

มาสร้าง Endpoint สำหรับการเพิ่ม Item ใหม่กันครับ


# main.py (เพิ่มโค้ดนี้ต่อจากโค้ดข้างบน)

@app.post("/items/", response_model=ItemInDB, status_code=status.HTTP_201_CREATED)
async def create_item(item: ItemCreate):
    global next_id # เพื่อให้สามารถแก้ไขค่า next_id ได้
    db_item = ItemInDB(id=next_id, **item.dict()) # สร้าง ItemInDB โดยใส่ id และข้อมูลจาก item
    fake_db[next_id] = db_item
    next_id += 1
    return db_item
  • @app.post("/items/", ...): กำหนด Path Operation เป็น POST ที่ /items/
  • response_model=ItemInDB: FastAPI จะใช้ ItemInDB ในการสร้าง Response Body และตรวจสอบ (validate) ข้อมูลก่อนส่งกลับ
  • status_code=status.HTTP_201_CREATED: เมื่อสร้างสำเร็จ จะส่งสถานะ 201 Created
  • item: ItemCreate: FastAPI จะรับ Request Body มาตรวจสอบด้วย ItemCreate Model
  • เราสร้าง db_item โดยการกำหนด id และใช้ **item.dict() เพื่อแตกข้อมูลจาก Pydantic Model item ออกมาเป็น Keyword Arguments

วิธีรัน API:

เปิด Terminal ในโฟลเดอร์โปรเจกต์ (และเปิดใช้งาน venv แล้ว) รันคำสั่ง:


uvicorn main:app --reload

จากนั้นเปิดเบราว์เซอร์ไปที่ http://127.0.0.1:8000/docs คุณจะเห็นเอกสาร Swagger UI และสามารถทดสอบ API ได้เลยครับ

อ่าน (Read) ด้วย GET Method

มาสร้าง Endpoint สำหรับการดึงข้อมูล Item กันครับ


# main.py (เพิ่มโค้ดนี้ต่อจากโค้ดข้างบน)

@app.get("/items/", response_model=List[ItemInDB])
async def read_items(skip: int = 0, limit: int = 10):
    # ดึงข้อมูลจาก fake_db โดยใช้ skip และ limit สำหรับ pagination
    return list(fake_db.values())[skip : skip + limit]

@app.get("/items/{item_id}", response_model=ItemInDB)
async def read_item(item_id: int):
    if item_id not in fake_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Item not found")
    return fake_db[item_id]
  • @app.get("/items/"): ดึงข้อมูล Item ทั้งหมด โดยรองรับ Query Parameters สำหรับ Pagination
  • response_model=List[ItemInDB]: ระบุว่า Response จะเป็น List ของ ItemInDB
  • @app.get("/items/{item_id}"): ดึงข้อมูล Item ชิ้นเดียวด้วย item_id
  • มีการตรวจสอบว่า item_id มีอยู่ใน fake_db หรือไม่ ถ้าไม่พบ จะโยน HTTPException พร้อมสถานะ 404 Not Found ครับ

อัปเดต (Update) ด้วย PUT Method

Endpoint สำหรับการอัปเดต Item ครับ


# main.py (เพิ่มโค้ดนี้ต่อจากโค้ดข้างบน)

@app.put("/items/{item_id}", response_model=ItemInDB)
async def update_item(item_id: int, item: ItemUpdate):
    if item_id not in fake_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Item not found")
    
    existing_item = fake_db[item_id]
    update_data = item.dict(exclude_unset=True) # ดึงเฉพาะฟิลด์ที่มีการส่งค่ามาเท่านั้น
    
    # อัปเดตข้อมูลใน existing_item
    for key, value in update_data.items():
        setattr(existing_item, key, value)
    
    fake_db[item_id] = existing_item
    return existing_item
  • @app.put("/items/{item_id}"): อัปเดตข้อมูล Item ด้วย item_id และรับ Request Body ที่เป็น ItemUpdate
  • item.dict(exclude_unset=True): เป็น Pydantic trick ที่สำคัญมาก! มันจะสร้าง dictionary ที่มีเฉพาะฟิลด์ที่ถูกส่งมาจากไคลเอนต์เท่านั้น (เพราะ ItemUpdate ทุกฟิลด์เป็น Optional) ทำให้เราสามารถอัปเดตเพียงบางฟิลด์ได้โดยไม่กระทบฟิลด์อื่น ๆ ครับ
  • มีการวนลูปอัปเดตค่าใน existing_item ด้วย setattr

ลบ (Delete) ด้วย DELETE Method

Endpoint สำหรับการลบ Item ครับ


# main.py (เพิ่มโค้ดนี้ต่อจากโค้ดข้างบน)

@app.delete("/items/{item_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_item(item_id: int):
    if item_id not in fake_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Item not found")
    
    del fake_db[item_id]
    return # ส่ง 204 No Content กลับไป
  • @app.delete("/items/{item_id}"): ลบ Item ด้วย item_id
  • status_code=status.HTTP_204_NO_CONTENT: เมื่อลบสำเร็จ จะส่งสถานะ 204 No Content กลับไป ซึ่งหมายถึงไม่มีเนื้อหาใด ๆ ใน Response Body
  • มีการตรวจสอบว่า item_id มีอยู่จริงหรือไม่ ก่อนที่จะลบ

การจัดการข้อผิดพลาด (Error Handling)

เราได้เห็นการใช้ HTTPException ในตัวอย่างข้างต้นแล้ว นี่คือวิธีมาตรฐานในการส่งข้อผิดพลาด HTTP กลับไปยังไคลเอนต์ครับ


from fastapi import HTTPException, status

# ... ใน Path Operation ...
    if condition_for_error:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND, # หรือสถานะอื่น ๆ ที่เหมาะสม
            detail="Item not found", # ข้อความรายละเอียดของข้อผิดพลาด
            headers={"X-Error": "There goes my error"}, # สามารถเพิ่ม Headers ได้
        )

FastAPI จะแปลง HTTPException เป็น JSON Response ที่มี detail field และ HTTP Status Code ที่กำหนดให้โดยอัตโนมัติครับ

คุณสมบัติขั้นสูงของ FastAPI

เมื่อคุณเข้าใจพื้นฐานแล้ว มาดูกันว่า FastAPI มีคุณสมบัติขั้นสูงอะไรอีกบ้างที่จะช่วยให้การพัฒนา API ของคุณมีประสิทธิภาพมากขึ้นครับ

Dependency Injection

Dependency Injection (DI) เป็นหนึ่งในคุณสมบัติที่ทรงพลังที่สุดของ FastAPI ช่วยให้การจัดการส่วนประกอบต่าง ๆ ของแอปพลิเคชันเป็นเรื่องง่ายและนำกลับมาใช้ใหม่ได้ครับ คุณสามารถกำหนด “Dependencies” ซึ่งเป็นฟังก์ชันหรือคลาสที่ FastAPI จะทำการเรียกใช้ก่อน Path Operation Function และส่งค่าที่ได้กลับมายัง Path Operation Function นั้น ๆ ครับ

ประโยชน์หลัก ๆ ของ Dependency Injection:

  • การแชร์โค้ด: สามารถนำโค้ดที่ใช้ร่วมกัน เช่น การเชื่อมต่อฐานข้อมูล หรือการตรวจสอบสิทธิ์ มาใช้ซ้ำได้
  • การทดสอบ: ทำให้การทดสอบแต่ละส่วนของโค้ดเป็นเรื่องง่ายขึ้น โดยการ Mock Dependencies
  • การจัดการทรัพยากร: สามารถเปิดและปิดทรัพยากร เช่น Database Session ได้อย่างมีประสิทธิภาพ

# main.py (ตัวอย่าง Dependency Injection)
from fastapi import FastAPI, Depends, HTTPException, status
from typing import Annotated, Dict

app = FastAPI()

# นี่คือ Dependency Function
async def get_current_user(token: str = Depends(lambda x: x)): # สมมติว่ารับ token จากบางที่
    if token != "secret-token":
        raise HTTPException(status_code=401, detail="Invalid authentication token")
    return {"username": "admin", "token": token}

@app.get("/users/me/")
async def read_users_me(current_user: Annotated[Dict, Depends(get_current_user)]):
    # current_user จะได้รับค่าที่คืนมาจาก get_current_user
    return current_user

# ทดสอบด้วยการเรียก http://127.0.0.1:8000/users/me/?token=secret-token
# หรือ http://127.0.0.1:8000/users/me/?token=wrong-token

ในตัวอย่างนี้ get_current_user เป็น Dependency ที่ตรวจสอบ Token ก่อน หาก Token ถูกต้อง จะส่งข้อมูลผู้ใช้กลับมา ซึ่งจะถูกส่งต่อไปยัง current_user ของฟังก์ชัน read_users_me ครับ

Authentication และ Authorization

การจัดการความปลอดภัยเป็นสิ่งสำคัญสำหรับ API ครับ FastAPI มีเครื่องมือที่ช่วยจัดการ Authentication (การยืนยันตัวตน) และ Authorization (การอนุญาตสิทธิ์) ได้เป็นอย่างดี โดยใช้ Dependency Injection เข้ามาช่วย

ตัวอย่าง HTTP Basic Auth

เราสามารถใช้ HTTPBasicCredentials จาก fastapi.security เพื่อทำ HTTP Basic Authentication ได้ครับ


# main.py (ตัวอย่าง HTTP Basic Auth)
from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import HTTPBasic, HTTPBasicCredentials
from typing import Annotated

app = FastAPI()
security = HTTPBasic() # สร้าง instance ของ HTTPBasic

def verify_credentials(credentials: HTTPBasicCredentials = Depends(security)):
    if credentials.username == "admin" and credentials.password == "secret":
        return credentials.username
    raise HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Incorrect username or password",
        headers={"WWW-Authenticate": "Basic"},
    )

@app.get("/secure-data/")
async def get_secure_data(username: Annotated[str, Depends(verify_credentials)]):
    return {"message": f"Hello, {username}! This is secure data."}

เมื่อเรียก /secure-data/ เบราว์เซอร์จะแสดง Pop-up ให้ใส่ Username และ Password หากใส่ “admin” และ “secret” ก็จะเข้าถึงข้อมูลได้ครับ

OAuth2 และ JWT (แนวคิด)

สำหรับระบบ Authentication ที่ซับซ้อนและทันสมัยกว่า เช่น การล็อกอินด้วย Social Media หรือระบบที่ใช้ Token เป็นหลัก มักจะใช้ OAuth2 ร่วมกับ JWT (JSON Web Tokens)

  • OAuth2: เป็น Framework มาตรฐานสำหรับการอนุญาตสิทธิ์ (Authorization) โดยไม่จำเป็นต้องแชร์รหัสผ่าน
  • JWT: เป็นมาตรฐานสำหรับสร้าง Access Token ที่มีการเข้ารหัสและลงชื่อดิจิทัล ทำให้สามารถตรวจสอบความถูกต้องของ Token ได้โดยไม่ต้องสอบถามฐานข้อมูลทุกครั้ง

FastAPI มีโมดูล fastapi.security.oauth2 ที่รองรับการสร้างระบบ OAuth2 และ JWT ได้อย่างง่ายดาย โดยใช้ Dependency Injection ในการดึง Token จาก Header และตรวจสอบความถูกต้องของ Token นั้นครับ

อ่านเพิ่มเติมเกี่ยวกับการทำ Authentication ด้วย JWT ใน FastAPI

การเชื่อมต่อฐานข้อมูล

FastAPI ไม่ได้มาพร้อมกับ ORM (Object Relational Mapper) หรือ ODM (Object Document Mapper) ในตัวเหมือน Django แต่ก็สามารถทำงานร่วมกับไลบรารีอื่น ๆ ได้อย่างยอดเยี่ยมครับ

SQLAlchemy (ORM) และ Async

SQLAlchemy เป็นไลบรารี ORM ที่ทรงพลังและเป็นที่นิยมใน Python สำหรับการเชื่อมต่อกับฐานข้อมูลเชิงสัมพันธ์ (Relational Databases) เช่น PostgreSQL, MySQL, SQLite

เนื่องจาก FastAPI เป็น Asynchronous Framework เราควรใช้เวอร์ชัน Asynchronous ของ SQLAlchemy (SQLAlchemy.ext.asyncio) เพื่อประสิทธิภาพสูงสุดครับ

ขั้นตอนการใช้งาน SQLAlchemy (โดยย่อ):

  1. ติดตั้ง: pip install sqlalchemy asyncpg # หรือ mysqlclient สำหรับ MySQL
  2. กำหนด Database Engine และ Session: 
    
# database.py
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import sessionmaker, declarative_base

DATABASE_URL = "postgresql+asyncpg://user:password@host/dbname" # หรือ sqlite+aiosqlite:///./test.db

engine = create_async_engine(DATABASE_URL, echo=True)
Base = declarative_base()
AsyncSessionLocal = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)

async def get_db():
    async with AsyncSessionLocal() as session:
        yield session
  3. กำหนด Models: ใช้ declarative_base ในการกำหนด Table และ Columns
    4. 
# models.py (สำหรับ SQLAlchemy)
from sqlalchemy import Column, Integer, String, Float
from .database import Base

class DBItem(Base):
    __tablename__ = "items"

    id = Column(Integer, primary_key=True, index=True)
    name = Column(String, index=True)
    description = Column(String, nullable=True)
    price = Column(Float)
    tax = Column(Float, nullable=True)
  4. ใช้งานใน Path Operations ด้วย Dependency: 
    
# main.py (ตัวอย่างการใช้งาน SQLAlchemy)
from fastapi import Depends, FastAPI
from sqlalchemy.ext.asyncio import AsyncSession
from typing import List
from .database import get_db, engine, Base # นำเข้าจาก database.py
from .models import DBItem # นำเข้าจาก models.py
from .schemas import ItemCreate, ItemInDB # Pydantic models (แยกไฟล์ schemas.py)

app = FastAPI()

# สร้างตารางเมื่อแอปเริ่มต้น (เฉพาะในโหมด dev)
@app.on_event("startup")
async def startup_event():
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)

@app.post("/db-items/", response_model=ItemInDB)
async def create_db_item(item: ItemCreate, db: AsyncSession = Depends(get_db)):
    db_item = DBItem(**item.dict())
    db.add(db_item)
    await db.commit()
    await db.refresh(db_item)
    return db_item

@app.get("/db-items/", response_model=List[ItemInDB])
async def read_db_items(skip: int = 0, limit: int = 10, db: AsyncSession = Depends(get_db)):
    result = await db.execute(select(DBItem).offset(skip).limit(limit))
    items = result.scalars().all()
    return items

ในตัวอย่างข้างต้น get_db เป็น Dependency ที่จะเปิดและปิด Database Session ให้โดยอัตโนมัติ ทำให้โค้ด Path Operation สะอาดและง่ายต่อการจัดการครับ

Alembic สำหรับ Database Migrations (กล่าวถึง)

เมื่อใช้ SQLAlchemy กับฐานข้อมูลจริง คุณจะต้องจัดการกับการเปลี่ยนแปลงโครงสร้างฐานข้อมูล (Schema Changes) ซึ่ง Alembic เป็นไลบรารีที่ใช้สำหรับ Database Migrations ที่ทำงานร่วมกับ SQLAlchemy ได้อย่างสมบูรณ์แบบครับ มันช่วยให้คุณสามารถสร้าง, รัน, และย้อนกลับ (revert) การเปลี่ยนแปลงของ Schema ได้อย่างเป็นระบบ

NoSQL เช่น MongoDB (กล่าวถึง)

หากโปรเจกต์ของคุณต้องการใช้ฐานข้อมูล NoSQL เช่น MongoDB คุณสามารถใช้ไลบรารีอย่าง Motor (Asynchronous driver สำหรับ MongoDB) ร่วมกับ Pydantic ได้ครับ หลักการคล้ายกับการใช้ ORM คือสร้าง Connection Dependency และนำไปใช้ใน Path Operations ครับ

การจัดระเบียบโค้ดด้วย APIRouter

เมื่อโปรเจกต์ API ของคุณเริ่มมีขนาดใหญ่ขึ้น การเก็บ Path Operations ทั้งหมดไว้ในไฟล์ main.py ไฟล์เดียวจะทำให้โค้ดยาวและจัดการยากครับ APIRouter ช่วยให้คุณสามารถจัดระเบียบโค้ดโดยการแยก Path Operations ออกเป็นไฟล์หรือโมดูลย่อย ๆ ตามฟังก์ชันการทำงาน (เช่น users.py, products.py) ครับ


# app/routers/items.py
from fastapi import APIRouter, HTTPException, status
from typing import List, Dict
from ..models import ItemCreate, ItemUpdate, ItemInDB # ใช้ .. เพื่ออ้างอิงไปยังระดับบน

router = APIRouter(
    prefix="/items", # กำหนด prefix สำหรับ Path ทั้งหมดใน router นี้
    tags=["items"], # กำหนด tag สำหรับเอกสาร API
    responses={404: {"description": "Not found"}},
)

# จำลองฐานข้อมูลสำหรับ router นี้
fake_db: Dict[int, ItemInDB] = {}
next_id = 1

@router.post("/", response_model=ItemInDB, status_code=status.HTTP_201_CREATED)
async def create_item_router(item: ItemCreate):
    global next_id
    db_item = ItemInDB(id=next_id, **item.dict())
    fake_db[next_id] = db_item
    next_id += 1
    return db_item

@router.get("/", response_model=List[ItemInDB])
async def read_items_router(skip: int = 0, limit: int = 10):
    return list(fake_db.values())[skip : skip + limit]

# ... เพิ่ม PUT, DELETE เช่นเดียวกับใน main.py ...

จากนั้นใน main.py คุณก็แค่รวม Router เหล่านั้นเข้ามาครับ


# main.py
from fastapi import FastAPI
from app.routers import items # อ้างอิงถึงไฟล์ items.py ที่อยู่ในโฟลเดอร์ routers

app = FastAPI()

app.include_router(items.router) # รวม router ของ items เข้ามา

@app.get("/")
async def read_root():
    return {"message": "Welcome to the FastAPI API with Routers!"}

ด้วยวิธีนี้ โค้ดของคุณจะมีความเป็นระเบียบและจัดการง่ายขึ้นมากครับ

Middleware

Middleware คือฟังก์ชันที่ทำงานระหว่างการรับ Request และการส่ง Response ครับ มันสามารถดักจับและประมวลผล Request ก่อนจะส่งไปยัง Path Operation และประมวลผล Response ก่อนจะส่งกลับไปยังไคลเอนต์

ตัวอย่างการใช้งาน Middleware:

  • การบันทึก Log ของทุก Request
  • การเพิ่ม Header ที่กำหนดเองให้กับทุก Response
  • การจัดการ CORS (Cross-Origin Resource Sharing)
  • การตรวจสอบสิทธิ์เบื้องต้น

# main.py (ตัวอย่าง Middleware)
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
import time

app = FastAPI()

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    start_time = time.time()
    response = await call_next(request) # ส่ง Request ไปยัง Path Operation ถัดไป
    process_time = time.time() - start_time
    response.headers["X-Process-Time"] = str(process_time) # เพิ่ม Header
    return response

@app.get("/hello/")
async def hello_world():
    return {"message": "Hello from FastAPI!"}

ในตัวอย่างนี้ Middleware จะคำนวณเวลาที่ใช้ในการประมวลผล Request และเพิ่ม Header X-Process-Time เข้าไปในทุก Response ครับ

Background Tasks

บางครั้งเราอาจต้องการให้ API ทำงานบางอย่างที่ใช้เวลานาน โดยที่ไม่ต้องให้ไคลเอนต์ต้องรอจนกว่างานนั้นจะเสร็จสิ้น เช่น การส่งอีเมล, การประมวลผลไฟล์, หรือการอัปเดตข้อมูลในระบบอื่น ๆ ในกรณีนี้ Background Tasks จะเข้ามาช่วยครับ


# main.py (ตัวอย่าง Background Tasks)
from fastapi import FastAPI, BackgroundTasks

app = FastAPI()

def write_log(message: str):
    with open("log.txt", mode="a") as log:
        log.write(message + "\n")

@app.post("/send-notification/")
async def send_notification(
    email: str, 
    message: str, 
    background_tasks: BackgroundTasks # รับ BackgroundTasks object
):
    background_tasks.add_task(write_log, f"Notification sent to {email} with message: {message}")
    # ในความเป็นจริงอาจจะเรียกฟังก์ชันส่งอีเมลจริง ๆ
    return {"message": "Notification process initiated in background."}

เมื่อเรียก /send-notification/ API จะส่ง Response กลับทันที ในขณะที่ฟังก์ชัน write_log จะทำงานใน Background ครับ

การทดสอบ API ด้วย TestClient

การทดสอบเป็นส่วนสำคัญของการพัฒนาซอฟต์แวร์ครับ FastAPI มี TestClient ที่ช่วยให้คุณสามารถทดสอบ API ของคุณได้อย่างง่ายดาย โดยไม่ต้องรันเซิร์ฟเวอร์จริง ๆ ครับ


# test_main.py (สร้างไฟล์นี้แยกออกมา)
from fastapi.testclient import TestClient
from main import app # อ้างอิงถึง FastAPI app ของเรา

client = TestClient(app) # สร้าง TestClient จาก app instance

def test_read_root():
    response = client.get("/")
    assert response.status_code == 200
    assert response.json() == {"message": "Welcome to the FastAPI CRUD API!"}

def test_create_item():
    response = client.post(
        "/items/",
        json={"name": "Test Item", "description": "A test item", "price": 10.5, "tax": 1.0},
    )
    assert response.status_code == 201
    assert response.json()["name"] == "Test Item"
    assert "id" in response.json()

def test_read_item_not_found():
    response = client.get("/items/999") # item id ที่ไม่มีอยู่จริง
    assert response.status_code == 404
    assert response.json() == {"detail": "Item not found"}

คุณสามารถรันการทดสอบเหล่านี้ด้วย pytest (ติดตั้ง pip install pytest) โดยพิมพ์ pytest ใน Terminal ครับ

การเตรียมพร้อมสำหรับการ Deploy

เมื่อ API ของคุณพร้อมใช้งานแล้ว ก็ถึงเวลาเตรียมพร้อมสำหรับการนำไปใช้งานจริงบน Production Environment ครับ

Uvicorn Workers และ Gunicorn

ใน Production Environment เรามักจะใช้ Uvicorn ร่วมกับ Gunicorn (Green Unicorn) ครับ Gunicorn เป็น WSGI HTTP Server ที่นิยมใช้ใน Python สำหรับจัดการ Process และ Workers และ Uvicorn จะถูกใช้เป็น Worker Class ของ Gunicorn

การใช้ Gunicorn ช่วยให้เราสามารถรัน Uvicorn หลาย Worker Process ได้ ซึ่งจะช่วยเพิ่มประสิทธิภาพและความเสถียรของ API ในการจัดการคำขอจำนวนมากครับ

ขั้นตอน:

  1. ติดตั้ง Gunicorn: pip install gunicorn
  2. รันด้วย Gunicorn: 
    
gunicorn main:app --workers 4 --worker-class uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000
    • main:app: ระบุไฟล์ main.py และ FastAPI instance ที่ชื่อ app
    • --workers 4: รัน 4 Worker Processes (จำนวน Worker มักจะถูกกำหนดตามจำนวน Core ของ CPU)
    • --worker-class uvicorn.workers.UvicornWorker: บอก Gunicorn ให้ใช้ Uvicorn เป็น Worker
    • --bind 0.0.0.0:8000: ให้ API รับ Request จากทุก IP บน Port 8000

นอกจากนี้ ยังนิยมใช้ Reverse Proxy Server เช่น Nginx หรือ Caddy อยู่หน้า Gunicorn อีกชั้นหนึ่ง เพื่อจัดการเรื่อง SSL/TLS, Load Balancing, และ Static Files ครับ

การใช้ Docker

Docker เป็นเครื่องมือที่ยอดเยี่ยมสำหรับการสร้าง, Deploy, และรันแอปพลิเคชันในรูปแบบของ Container ทำให้มั่นใจได้ว่าแอปพลิเคชันของคุณจะทำงานได้เหมือนกันทุกที่ ไม่ว่าจะในเครื่องพัฒนาของคุณ หรือบน Production Server ครับ

ตัวอย่าง Dockerfile สำหรับ FastAPI:


# Dockerfile
FROM python:3.9-slim-buster # ใช้ Python 3.9 บน Debian Buster แบบ slim

WORKDIR /app # กำหนด Working Directory ภายใน Container

COPY requirements.txt . # คัดลอก requirements.txt มาก่อน

RUN pip install --no-cache-dir -r requirements.txt # ติดตั้ง dependencies

COPY . . # คัดลอกโค้ดทั้งหมดของโปรเจกต์

# Expose port ที่ Uvicorn/Gunicorn จะรัน
EXPOSE 8000

# คำสั่งสำหรับรัน Gunicorn + Uvicorn Workers
CMD ["gunicorn", "main:app", "--workers", "4", "--worker-class", "uvicorn.workers.UvicornWorker", "--bind", "0.0.0.0:8000"]

ขั้นตอนการใช้งาน Docker:

  1. สร้าง requirements.txt: 
    
pip freeze > requirements.txt
  2. สร้าง Docker Image: 
    
docker build -t my-fastapi-app .
  3. รัน Docker Container: 
    
docker run -d --name fastapi-prod -p 8000:8000 my-fastapi-app

    ตอนนี้ API ของคุณจะรันอยู่ใน Docker Container และเข้าถึงได้ที่ http://localhost:8000 ครับ

แนวทางปฏิบัติที่ดีที่สุด (Best Practices)

เพื่อให้ API ของคุณมีคุณภาพ, ปรับขนาดได้, และดูแลรักษาง่าย ลองพิจารณาแนวทางเหล่านี้ครับ

  • การจัดโครงสร้างโปรเจกต์ (Project Structure):
    • แยกโค้ดออกเป็นโมดูลย่อย ๆ เช่น routers/ สำหรับ Path Operations, schemas/ สำหรับ Pydantic Models, crud/ สำหรับ Logic การจัดการฐานข้อมูล, database/ สำหรับการเชื่อมต่อ DB ครับ
    • ใช้ __init__.py ในโฟลเดอร์เพื่อให้ Python มองว่าเป็น Package
  • การใช้ Type Hints อย่างสม่ำเสมอ: Type Hints เป็นหัวใจของ FastAPI ทำให้โค้ดอ่านง่าย ตรวจสอบได้ และยังช่วยให้ IDE (เช่น VS Code) สามารถแนะนำโค้ด (Autocompletion) ได้ดีขึ้นครับ
  • การจัดการข้อผิดพลาด (Error Handling): ใช้ HTTPException สำหรับข้อผิดพลาดที่คาดการณ์ได้ และพิจารณาการสร้าง Custom Exception Handlers สำหรับข้อผิดพลาดเฉพาะทางครับ
  • การบันทึก Log (Logging): ใช้ไลบรารี logging ของ Python เพื่อบันทึกเหตุการณ์สำคัญ, ข้อผิดพลาด, หรือข้อมูลการทำงานของ API เพื่อช่วยในการ Debug และ Monitor ครับ
  • ความปลอดภัย (Security):
    • ใช้ HTTPS เสมอใน Production Environment
    • ตรวจสอบและยืนยันข้อมูลที่เข้ามาอย่างเข้มงวด (Input Validation)
    • หลีกเลี่ยงการเปิดเผยข้อมูลที่ละเอียดอ่อนใน Response โดยไม่จำเป็น
    • ใช้ Authentication และ Authorization ที่เหมาะสม
    • จัดการ Secret Keys (เช่น Database Passwords, API Keys) ด้วย Environment Variables หรือ Secret Management Tools ไม่ควร Hardcode ไว้ในโค้ดครับ
  • การทดสอบ (Testing): เขียน Unit Tests และ Integration Tests สำหรับ Path Operations และ Logic ธุรกิจของคุณครับ
  • การจัดทำเอกสาร (Documentation): FastAPI สร้างเอกสาร API ให้อัตโนมัติ แต่คุณควรเพิ่ม description, summary, และ response_description ใน Path Operations และ Models เพื่อให้เอกสารสมบูรณ์และเข้าใจง่ายยิ่งขึ้นครับ
  • การจัดการ Dependency (Dependency Management): ใช้ pip freeze > requirements.txt หรือเครื่องมืออื่น ๆ เช่น Poetry, PDM เพื่อจัดการ Dependencies ของโปรเจกต์อย่างเป็นระบบครับ

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

เราได้รวบรวมคำถามที่พบบ่อยเกี่ยวกับการสร้าง REST API ด้วย FastAPI มาให้คุณแล้วครับ

1. FastAPI เหมาะสำหรับโปรเจกต์ขนาดใหญ่หรือไม่?

ตอบ: เหมาะสมอย่างยิ่งครับ! FastAPI ถูกออกแบบมาให้มีประสิทธิภาพสูงและรองรับการขยายขนาดได้ดีเยี่ยม ด้วยการใช้ Pydantic สำหรับการตรวจสอบข้อมูล, Starlette สำหรับเว็บส่วนหลัก, และการรองรับ Asynchronous เต็มรูปแบบ ทำให้ FastAPI สามารถจัดการกับปริมาณงานที่สูงได้ นอกจากนี้ ระบบ Dependency Injection และ APIRouter ยังช่วยให้การจัดโครงสร้างโปรเจกต์ขนาดใหญ่เป็นระเบียบและดูแลรักษาง่ายอีกด้วยครับ

2. จะจัดการกับ CORS (Cross-Origin Resource Sharing) ใน FastAPI ได้อย่างไร?

ตอบ: FastAPI มี CORSMiddleware ในตัวที่ช่วยให้การจัดการ CORS เป็นเรื่องง่ายมากครับ คุณสามารถเพิ่มมันเข้าไปในแอปพลิเคชันของคุณดังนี้:


from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

origins = [
    "http://localhost",
    "http://localhost:8080",
    "https://your-frontend-domain.com",
]

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins, # อนุญาต Origin ที่ระบุ
    allow_credentials=True,
    allow_methods=["*"], # อนุญาตทุก HTTP Methods
    allow_headers=["*"], # อนุญาตทุก Headers
)

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

การตั้งค่า allow_origins ให้ระบุเฉพาะโดเมนที่คุณอนุญาต เพื่อความปลอดภัยที่ดีที่สุดครับ

3. สามารถใช้ FastAPI กับฐานข้อมูล NoSQL ได้หรือไม่?

ตอบ: ได้แน่นอนครับ! FastAPI ไม่ได้ผูกติดกับฐานข้อมูลประเภทใดประเภทหนึ่ง คุณสามารถใช้ FastAPI กับฐานข้อมูล NoSQL เช่น MongoDB โดยใช้ Asynchronous Driver อย่าง Motor ได้ครับ Pydantic Models ยังคงมีประโยชน์ในการกำหนด Schema และตรวจสอบข้อมูลที่เข้าและออกจากฐานข้อมูลครับ

4. FastAPI มีความปลอดภัยแค่ไหน?

ตอบ: FastAPI มีความปลอดภัยสูงโดยธรรมชาติ เพราะสร้างขึ้นโดยคำนึงถึงความปลอดภัยเป็นหลักครับ

  • การตรวจสอบข้อมูล (Data Validation): Pydantic ช่วยป้องกัน Injection Attacks และตรวจสอบประเภทข้อมูล
  • การจัดการความปลอดภัย: มีโมดูล fastapi.security ที่รองรับ OAuth2, JWT, HTTP Basic Auth
  • ป้องกัน XSS/CSRF: เนื่องจาก FastAPI เป็น API Framework โดยตรง ไม่ได้สร้าง HTML Pages จึงลดความเสี่ยงจาก XSS (Cross-Site Scripting) และ CSRF (Cross-Site Request Forgery) โดยธรรมชาติ แต่คุณยังคงต้องระมัดระวังเมื่อประมวลผลข้อมูลที่ผู้ใช้ส่งมา

อย่างไรก็ตาม ความปลอดภัยของ API ขึ้นอยู่กับการนำไปใช้งานและ Best Practices ของนักพัฒนาด้วยครับ เช่น การใช้ HTTPS, การจัดการ Secret Keys อย่างปลอดภัย, และการตรวจสอบสิทธิ์ที่เหมาะสม

5. ควรใช้ Pydantic Models สำหรับ Request และ Response แยกกันหรือไม่?

ตอบ: เป็นแนวทางปฏิบัติที่ดีเยี่ยมครับ! การแยก Pydantic Models สำหรับ Request (เช่น ItemCreate, ItemUpdate) และ Response (เช่น ItemInDB) มีประโยชน์หลายอย่าง:

  • ความชัดเจน: ทำให้เห็นชัดเจนว่าข้อมูลใดที่ไคลเอนต์สามารถส่งเข้ามาได้ และข้อมูลใดที่จะถูกส่งกลับไป
  • ความปลอดภัย: ป้องกันการเปิดเผยข้อมูลที่ไม่จำเป็นหรือละเอียดอ่อนใน Response
  • ความยืดหยุ่น: ช่วยให้คุณสามารถปรับเปลี่ยนรูปแบบ Request/Response ได้อย่างอิสระโดยไม่กระทบต่อกัน
  • การจัดการ ID: โดยทั่วไป Request ไม่ควรส่ง ID มา แต่ Response ควรมี ID ครับ

ในบทความนี้เราได้แสดงให้เห็นถึงการแยก Models ในส่วนของ CRUD API เพื่อให้เห็นภาพที่ชัดเจนครับ

สรุปและ Call-to-Action

ตลอดบทความนี้ เราได้เดินทางร่วมกันตั้งแต่การทำความเข้าใจพื้นฐานของ REST API, เจาะลึกถึงเหตุผลที่ FastAPI เป็นตัวเลือกที่ยอดเยี่ยม, การตั้งค่าสภาพแวดล้อม, การสร้าง CRUD API อย่างละเอียด, ไปจนถึงการสำรวจคุณสมบัติขั้นสูง เช่น Dependency Injection, Authentication, การเชื่อมต่อฐานข้อมูล, การจัดระเบียบโค้ดด้วย Routers, Middleware, Background Tasks, การทดสอบ, และการเตรียมพร้อมสำหรับการ Deploy บน Production ครับ

FastAPI ได้พิสูจน์แล้วว่าเป็น Python Web Framework ที่ทันสมัย, มีประสิทธิภาพ, ใช้งานง่าย, และมีคุณสมบัติครบถ้วนสำหรับการสร้าง REST API ที่แข็งแกร่งและปรับขนาดได้ ด้วยการผสานพลังของ Python Type Hints และ Pydantic ทำให้การพัฒนา API เป็นเรื่องที่รวดเร็ว ลดข้อผิดพลาด และยังมาพร้อมกับเอกสาร API อัตโนมัติที่ยอดเยี่ยมอีกด้วยครับ

หวังว่าบทความนี้จะเป็นคู่มือฉบับสมบูรณ์ที่จะช่วยให้คุณมีความเข้าใจอย่างลึกซึ้งและพร้อมที่จะเริ่มต้นสร้าง API ของคุณเองด้วย FastAPI ได้อย่างมั่นใจนะครับ

ถึงเวลาลงมือทำแล้วครับ! อย่ารอช้า ลองนำความรู้และตัวอย่างโค้ดในบทความนี้ไปทดลองสร้าง API ของคุณเองดูนะครับ ไม่ว่าจะเป็น API สำหรับโปรเจกต์ส่วนตัว, โปรเจกต์ในที่ทำงาน, หรือแม้กระทั่งการเรียนรู้เพิ่มเติม การลงมือปฏิบัติจริงคือกุญแจสำคัญสู่ความสำเร็จครับ หากมีข้อสงสัยหรือต้องการแบ่งปันประสบการณ์ อย่า

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

Siam2R.com — Portfolio งาน IT · XM Signal — Free Forex EA Download

Related Articles
จัดส่งรวดเร็วส่งด่วนทั่วประเทศ
รับประกันสินค้าเคลมง่าย มีใบรับประกัน
ผ่อนชำระได้บัตรเครดิต 0% สูงสุด 10 เดือน
สะสมแต้ม รับส่วนลดส่วนลดและคะแนนสะสม

ติดต่อเรา | LINE: @siamlancard

Facebook | YouTube | LINE OA

เว็บในเครือ: SiamCafe.net | iCafeForex.com | Siam2R.com | XMSignal.com

© 2026 SiamLancard — จำหน่ายการ์ดแลน อุปกรณ์ Server และเครื่องพิมพ์ใบเสร็จ

SiamLancard
Logo
Free Forex EA Download — XM Signal · EA Forex ฟรี
iCafeForex.com - สอนเทรด Forex | SiamCafe.net
Shopping cart