Cách cài đặt Fast API với MongoDB trên Ubuntu 24.04

[theanh]

FastAPI là một khuôn khổ web dựa trên Python để tạo các dịch vụ API. Đây là một khuôn khổ hiện đại, nhanh và hiệu suất cao hỗ trợ các hoạt động không đồng bộ.

Trong hướng dẫn này, bạn sẽ tìm hiểu cách cài đặt FastAPI với MongoDB trên Ubuntu 24.04. Bạn cũng sẽ tìm hiểu cách tạo API đầu tiên của mình với các hoạt động CRUD bằng FastAPI và cơ sở dữ liệu MongoDB.

Điều kiện tiên quyết​

Để bắt đầu với hướng dẫn này, hãy đảm bảo rằng bạn có những điều sau:

• Hệ thống Ubuntu 24.04
• Người dùng không phải root có quyền quản trị viên

Cài đặt MongoDB​

Trước khi tạo một dự án FastAPI mới, hãy cài đặt máy chủ MongoDB vào hệ thống của chúng ta.

Trước tiên, hãy chạy lệnh bên dưới để cập nhật chỉ mục gói của bạn và cài đặt 'gnupg' và 'curl' vào hệ thống.

sudo apt update && sudo apt install gnupg curl -y

Thực hiện lệnh bên dưới để thêm khóa GPG cho máy chủ MongoDB.

curl -fsSL https://www.mongodb.org/static/pgp/server-8.0.asc | \
sudo gpg -o /usr/share/keyrings/mongodb-server-8.0.gpg \
--dearmor

Thêm kho lưu trữ MongoDB bằng lệnh bên dưới.

echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-8.0.gpg ] https://repo.mongodb.org/apt/ubuntu noble/mongodb-org/8.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-8.0.list

Sau khi kho lưu trữ được thêm vào, hãy chạy lệnh sau để làm mới chỉ mục gói của bạn và cài đặt máy chủ MongoDB. Nhập 'Y' để xác nhận cài đặt.

sudo apt update && sudo apt install mongodb-org

data:image/svg+xml,%3Csvg%20xmlns=%22http://www.w3.org/2000/svg%22%20width=%22750%22%20height=%22143%22%3E%3C/svg%3E


Khi quá trình cài đặt hoàn tất, hãy khởi động và bật dịch vụ 'mongod' của MongoDB, sau đó kiểm tra trạng thái dịch vụ MongoDB của bạn để đảm bảo dịch vụ đang chạy.

sudo systemctl enable --now mongod
sudo systemctl status mongod

Bạn có thể thấy bên dưới rằng máy chủ MongoDB đang chạy.


data:image/svg+xml,%3Csvg%20xmlns=%22http://www.w3.org/2000/svg%22%20width=%22750%22%20height=%22215%22%3E%3C/svg%3E


Ngoài ra, bạn có thể đăng nhập vào máy chủ MongoDB bằng lệnh 'mongosh' bên dưới. Để thoát, hãy nhấn Ctrl+d.

mongosh

Thiết lập Python và Môi trường ảo​

Sau khi cài đặt MongoDB, bạn sẽ cài đặt các gói Python và thiết lập thư mục dự án và môi trường ảo.

Cài đặt các mô-đun Python, Pip và Venv bằng lệnh sau. Nhập 'Y' để xác nhận cài đặt.

sudo apt install python3 python3-pip python3-venv

data:image/svg+xml,%3Csvg%20xmlns=%22http://www.w3.org/2000/svg%22%20width=%22750%22%20height=%22295%22%3E%3C/svg%3E


Sau khi cài đặt hoàn tất, hãy đăng nhập vào người dùng.

su - username

Bây giờ hãy tạo một thư mục '~/app' mới và di chuyển vào đó. Thư mục này sẽ được sử dụng để lưu trữ dự án FastAPI của bạn.

mkdir -p ~/app; cd ~/app

Thực hiện lệnh bên dưới để tạo một môi trường ảo 'venv' mới và kích hoạt nó. Với lệnh này, dấu nhắc shell của bạn sẽ trở thành '(venv) user@hostname'.

python3 -m venv .venv
source .venv/bin/activate

data:image/svg+xml,%3Csvg%20xmlns=%22http://www.w3.org/2000/svg%22%20width=%22566%22%20height=%22159%22%3E%3C/svg%3E


