Hỗ trợ đồ án, khóa luận Web, App, AI - Uy tín, chất lượng!

Zalo: 0379.962.045

Trang Chủ Hướng Dẫn Đồ Án Làm đồ án REST API bằng FastAPI trong Python

Hướng Dẫn Đồ Án

Làm đồ án REST API bằng FastAPI trong Python

BởiHỗ Trợ Code CNTT6 phút đọc260 lượt xem

Chia sẻ

Trong thời đại hiện nay, khi kiến thức về lập trình web và API – đặc biệt là REST API – ngày càng quan trọng, việc xây dựng một đồ án bằng FastAPI trong Python sẽ không những giúp bạn hiểu sâu về backend mà còn tạo ra sản phẩm chuyên nghiệp, hiện đại. Đây là lựa chọn cực kỳ thích hợp cho sinh viên ngành CNTT hoặc những người muốn làm quen với framework backend nhanh, mạnh, có cú pháp rõ ràng.

FastAPI nổi bật vì tốc độ, tích hợp tự động tài liệu Swagger, hỗ trợ async/await native và dễ triển khai. Nếu bạn đang cần làm một REST API để phục vụ ứng dụng mobile, frontend, hoặc để làm đồ án, bài viết này sẽ đưa bạn đi qua từng bước cụ thể: từ cài đặt cơ bản, thiết kế cấu trúc thư mục chuẩn, viết code từng endpoint, đến test và triển khai dự án thực sự.

Tại sao nên chọn FastAPI làm nền tảng đồ án REST API?

FastAPI là một framework web Python hiện đại, viết trên Starlette và Pydantic, được thiết kế để:

Tốc độ xử lý nhanh, tương đương Node.js hoặc Go.
Hỗ trợ type hints – giúp kiểm tra và tự động tạo tài liệu đầy đủ.
Tích hợp sẵn Swagger UI và ReDoc giúp dễ test và giới thiệu API.
Giúp bạn viết code gọn gàng và ít lỗi.

Với những ưu điểm đó, FastAPI ngày càng được sinh viên và lập trình viên sử dụng trong các đồ án, bài tập lớn hoặc dự án thực tế. Khi bạn học được cách triển khai REST API theo chuẩn, bạn không chỉ có thể phối hợp tốt với frontend/mobile mà còn nâng cao khả năng xin thực tập hoặc việc làm trong các công ty công nghệ.

Xác định mục tiêu và cấu trúc đề tài đồ án

Khởi đầu một đồ án, bạn cần xác định rõ: API này phục vụ mục đích gì? Có thể là quản lý sách, học sinh, đơn hàng, sản phẩm… Ví dụ, nếu bạn làm hệ thống quản lý sản phẩm hoặc chỉ đơn giản là CRUD trong Flask, bạn cần có các chức năng:

Thêm sản phẩm (Create)
Xem danh sách (Read)
Sửa/xóa sản phẩm (Update, Delete)

Cơ sở dữ liệu có thể rất đơn giản như SQLite (phù hợp đồ án) hoặc Postgres nếu bạn muốn làm chuyên nghiệp hơn.

Khi đã xác định mục tiêu, bạn nên lên cấu trúc dự án ngay từ đầu để đảm bảo code rõ ràng, dễ bảo trì:

my_fastapi_app/
├── app/
│   ├── __init__.py
│   ├── main.py
│   ├── models.py
│   ├── schemas.py
│   ├── crud.py
│   ├── database.py
│   └── routers/
       └── products.py

Cài đặt và khởi tạo ứng dụng FastAPI

Bạn bắt đầu bằng việc tạo môi trường ảo:

python -m venv venv
source venv/bin/activate

Sau đó cài các thư viện:

pip install fastapi uvicorn[standard] sqlalchemy pydantic

from fastapi import FastAPI
from app.routers import products

app = FastAPI(title="Product API")

app.include_router(products.router, prefix="/products")

@app.get("/")
async def root():
    return {"message": "Welcome to Product API"}

Chạy ứng dụng với:

uvicorn app.main:app --reload

Và bạn có thể truy cập http://localhost:8000/docs để thấy giao diện Swagger.

Thiết lập database và model với SQLAlchemy

Mặc dù đồ án đơn giản, nhưng bạn vẫn cần có một database file để lưu dữ liệu.

Trong app/database.py:

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

SQLALCHEMY_DATABASE_URL = "sqlite:///./products.db"

engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
SessionLocal = sessionmaker(bind=engine, autoflush=False, autocommit=False)
Base = declarative_base()

Trong app/models.py, định nghĩa model Product:

from sqlalchemy import Column, Integer, String, Float
from .database import Base

class Product(Base):
    __tablename__ = "products"
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String, index=True, unique=True)
    price = Column(Float)
    description = Column(String, nullable=True)

Bạn sẽ tạo bảng này bằng cách gọi .create_all(bind=engine) khi chạy app.

Định nghĩa schema với Pydantic để validate dữ liệu

Schema giúp kiểm tra dữ liệu JSON đầu vào và đảm bảo cấu trúc đầu ra rõ ràng.

Trong app/schemas.py:

from pydantic import BaseModel
from typing import Optional

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

class ProductCreate(ProductBase):
    pass

class Product(ProductBase):
    id: int

    class Config:
        orm_mode = True

Với cấu trúc này, khi client gửi JSON chứa 'name', 'price', 'description', FastAPI sẽ tự validate type.

Tách riêng logic CRUD trong `crud.py`

Bạn nên viết một file riêng, giúp quản lý các thao tác với database theo đúng SOLID:

from sqlalchemy.orm import Session
from . import models, schemas

def get_product(db: Session, product_id: int):
    return db.query(models.Product).filter(models.Product.id == product_id).first()

def get_products(db: Session, skip: int =0, limit: int =100):
    return db.query(models.Product).offset(skip).limit(limit).all()

def create_product(db: Session, product: schemas.ProductCreate):
    db_item = models.Product(name=product.name, price=product.price, description=product.description)
    db.add(db_item)
    db.commit()
    db.refresh(db_item)
    return db_item

Bạn cũng có thể thêm update, delete nếu cần.

Viết endpoint trong router `products.py`

Giờ bạn chuyển sang viết endpoint bằng APIRouter:

from fastapi import APIRouter, HTTPException, Depends
from sqlalchemy.orm import Session
from app import crud, models, schemas
from app.database import SessionLocal, engine

models.Base.metadata.create_all(bind=engine)
router = APIRouter(tags=["products"])

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

@router.post("/", response_model=schemas.Product)
def create_product_endpoint(product: schemas.ProductCreate, db: Session = Depends(get_db)):
    return crud.create_product(db=db, product=product)

@router.get("/{product_id}", response_model=schemas.Product)
def read_product(product_id: int, db: Session = Depends(get_db)):
    db_product = crud.get_product(db=db, product_id=product_id)
    if db_product is None:
        raise HTTPException(status_code=404, detail="Product not found")
    return db_product

@router.get("/", response_model=list[schemas.Product])
def list_products(skip: int = 0, limit: int = 10, db: Session = Depends(get_db)):
    return crud.get_products(db=db, skip=skip, limit=limit)

Test và kiểm tra API

Bạn hãy dùng các công cụ thử như Swagger hoặc curl:

Thêm sản phẩm:

curl -X POST http://localhost:8000/products/ \
  -H 'Content-Type: application/json' -d '{"name":"Book","price":10.5}'

Xem list:

curl http://localhost:8000/products/

Xem 1 sản phẩm

curl http://localhost:8000/products/1

Nhờ Swagger UI, bạn dễ dàng thử ngay trên trình duyệt mà không cần cài thêm công cụ.

Mở rộng chức năng theo yêu cầu

Dưới đây là vài hướng mở rộng hữu ích cho đồ án:

Thêm endpoint update (PUT) và delete (DELETE).
Tích hợp phân trang, lọc giá, search name.
Xác thực người dùng bằng JWT hoặc API Key.
Kết nối với cơ sở dữ liệu lớn hơn như Postgres hoặc MySQL.
Sử dụng Alembic để quản lý migration data.
Đóng gói Docker để deploy nhanh.

Kết luận

Xây dựng một REST API đồ án bằng FastAPI là cách tuyệt vời để phát triển kỹ năng backend chuyên nghiệp. Bạn sẽ hiểu rõ cách thiết kế API chuẩn, xử lý database hiệu quả, kiểm thử bằng Swagger UI, đồng thời sẵn sàng triển khai ứng dụng thực tế chỉ trong vài ngày.

FastAPI cho phép bạn viết code sạch, rõ cấu trúc và dễ mở rộng sau này. Nếu bạn muốn liên kết với frontend, mobile hoặc mở rộng thành microservice, việc này hoàn toàn dễ dàng với nền tảng đã xây.