Cách tạo API REST với FastAPI và MongoDB

Tiếp theo, hãy kiểm tra xem bạn có đang chạy Python phiên bản 3.6 trở lên không. Nếu không, hãy cài đặt phiên bản Python mới nhất.

 python --version 

Sau đó, cài đặt Virtualenv để tạo môi trường phát triển ảo biệt lập. Điều này rất được khuyến khích vì nó cho phép bạn tránh xung đột, đặc biệt nếu bạn đang sử dụng các phiên bản gói khác nhau cho các dự án khác nhau.

 pip install virtualenv 

Tiếp theo, tạo một môi trường ảo có tên “venv” trong thư mục hiện tại của bạn:

 virtualenv venv 

Cuối cùng, kích hoạt môi trường ảo.

 # On Unix or MacOS: 
source venv/bin/activate
# On Windows:
 .venvScriptsactivate 

Khi bạn đã định cấu hình môi trường ảo, hãy cài đặt các gói FastAPI, PyMongo và Uvicorn.

 pip install fastapi pymongo uvicorn 

PyMongo là một thư viện dựa trên Python để làm việc với cơ sở dữ liệu MongoDB. Nó cung cấp một API hỗ trợ tất cả các tính năng của MongoDB và cho phép bạn tương tác với MongoDB mà không cần phải viết các truy vấn MongoDB thô.

Mặt khác, Uvicorn là một máy chủ web không đồng bộ dựa trên mô-đun asyncio của Python. Tính năng chính của nó là tải lại nóng các máy chủ FastAPI của bạn khi đang di chuyển. Sử dụng Uvicorn, tương tự như làm việc với Nodemon.

Tạo máy chủ FastAPI

Cuối cùng, hãy tạo một máy chủ FastAPI đơn giản để lắng nghe các yêu cầu đến từ tuyến nhà. Trong thư mục gốc của thư mục dự án của bạn, hãy tạo tệp server.py và thêm mã bên dưới.

 from fastapi import FastAPI
app = FastAPI()
@app.get("https://www.smartreviewaz.com/")
async def home():
    return {"message": "Hello World"} 

Cuối cùng, hãy chạy lệnh bên dưới để khởi động máy chủ phát triển. Uvicorn sẽ phục vụ ứng dụng của bạn trên cổng 8000.

 uvicon server:app --reload 

Tiếp tục và xem phản hồi của máy chủ trên trình duyệt của bạn tại http://localhost:8000.

Tạo API REST với các hoạt động CRUD

Bây giờ hãy xây dựng API REST triển khai các phương thức CRUD (tạo, đọc, cập nhật và xóa). Trong thư mục gốc của thư mục dự án của bạn, tạo bốn thư mục: cấu hình, mô hình, tuyến đường và lược đồ.

 ├── config
├── models
├── routes
├── schemas
└── server.py 

1. Cấu hình kết nối cơ sở dữ liệu

Trong thư mục cấu hình, tạo một tệp mới, db.py và thêm mã bên dưới.

 from pymongo import MongoClient
db_connection = MongoClient("mongodb://localhost:27017")
db = db_connection.database_name
collection = db["collection_name"] 

• Sử dụng phương thức MongoClient() để tạo kết nối tới cơ sở dữ liệu MongoDB. Nó lấy một chuỗi URI kết nối làm đối số chỉ định máy chủ và cổng của máy chủ MongoDB.
• Hai biến chỉ định cơ sở dữ liệu và bộ sưu tập nào trong máy chủ MongoDB của bạn mà máy chủ sẽ truy cập.

2. Xác định Mô hình Dữ liệu

Mô hình này sẽ xác định cấu trúc dữ liệu của bạn trong cơ sở dữ liệu bao gồm các trường và kiểu dữ liệu.

Trong thư mục mô hình, tạo một tệp mới, user_model.py và thêm mã bên dưới.

 from pydantic import BaseModel 
class User(BaseModel):
    name: str
    role: str 

• Đoạn mã trên tạo một lớp được gọi là Người dùng, là lớp con của lớp BaseModel từ thư viện Pydantic. Lớp Người dùng có hai trường, tên và vai trò với kiểu dữ liệu của chúng được đặt thành chuỗi.
• Bạn có thể sử dụng thư viện Pydantic với FastAPI để tạo mô hình dữ liệu. Bạn cũng có thể sử dụng nó để xác thực dữ liệu, tuần tự hóa dữ liệu (JSON thành Python) và hủy tuần tự hóa dữ liệu (Python thành JSON).

3. Xác định lược đồ dữ liệu