Từ đây, môi trường làm việc của bạn phải nằm trên môi trường ảo 'venv'. Bạn có thể đăng xuất khỏi 'venv' bằng lệnh bên dưới.

deactivate

Tạo dự án FastAPI​

Bây giờ bạn đã tạo và kích hoạt môi trường ảo Python của mình, hãy cài đặt FastAPI và tạo cấu trúc dự án.

Với lệnh 'pip3', hãy thực thi lệnh này để cài đặt 'fastapi' và 'uvicorn' packages.

pip3 install fastapi uvicorn

• 'Fastapi' là khuôn khổ web FastAPI chính để xây dựng API trong Python
• 'Uvicorn' là triển khai máy chủ web ASGI (Giao diện cổng máy chủ không đồng bộ) trong Python.

Sau khi cài đặt hoàn tất, hãy tạo các tệp và thư mục mới bằng lệnh sau lệnh.

mkdir -p server/{models,routes}
touch main.py server/{app.py,database.py} server/models/itemModels.py server/routes/item.py

Dưới đây là cấu trúc dự án FastAPI của chúng tôi.


data:image/svg+xml,%3Csvg%20xmlns=%22http://www.w3.org/2000/svg%22%20width=%22418%22%20height=%22371%22%3E%3C/svg%3E

server/app.py​

Bây giờ dự án của bạn đã sẵn sàng, hãy sửa đổi tệp 'server/app.py', đây là ứng dụng chính của dự án FastAPI của bạn.

Mở tệp 'app.py' bằng trình soạn thảo văn bản của bạn và sao chép tập lệnh sau.

from fastapi import FastAPI

app = FastAPI()

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

• Nhập mô-đun FastAPI vào dự án của bạn và liên kết nó với biến 'app'
• Tạo một hàm 'root' mới trả về 'Hello FastAPI!'
• Hàm 'root' phản hồi phương thức GET trên URL gốc
• 'async' đánh dấu hàm của bạn là hàm bất đồng bộ và có thể sử dụng 'await' trong phần thân của nó khi được gọi

main.py​

Trong phần này, chúng ta sẽ sửa đổi tệp 'main.py' sẽ được sử dụng để chạy dự án FastAPI của bạn thông qua 'uvicorn' (máy chủ web ASGI trong Python).

Bây giờ hãy mở và sửa đổi tập lệnh 'main.py' và chèn mã sau.

import uvicorn

if __name__ == "__main__":
 uvicorn.run("server.app:app", host="0.0.0.0", port=8080, reload=True)

• Nhập mô-đun 'uvicorn'
• Khi tập lệnh 'main.py' được thực thi, nó sẽ tải mô-đun 'app' hoặc FastAPI trong 'server/app.py'
• FastAPI sẽ là chạy trên '0.0.0.0' với cổng '8080'
• Bật tính năng tự động tải lại khi mã thay đổi thông qua 'reload=True'

Chạy dự án FastAPI của bạn​

Bây giờ dự án của bạn đã sẵn sàng, hãy chạy dự án FastAPI đầu tiên của bạn.

Thực thi tập lệnh 'main.py' như sau và FastAPI của bạn sẽ chạy trên hệ thống của bạn.

python3 main.py

data:image/svg+xml,%3Csvg%20xmlns=%22http://www.w3.org/2000/svg%22%20width=%22750%22%20height=%22208%22%3E%3C/svg%3E


Bây giờ hãy mở trình duyệt web của bạn và truy cập http://SERVERIP:8080/. Nếu cài đặt thành công, bạn sẽ thấy thông báo 'Hello FastAPI!'. Bạn cũng có thể truy cập thông báo này qua 'curl' từ terminal.

Cuối cùng, bạn có thể truy cập tài liệu API trên http://SERVERIP:8080/docs> được cung cấp bởi Swagger UI.


data:image/svg+xml,%3Csvg%20xmlns=%22http://www.w3.org/2000/svg%22%20width=%22750%22%20height=%22453%22%3E%3C/svg%3E

Kết nối FastAPI với MongoDB​

Trong hướng dẫn này, bạn sẽ tạo một API cơ bản với FastAPI và MongoDB. API của bạn phải có khả năng CRUD với máy chủ cơ sở dữ liệu MongoDB. Đối với bước này, bạn sẽ kết nối dự án của mình với máy chủ MongoDB.

Trước tiên, hãy chạy lệnh 'pip3' bên dưới để cài đặt trình điều khiển MongoDB 'motor' vào dự án của bạn. 'motor' cung cấp quyền truy cập API không chặn và dựa trên coroutine vào máy chủ MongoDB.

