FastAPI là gì và tại sao nên chọn FastAPI?
FastAPI là một framework web Python hiệu suất cao, được thiết kế để xây dựng REST API một cách nhanh chóng và đáng tin cậy. Tạo bởi Sebastián Ramírez, FastAPI sử dụng Starlette cho phần xử lý request và Pydantic cho việc validation dữ liệu, mang lại tốc độ tương đương Node.js hay Go (fastapi.tiangolo.com).
Trong bối cảnh phát triển API hiện đại, FastAPI nổi bật nhờ ba ưu điểm chính:
- Tốc độ cao: Nhanh ngang ngửa FastAPI so với NodeJS, Starlette và chỉ chậm hơn ~2-3% so với raw Starlette nhờ ASGI backend (Benchmarks FastAPI).
- Tự động sinh tài liệu: Swagger UI và ReDoc được tích hợp sẵn, không cần cấu hình thêm.
- Hỗ trợ type hints: Sử dụng Python type hints để validate, serialize và deserialize dữ liệu tự động.
Cài đặt và thiết lập môi trường
Bắt đầu với FastAPI cực kỳ đơn giản. Bạn chỉ cần cài đặt hai package chính:
pip install fastapi uvicorn
Trong đó:
fastapi— framework chính cung cấp các decorator và tiện ích.uvicorn— ASGI server để chạy ứng dụng trong môi trường development.
Để chạy server development, sử dụng lệnh:
uvicorn main:app --reload
Tham số --reload giúp server tự động restart khi có thay đổi code, rất tiện lợi khi đang phát triển (FastAPI First Steps).
Xây dựng REST API đầu tiên
Một ứng dụng FastAPI cơ bản chỉ cần vài dòng code:
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class User(BaseModel):
name: str
email: str
age: int | None = None
users_db: list[dict] = []
@app.get("/users")
def get_users():
return users_db
@app.post("/users")
def create_user(user: User):
users_db.append(user.model_dump())
return {"message": "Tạo thành công", "data": user}
Khi chạy và truy cập http://127.0.0.1:8000/docs, bạn sẽ thấy Swagger UI với toàn bộ API được mô tả sẵn. Đây là một trong những tính năng mạnh mẽ nhất của FastAPI — tài liệu API luôn đồng bộ với code thực tế (Interactive API Docs).
Các HTTP methods trong FastAPI
FastAPI hỗ trợ đầy đủ các HTTP methods phổ biến cho REST API:
GET — Đọc dữ liệu
@app.get("/users/{user_id}")
def get_user(user_id: int):
for user in users_db:
if user["age"] is not None and user.get("id") == user_id:
return user
return {"error": "Không tìm thấy"}
POST — Tạo mới
@app.post("/users")
def create_user(user: User):
user_data = user.model_dump()
user_data["id"] = len(users_db) + 1
users_db.append(user_data)
return user_data
PUT — Cập nhật toàn bộ
@app.put("/users/{user_id}")
def update_user(user_id: int, user: User):
for i, u in enumerate(users_db):
if u.get("id") == user_id:
user_data = user.model_dump()
user_data["id"] = user_id
users_db[i] = user_data
return user_data
return {"error": "Không tìm thấy"}
DELETE — Xóa
@app.delete("/users/{user_id}")
def delete_user(user_id: int):
for i, u in enumerate(users_db):
if u.get("id") == user_id:
users_db.pop(i)
return {"message": "Đã xóa"}
return {"error": "Không tìm thấy"}
Mỗi route tương ứng một HTTP method rõ ràng, giúp code dễ đọc và maintain (Path Parameters).
Validation dữ liệu với Pydantic
FastAPI sử dụng Pydantic BaseModel để validate dữ liệu đầu vào. Khi client gửi request với dữ liệu sai kiểu, hệ thống tự động trả về lỗi 422 với thông báo chi tiết:
class Product(BaseModel):
name: str
price: float
description: str = "Không có mô tả"
in_stock: bool = True
@app.post("/products")
def create_product(product: Product):
return product.model_dump()
Các quy tắc validation bao gồm:
- Bắt buộc:
str,int,float— không có giá trị mặc định thì bắt buộc truyền vào. - Tùy chọn:
str = "default"— có thể bỏ qua khi gọi API. - Kiểm tra kiểu: Nếu truyền string thay cho int, FastAPI trả lỗi 422 với message rõ ràng.
- Nested models: Có thể lồng BaseModel bên trong BaseModel để cấu trúc dữ liệu phức tạp.
Tính năng này giúp giảm thiểu lỗi runtime và tăng độ ổn định cho ứng dụng (Body Multiple Params).
Middleware và CORS
Khi frontend gọi API từ domain khác, bạn cần cấu hình CORS (Cross-Origin Resource Sharing):
from fastapi.middleware.cors import CORSMiddleware
app.add_middleware(
CORSMiddleware,
allow_origins=["http://localhost:3000"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
Middleware trong FastAPI chạy trước khi request đến handler và sau khi response được tạo, thuận tiện cho logging, authentication hay rate limiting (Advanced Middleware).
Kết nối cơ sở dữ liệu
Trong thực tế, API cần kết nối database. FastAPI hỗ trợ nhiều ORM và driver phổ biến:
- SQLAlchemy — ORM truyền thống, ổn định và nhiều extension.
- Tortoise ORM — async-native, tương thích tốt với FastAPI.
- Prisma — thế hệ mới, type-safe và dễ dùng.
- MongoDB Motor — driver async chính thức cho MongoDB.
Ví dụ với SQLAlchemy:
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import Session, DeclarativeBase
DATABASE_URL = "sqlite:///./app.db"
engine = create_engine(DATABASE_URL)
class Base(DeclarativeBase):
pass
class UserDB(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True)
name = Column(String)
email = Column(String)
Flyway cũng cung cấp dependency injection để quản lý session database một cách tự động (SQL Databases).
Triển khai production
Để đưa API vào production, bạn cần lưu ý:
- Không dùng
--reload— chỉ dành cho development. - Sử dụng Gunicorn + Uvicorn workers:
gunicorn main:app -w 4 -k uvicorn.workers.UvicornWorker - Cấu hình môi trường: Dùng python-dotenv hoặc hệ thống env vars để quản lý secrets.
- Docker: FastAPI có image chính thức trên Docker Hub, giúp triển khai nhất quán (FastAPI Docker).
- HTTPS: Luôn sử dụng HTTPS thông qua reverse proxy như Nginx hoặc Traefik.
Tài nguyên tham khảo
Để tìm hiểu sâu hơn về FastAPI, bạn nên tham khảo:
- Tài liệu chính thức FastAPI — nguồn thông tin đáng tin cậy nhất.
- Tutorial chính thức — hướng dẫn từ cơ bản đến nâng cao.
- GitHub Repository — source code và issue tracker.
- Pydantic Documentation — tìm hiểu sâu về validation.
FastAPI đang trở thành lựa chọn hàng đầu cho REST API trong Python ecosystem nhờ tốc độ, tính năng tự động hóa và trải nghiệm developer tuyệt vời. Bắt đầu với các endpoint đơn giản, dần mở rộng với authentication, database và deployment — đó là lộ trình hiệu quả nhất để làm chủ framework này.