Từ mô hình dữ liệu đã tạo, bạn có thể xác định lược đồ cho dữ liệu của mình. Trong thư mục lược đồ, hãy tạo một tệp mới: user_schema.py và thêm mã bên dưới.

 def user_serializer(user) -> dict:
    return {
        'id':str(user["_id"]),
        'name':user["name"],
        'role':user["role"]
    }
def users_serializer(users) -> list:
    return [user_serializer(user) for user in users] 

4. Xác định các tuyến API

Cuối cùng, xác định các tuyến đường cho các hoạt động CRUD khác nhau.

Trong thư mục routes, tạo một tệp mới: user_routes.py và thêm mã bên dưới.

Thêm dữ liệu bằng phương thức đăng

Tạo tuyến bài đăng để thêm dữ liệu.

 from fastapi import APIRouter
from models.user_model import User
from schemas.user_schema import users_serializer
from bson import ObjectId
from config.db import collection
user = APIRouter()
@user.post("https://www.smartreviewaz.com/")
async def create_user(user: User):
    _id = collection.insert_one(dict(user))
    user = users_serializer(collection.find({"_id": _id.inserted_id}))
    return {"status": "Ok","data": user} 

• FastAPI cung cấp phương thức APIRouter() xác định đối tượng bộ định tuyến cung cấp giao diện để thực hiện các yêu cầu API tới máy chủ.
• Chỉ định tuyến đường đăng tạo đối tượng người dùng mới trong cơ sở dữ liệu bằng cách chèn dữ liệu vào bộ sưu tập sau khi tuần tự hóa nó. Tiếp theo, lưu trữ và chuyển insert_id để tìm dữ liệu liên kết trong bộ sưu tập và cuối cùng, trả về trạng thái “Ok” với dữ liệu trong phản hồi, nếu yêu cầu đăng thành công.
• Các phương thức insert_one và find được xác định bởi ứng dụng khách PyMongo.

Bây giờ, hãy thêm mã bên dưới vào server.py để khởi tạo các tuyến.

 from routes.user_routes import user
app.include_router(user) 

Hãy tiếp tục và kiểm tra lộ trình đăng bài trên trình duyệt của bạn bằng công cụ API giao diện người dùng Swagger được cung cấp bởi FastAPI.

Đọc dữ liệu với phương thức Get

Sau khi xác định post route và khởi tạo các route, hãy xác định phần còn lại của các route khác.

 @user.get("https://www.smartreviewaz.com/")
async def find_all_users():
    users = users_serializer(collection.find())
    return {"status": "Ok","data": users}
            
@user.get("/{id}")
async def get_one_user(id: str):
   user = users_serializer(collection.find({"_id": ObjectId(id)}))
   return {"status": "Ok","data": user} 

Xác định hai tuyến nhận truy xuất tất cả dữ liệu trong bộ sưu tập và truy xuất dữ liệu cụ thể từ bộ sưu tập dựa trên ID.

Cập nhật dữ liệu với phương thức Put

Tạo put route để cập nhật dữ liệu được lưu trữ trong cơ sở dữ liệu.

 @user.put("/{id}")
async def update_user(id: str, user: User):
    collection.find_one_and_update(
        {
          "_id": ObjectId(id)
        }, 
        {
         "$set": dict(user)
        })
    user = users_serializer(collection.find({"_id": ObjectId(id)}))
    return {"status": "Ok","data": user} 

Phương thức put sử dụng ID để tìm dữ liệu cụ thể trong bộ sưu tập và cập nhật giá trị của các trường trong tài liệu với dữ liệu mới được chuyển từ API. Sau đó, bạn có thể tìm kiếm dữ liệu được cập nhật theo ID và gửi lại dữ liệu đó trong phản hồi API.

Xóa dữ liệu bằng phương thức Delete

Tạo tuyến xóa để xóa dữ liệu được lưu trữ trong cơ sở dữ liệu.

 @user.delete("/{id}")
async def delete_user(id: str):
   collection.find_one_and_delete({"_id": ObjectId(id)})
   users = users_serializer(collection.find())
   return {"status": "Ok","data": []}  

Lộ trình xóa lấy ID của tài liệu cụ thể mà bạn muốn xóa khỏi bộ sưu tập.

Tạo API REST với FastAPI

FastAPI cung cấp một cách tuyệt vời để thuận tiện xây dựng các API web Python phụ trợ. Các công cụ tích hợp sẵn của nó để tích hợp cơ sở dữ liệu và sản xuất API tự động giúp quy trình trở nên đơn giản.

Bạn thậm chí có thể tiến thêm một bước nữa và xây dựng các ứng dụng hoàn chỉnh. Hãy thử tích hợp ứng dụng khách đầu cuối bằng các công nghệ phổ biến như React, Angular hoặc Vue.