pip3 install motor

server/database.py​

Sau khi mô-đun 'motor' được cài đặt, hãy sửa đổi tập lệnh 'server/database.py'.

Mở tệp 'server/database.py' bằng trình soạn thảo văn bản của bạn và nhập tập lệnh sau. Điều này sẽ được sử dụng để kết nối với máy chủ MongoDB thông qua mô-đun 'motor'.

from motor.motor_asyncio import AsyncIOMotorClient

MONGODB_HOST = "mongodb://localhost:27017"

connection = AsyncIOMotorClient(MONGODB_HOST)

database = connection.items
item_collection = database.get_collection("item_collection")

• Nhập 'AsyncIOMotorClient' từ 'motor.motor_asyncio'
• Tạo hằng số mới 'MONGODB_HOST' và trỏ đến máy chủ MongoDB 'mongodb://localhost:27017'
• Kết nối với máy chủ MongoDB thông qua biến 'connection'
• Kết nối với cơ sở dữ liệu 'items' thông qua biến 'database'
• Truy cập các bộ sưu tập trên cơ sở dữ liệu bằng biến 'item_collection'

Tạo mô hình cơ sở dữ liệu bằng pydantic​

Trong phần này, bạn sẽ thiết kế dữ liệu của mình thông qua 'pydantic', cung cấp mô hình cho cơ sở dữ liệu MongoDB của chúng tôi.

Cài đặt mô-đun 'pydantic' bằng lệnh 'pip3' bên dưới. Mô-đun 'pydantic' là thư viện xác thực dữ liệu cho phép bạn tạo lược đồ cơ sở dữ liệu thông qua mô hình.

pip3 install pydantic

Bây giờ hãy mở tệp 'server/models/itemModels.py' bằng trình soạn thảo văn bản của bạn và sao chép tập lệnh sau.

from pydantic import BaseModel, Field
from typing import Optional

class Item(BaseModel):
 name: str
 category: str
 stocks: int
 price: int = Field(gt=0)

 class Config:
 json_schema_extra = {
 "example": {
 "name": "Company Smart Watch",
 "category": "smartwatch",
 "stocks": 10,
 "price": 1000,
 }
 }

class ItemUpdate(BaseModel):
 name: Optional[str] = None
 category: Optional[str] = None
 stocks: Optional[int] = None
 price: Optional[int] = None

 class Config:
 json_schema_extra = {
 "example": {
 "name": "New Smart watch",
 "category": "new-smartwatch",
 "stocks": 5,
 "price": 500,
 }
 }

• Nhập các mô-đun 'BaseModel' và 'Field' từ 'pydantic'
• Nhập mô-đun 'Tùy chọn' từ 'typing'
• Tạo lược đồ cơ sở dữ liệu 'Mục' sau cho FastAPI:'tên' và 'danh mục' với kiểu chuỗi
• 'cổ phiếu' và 'giá' với số nguyên danh mục
• 'giá' phải lớn hơn 0

[*] Mở rộng mô hình dữ liệu thông qua lớp 'Config' bằng cách cung cấp ví dụ về dữ liệu mà người dùng có thể đưa vào yêu cầu
[*] Tạo lược đồ 'ItemUpdate' sau với mọi trường là tùy chọn.

Thêm các hoạt động CRUD​

Tại thời điểm này, bạn đã tạo kết nối đến máy chủ MongoDB và tạo lược đồ cơ sở dữ liệu thông qua 'pydantic'. Chúng ta hãy chuyển sang tạo các hoạt động CRUD với FastAPI và MongoDB.

Mở lại tập lệnh 'server/database.py' và tạo một hàm mới 'item_helper' với kiểu 'dict'. Gọi hàm này để lấy dữ liệu chi tiết về một mục.

def item_helper(item) -> dict:
 return {
 "id": str(item["_id"]),
 "name": item["name"],
 "category": item["category"],
 "stocks": item["stocks"],
 "price": item["price"],
 }

Thêm dòng sau để nhập mô-đun 'ObjectId' từ 'bson.objectid'. 'ObjectId' là một phần của kiểu dữ liệu trong BSON, mà MongoDB sử dụng để lưu trữ dữ liệu và biểu diễn dữ liệu JSON.

from bson.objectid import ObjectId

Tạo một mục​

