🚀 Xây Dựng Máy Chủ Giả Mạnh Mẽ Với FastAPI

Khi các đội ngũ frontend hoặc tích hợp bị chặn lại vì chờ đợi API thực, một máy chủ giả có thể cứu nguy. Thay vì chờ đợi hàng tuần cho các endpoint backend, bạn có thể khởi động một dịch vụ giả hoàn chỉnh chỉ trong vài phút bằng cách sử dụng FastAPI.

Trong hướng dẫn này, chúng ta sẽ xây dựng một máy chủ giả FastAPI mở rộng hỗ trợ:

• ✅ APIs CRUD với phản hồi JSON
• ✅ Tải xuống và tải lên tệp
• ✅ Giả lập độ trễ và mã lỗi
• ✅ Tài liệu Swagger/OpenAPI tự động sinh
• ✅ Chạy nhiều dịch vụ giả
• ✅ Triển khai qua Docker

Hãy cùng khám phá.

🔹 Tại Sao Chọn FastAPI Cho Máy Chủ Giả?

Python cung cấp một số cách để khởi động máy chủ giả (http.server, Flask, v.v.), nhưng FastAPI nổi bật hơn vì:

• Nó hiện đại và hỗ trợ async (tuyệt vời cho việc xử lý yêu cầu đồng thời).
• Tự động tạo Swagger UI tương tác tại /docs.
• Cung cấp xác thực dữ liệu với các mô hình Pydantic.
• Cảm giác gần giống với backend sản xuất, giúp kiểm thử thực tế hơn.

🔹 Bước 1: Máy Chủ Giả FastAPI Cơ Bản

Hãy bắt đầu với một máy chủ tối thiểu.

from fastapi import FastAPI

app = FastAPI()

@app.get("/ping")
def ping():
    return {"message": "pong"}

Chạy nó:

uvicorn app:app --reload --port 8000

👉 Truy cập: http://localhost:8000/ping → {"message": "pong"}
👉 Swagger UI: http://localhost:8000/docs

🔹 Bước 2: Thêm Các Endpoint CRUD

Hãy giả lập một API Người Dùng đơn giản với GET, POST, PUT và DELETE.

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List

app = FastAPI(title="Mock User API")

class User(BaseModel):
    id: int
    name: str

users: List[User] = [User(id=1, name="Alice")]

@app.get("/users", response_model=List[User])
def get_users():
    return users

@app.get("/users/{user_id}", response_model=User)
def get_user(user_id: int):
    for u in users:
        if u.id == user_id:
            return u
    raise HTTPException(status_code=404, detail="User not found")

@app.post("/users", response_model=User, status_code=201)
def create_user(user: User):
    users.append(user)
    return user

@app.put("/users/{user_id}", response_model=User)
def update_user(user_id: int, updated: User):
    for i, u in enumerate(users):
        if u.id == user_id:
            users[i] = updated
            return updated
    raise HTTPException(status_code=404, detail="User not found")

@app.delete("/users/{user_id}")
def delete_user(user_id: int):
    global users
    users = [u for u in users if u.id != user_id]
    return {"message": "deleted"}

✅ Giờ đây bạn đã có một API Người Dùng giả với đầy đủ CRUD.
✅ Kiểm thử nó trong Swagger UI (/docs).

🔹 Bước 3: Phục Vụ Tệp (Tải Xuống)

Bạn có thể muốn thử nghiệm tải xuống tệp (ví dụ: PDF, hình ảnh).

from fastapi.responses import FileResponse
import os

FILES_DIR = "files"
os.makedirs(FILES_DIR, exist_ok=True)

# tạo một tệp mẫu
with open(f"{FILES_DIR}/sample.txt", "w") as f:
    f.write("Đây là một tệp giả")

@app.get("/files/{filename}")
def download_file(filename: str):
    path = os.path.join(FILES_DIR, filename)
    if not os.path.exists(path):
        raise HTTPException(status_code=404, detail="File not found")
    return FileResponse(path, media_type="application/octet-stream", filename=filename)

👉 Giờ bạn có thể truy cập: http://localhost:8000/files/sample.txt để tải xuống tệp giả.

🔹 Bước 4: Tải Lên Tệp

from fastapi import UploadFile, File