Đầu tiên, bạn sẽ tạo một hàm bất đồng bộ có thể thêm dữ liệu mới vào cơ sở dữ liệu MongoDB.

Tạo một hàm mới 'add_item' như sau:

# Add a new item
async def add_item(item_details: dict) -> dict :
 item = await item_collection.insert_one(item_details)
 new_item = await item_collection.find_one({"_id": item.inserted_id})
 return item_helper(new_item)

• Hàm 'add_item' chấp nhận dữ liệu từ điển về chi tiết mục của bạn
• Thông qua 'item_collection' để truy cập các tài liệu trong cơ sở dữ liệu và thực hiện truy vấn 'insert_one' để thêm mục mới
• Mục mới sẽ được in ra sau khi hoạt động thành công

Lấy tất cả các mục​

Thứ hai, bạn sẽ tạo một hàm mới 'get_items' có thể lấy tất cả các mục có sẵn trong cơ sở dữ liệu của bạn.

Tạo một hàm mới 'get_items' để lấy tất cả các mục từ MongoDB.

# retrieve all items
async def get_items():
 items = []
 async for item in item_collection.find():
 items.append(item_helper(item))
 return items

• Bạn sẽ tạo một danh sách 'mục' trống
• Sử dụng truy vấn 'find()' để tìm kiếm tất cả dữ liệu và lặp qua nó
• Mỗi mục sẽ được thêm vào danh sách 'mục' thông qua phương thức 'append'
• Sau khi vòng lặp hoàn tất, các mục của bạn sẽ được hiển thị

Lấy mục cụ thể dựa trên id​

Tiếp theo, bạn sẽ tạo một hàm mới có thể lấy dữ liệu cho bộ chọn cụ thể 'id'. Thao tác này sẽ hiển thị cho bạn dữ liệu chi tiết về các mục cụ thể.

Tạo hàm mới 'get_item' để lấy dữ liệu của các mục cụ thể. Hàm 'get_item' sẽ chấp nhận một chuỗi 'id' làm bộ chọn và trả về một từ điển.

# retrieve specific item
async def get_item(id: str) -> dict:
 item = await item_collection.find_one({"_id": ObjectId(id)})
 if item:
 return item_helper(item)
 return "Item Not Found."

• Truy vấn 'find_one()' sẽ được sử dụng để truy xuất dữ liệu dựa trên 'id'
• Nếu tìm thấy một mục, thông tin chi tiết sẽ được hiển thị bằng định dạng từ điển 'item_helper'
• Nếu mục không khả dụng, phản hồi là 'Không tìm thấy mục'

Cập nhật một mục​

Bây giờ bạn sẽ tạo một hàm mới để cập nhật một mục. Bạn cũng có thể cập nhật một phần mục của mình thông qua API.

Xác định hàm mới 'change_item' như các mã sau:

# update item
async def change_item(id: str, data: dict):
 if len(data) < 1:
 return "Please input your data"
 find_item = await item_collection.find_one({"_id": ObjectId(id)})
 if find_item:
 item_update = await item_collection.update_one({"_id": ObjectId(id)}, {"$set": data})
 if item_update:
 return True
 return False

• Hàm 'change_item' lấy hai đối số, 'id' của mục đích và 'data' làm dữ liệu mới
• Nếu dữ liệu trống hoặc '< 1', hoạt động đã kết thúc
• Hàm này sẽ tìm một mục dựa trên bộ chọn 'id'
• Nếu tìm thấy 'id', 'item_update' sẽ được thực thi
• Nếu 'item_update' thành công, trả về 'True' hoặc trả về 'False' nếu không

Xóa một mục​

Cuối cùng, bạn sẽ tạo hàm 'delete_item' để xóa các mục thông qua một bộ chọn cụ thể.

Để xóa một mục, chúng ta sẽ tạo hàm 'delete_item' và sử dụng bộ chọn 'id' như sau:

# delete an item
async def delete_item(id: str):
 item = await item_collection.find_one({"_id": ObjectId(id)})
 if item:
 await item_collection.delete_one({"_id": ObjectId(id)})
 return(f'Item {id} deleted.')
 return "Item Not Found."

• Truy vấn 'find_one()' sẽ tìm kiếm một mục dựa trên 'id' được cung cấp
• Nếu tìm thấy mục, mục đó sẽ bị xóa thông qua truy vấn 'delete_one()' và trả về 'ID mục đã xóa'
• Nếu mục không khả dụng, 'Không tìm thấy mục' sẽ được hiển thị

Thêm tuyến cho hoạt động CRUD​

Tại thời điểm này, chúng tôi đã tạo các hàm không đồng bộ cho hoạt động CRUD với FastAPI. Bây giờ chúng ta hãy tạo tuyến đường hoặc điểm cuối cho từng hoạt động.

Chỉnh sửa tệp 'server/routes/item.py' bằng trình soạn thảo bạn thích.

server/routes/item.py​

Đầu tiên, thêm các mô-đun 'APIRouter' và 'Body' từ 'fastapi'. Sau đó, thêm 'jsonable_encode' từ 'fastapi.encoders'.

from fastapi import APIRouter, Body
from fastapi.encoders import jsonable_encoder

Nhập từng hàm từ tệp 'database.py'.

from server.database import (
 add_item,
 get_items,
 get_item,
 change_item,
 delete_item,
)

Nhập các mô hình 'Item' và 'ItemUpdate' từ 'itemModels.py' file.

from server.models.itemModels import (
 Item,
 ItemUpdate,
)

Gọi lớp 'APIRouter' thông qua biến 'router'.

router = APIRouter()

Tuyến đường để thêm mục mới​

Bây giờ chúng ta hãy thêm một tuyến đường để thêm mục mới. Trong ví dụ này, bạn có thể thêm một mục mới thông qua POST vào URL '/item'.

Thêm các dòng sau để thiết lập các tuyến đường để thêm các mục mới. Mỗi POST tới URL gốc của mục sẽ được coi là chèn dữ liệu mới.

# add new item operation
@router.post("/")
async def add_item_data(item: Item = Body(...)):
 item = jsonable_encoder(item)
 new_item = await add_item(item)
 return new_item

• Hàm 'add_item_data' chấp nhận lược đồ 'Item', lược đồ này sẽ là một phần của 'Body' theo yêu cầu của bạn
• Mục của bạn sẽ được chuyển đổi sang định dạng từ điển thông qua 'jsonable_encoder'
• Chèn dữ liệu từ điển của bạn thông qua hàm 'add_item' (xem database.py) ở đầu biến 'new_item'
• Trả về dữ liệu đã chèn 'new_item' dưới dạng phản hồi

Tuyến đường lấy tất cả các mục​

Thêm đoạn mã sau để thiết lập tuyến đường truy xuất dữ liệu. Mỗi yêu cầu GET tới URL mục gốc sẽ truy xuất tất cả dữ liệu của bạn.

# get all available items
@router.get("/")
async def get_item_data():
 items = await get_items()
 if items:
 return items
 return "No available item."

• Tạo hàm 'get_item_data' sẽ thực thi hàm 'get_item' từ tệp 'database.py'
• Nếu có mục, bạn sẽ nhận được danh sách tất cả các mục của mình
• Nếu không có mục nào, bạn sẽ nhận được phản hồi 'Không có mục nào khả dụng'

Tuyến đường để lấy mục cụ thể​

Để lấy thông tin chi tiết về một mục cụ thể, chúng ta sẽ sử dụng 'id' làm bộ chọn. Mỗi yêu cầu GET tới '/id' sẽ trả về một mục chi tiết của 'id' được yêu cầu.

# Show details of the item via the id
@router.get("/{id}")
async def get_item_details(id):
 item_details = await get_item(id)
 if item_details:
 return item_details
 return "Item not found."

• Hàm 'get_item_details' sẽ được tạo và truyền 'id' từ URL
• Hàm 'get_item' (xem database.py) sẽ được gọi và cũng truyền 'id' làm đối số
• Nếu tìm thấy mục, thông tin chi tiết về mục sẽ được hiển thị
• Nếu không có mục nào có 'id' cụ thể đó, bạn sẽ nhận được 'Không tìm thấy mục'

Tuyến đường để cập nhật một mục​

Sao chép mã sau để thiết lập tuyến đường cho mục đã cập nhật:

# Update Item
@router.put("/{id}")
async def update_item(id: str, data: ItemUpdate = Body(...)):
 data = {k: v for k, v in data.dict().items() if v is not None}
 updated_item = await change_item(id, data)
 if updated_item:
 return{f'Success: item {id} updated.'}
 return "Error"

• Hàm 'update_item' sẽ lấy hai đối số, 'id' làm bộ chọn và 'data', dựa trên mô hình 'ItemUpdate'
• Dữ liệu sẽ được kiểm tra trong biến 'data'
• 'updated_item' sẽ thực thi hàm 'change_item' từ tệp 'database.py'
• Nếu cập nhật thành công, bạn sẽ thấy đầu ra 'Thành công'