@app.post("/files/upload")
async def upload_file(file: UploadFile = File(...)):
    file_path = os.path.join(FILES_DIR, file.filename)
    with open(file_path, "wb") as f:
        content = await file.read()
        f.write(content)
    return {"filename": file.filename}

✅ Bây giờ bạn có thể tải lên tệp qua Swagger UI và tải xuống chúng sau đó.

🔹 Bước 5: Tăng Cường Tính Thực Tế (Độ Trễ & Lỗi)

Các máy chủ giả không nên luôn trả về 200 OK ngay lập tức. Bạn có thể giả lập độ trễ mạng và mã lỗi.

import time, random

@app.get("/unstable")
def unstable_endpoint():
    # Giả lập độ trễ ngẫu nhiên
    delay = random.uniform(0.5, 2.0)
    time.sleep(delay)

    # Giả lập lỗi ngẫu nhiên
    if random.random() < 0.3:  # 30% khả năng thất bại
        raise HTTPException(status_code=500, detail="Lỗi máy chủ ngẫu nhiên")

    return {"message": f"Thành công sau {delay:.2f}s"}

✅ Điều này giúp các đội frontend kiểm thử logic retry và xử lý lỗi.

🔹 Bước 6: Chạy Nhiều Dịch Vụ Giả

Nếu hệ thống của bạn có microservices, bạn có thể chạy nhiều ứng dụng FastAPI:

• users_mock/app.py → /users/*
• orders_mock/app.py → /orders/*

Chạy chúng trên các cổng khác nhau:

uvicorn users_mock.app:app --port 8001
uvicorn orders_mock.app:app --port 8002

Hoặc tổ chức chúng với Docker Compose:

version: "3.8"
services:
  users:
    build: ./users_mock
    ports: ["8001:8000"]
  orders:
    build: ./orders_mock
    ports: ["8002:8000"]

🔹 Bước 7: Tài Liệu API Tự Động Sinh

Một trong những lợi thế lớn nhất của FastAPI:

• /docs → Swagger UI (kiểm thử tương tác)
• /redoc → Tài liệu API Redoc

Bạn có thể chia sẻ những URL này với các nhà phát triển frontend để họ biết chính xác những gì mong đợi.

🔹 Bước 8: Triển Khai Với Docker

Tạo một Dockerfile đơn giản:

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

Xây dựng & chạy:

docker build -t mock-api .
docker run -p 8000:8000 mock-api

Bây giờ API giả của bạn có thể chạy ở bất kỳ đâu — cục bộ, trong các pipeline CI, hoặc trên đám mây.

🔹 Bước 9: Nâng Cao Chất Lượng

Bạn có thể cải thiện các máy chủ giả hơn nữa bằng cách:

• Thư viện Faker → tạo tên người dùng, địa chỉ, email giả.
• Phiên bản API → /v1/users, /v2/users.
• Cấu hình môi trường → cho phép chuyển đổi giữa API thực và giả.
• Máy chủ giả dựa trên cơ sở dữ liệu → thay vì lưu trong bộ nhớ, sử dụng SQLite/tệp JSON để đảm bảo tính liên tục.

Ví dụ với Faker:

from faker import Faker
fake = Faker()

@app.get("/random-user")
def random_user():
    return {"id": fake.random_int(), "name": fake.name()}

🔹 Tóm Tắt

Với FastAPI, bạn có thể tạo một máy chủ giả cảm giác thực:

• ✅ Phục vụ tệp tĩnh & tải xuống
• ✅ Xử lý tải lên tệp
• ✅ Cung cấp API CRUD đầy đủ
• ✅ Giả lập độ trễ, lỗi và các endpoint không ổn định
• ✅ Chạy nhiều dịch vụ với Docker
• ✅ Tự động tạo tài liệu API

Bằng cách đầu tư một chút công sức, đội ngũ của bạn có thể có một môi trường giống sản xuất trước khi backend thậm chí còn tồn tại — giúp cho frontend, QA, và DevOps phát triển nhanh chóng.

💡 Mẹo chuyên nghiệp: Đặt các máy chủ giả FastAPI của bạn vào một repo riêng biệt và tích hợp chúng vào các pipeline CI/CD. Bằng cách này, đội ngũ của bạn có thể luôn kiểm thử chống lại một môi trường API nhất quán và có thể dự đoán được.