Tuyến đường xóa một mục​

Chèn các dòng sau để tạo hàm 'remove_item' để xóa các mục. Mỗi thao tác DELETE đối với một '/id' cụ thể sẽ xóa mục khớp với 'id'.

# delete item via id
@router.delete("/{id}")
async def remove_item(id):
 item_to_delete = await delete_item(id)
 if item_to_delete:
 return item_to_delete
 return{f'Item {id} Not Available.'}

• Hàm 'remove_item' sẽ thực thi 'delete_item' và truyền bộ chọn 'id'
• Thao tác xóa sẽ được lưu trữ và thực thi thông qua biến 'item_to_delete'
• Khi một mục không khả dụng, bạn sẽ nhận được kết quả trả về 'Item id Not Available'

server/app.py​

Bây giờ bạn đã hoàn thành tệp 'server/routes/item.py', hãy đưa tệp đó vào 'server/app.py'.

Mở tệp 'app.py' bằng trình soạn thảo văn bản của bạn.

Nhập 'router' từ tệp 'server/routes/item.py' dưới dạng 'ItemRouter'.

from server.routes.item import router as ItemRouter

Chèn 'ItemRouter' với tiền tố mặc định '/item'. Các hoạt động CRUD sẽ được xử lý thông qua URL '/item'.

app.include_router(ItemRouter, tags=["Item"], prefix="/item")

Bây giờ điểm cuối CRUD của bạn sẽ khả dụng tại địa chỉ sau:

• Thêm mục mới: POST vào '/item'
• Lấy tất cả các mục: GET đến '/item'
• Lấy mục cụ thể: GET đến '/item/id'. 'id' được tạo bởi MongoDB
• Cập nhật mục: PUT đến '/item/id'
• Xóa mục: DELETE đến '/item/id'

Kiểm tra các hoạt động CRUD​

Trước tiên, hãy đảm bảo rằng dự án FastAPI của bạn đang chạy hoặc bạn có thể thực thi tập lệnh 'main.py' như sau:

python3 main.py

Điều hướng qua http://SERVERIP:8080/docsvà bạn sẽ thấy từng tuyến đường bạn đã tạo.


data:image/svg+xml,%3Csvg%20xmlns=%22http://www.w3.org/2000/svg%22%20width=%22750%22%20height=%22340%22%3E%3C/svg%3E


Dưới đây là ví dụ về cách thêm mục mới.


data:image/svg+xml,%3Csvg%20xmlns=%22http://www.w3.org/2000/svg%22%20width=%22750%22%20height=%22479%22%3E%3C/svg%3E


Lấy tất cả các mục có sẵn thông qua API.


data:image/svg+xml,%3Csvg%20xmlns=%22http://www.w3.org/2000/svg%22%20width=%22750%22%20height=%22504%22%3E%3C/svg%3E


Lấy các mục cụ thể thông qua bộ chọn 'id'.


data:image/svg+xml,%3Csvg%20xmlns=%22http://www.w3.org/2000/svg%22%20width=%22750%22%20height=%22504%22%3E%3C/svg%3E


Cập nhật dữ liệu một phần từ các mục cụ thể.


data:image/svg+xml,%3Csvg%20xmlns=%22http://www.w3.org/2000/svg%22%20width=%22750%22%20height=%22468%22%3E%3C/svg%3E


Dưới đây là dữ liệu đã cập nhật.


data:image/svg+xml,%3Csvg%20xmlns=%22http://www.w3.org/2000/svg%22%20width=%22750%22%20height=%22456%22%3E%3C/svg%3E


Dưới đây là thao tác xóa thông qua bộ chọn 'id'.


data:image/svg+xml,%3Csvg%20xmlns=%22http://www.w3.org/2000/svg%22%20width=%22750%22%20height=%22488%22%3E%3C/svg%3E

Kết luận​

Xin chúc mừng! Bạn đã hoàn tất cài đặt FastAPI với MongoDB trên Ubuntu 24.04. Bạn cũng đã học cách kết nối FastAPI với MongoDB bằng mô-đun 'motor', tạo mô hình dữ liệu thông qua 'pydantic', tạo các hoạt động CRUD bằng FastAPI và tìm hiểu cách tạo điểm cuối cho API của bạn.