So installieren Sie Fast API mit MongoDB auf Ubuntu 24.04

FastAPI ist ein auf Python basierendes Web-Framework zur Erstellung von API-Diensten. Es ist ein modernes, schnelles, leistungsstarkes Framework, das asynchrone Operationen unterstützt.

In diesem Tutorial lernen Sie, wie Sie FastAPI mit MongoDB auf Ubuntu 24.04 installieren. Sie lernen auch, wie Sie Ihre erste API mit CRUD-Operationen unter Verwendung von FastAPI und der MongoDB-Datenbank erstellen.

Voraussetzungen

Um mit diesem Leitfaden zu beginnen, stellen Sie sicher, dass Sie Folgendes haben:

• Ein Ubuntu 24.04-System
• Einen Nicht-Root-Benutzer mit Administratorrechten

MongoDB installieren

Bevor Sie ein neues FastAPI-Projekt erstellen, installieren wir den MongoDB-Server auf unserem System.

Zuerst führen Sie den folgenden Befehl aus, um Ihr Paket-Index zu aktualisieren und ‘gnupg’ und ‘curl’ auf Ihrem System zu installieren.

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

Führen Sie den folgenden Befehl aus, um den GPG-Schlüssel für den MongoDB-Server hinzuzufügen.

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

Fügen Sie das MongoDB-Repository mit dem folgenden Befehl hinzu.

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

Nachdem das Repository hinzugefügt wurde, führen Sie den folgenden Befehl aus, um Ihr Paket-Index zu aktualisieren und den MongoDB-Server zu installieren. Geben Sie ‘Y’ ein, um die Installation zu bestätigen.

sudo apt update && sudo apt install mongodb-org

Wenn die Installation abgeschlossen ist, starten und aktivieren Sie den MongoDB-Dienst ‘mongod’ und überprüfen Sie dann den Status Ihres MongoDB-Dienstes, um sicherzustellen, dass er läuft.

sudo systemctl enable --now mongod  
sudo systemctl status mongod

Sie können unten sehen, dass der MongoDB-Server läuft.

Darüber hinaus können Sie sich mit dem folgenden ‘mongosh’-Befehl beim MongoDB-Server anmelden. Um zu beenden, drücken Sie Ctrl+d.

mongosh

Python und virtuelle Umgebung einrichten

Nachdem MongoDB installiert ist, installieren Sie Python-Pakete und richten das Projektverzeichnis sowie die virtuelle Umgebung ein.

Installieren Sie Python, Pip und Venv-Module mit dem folgenden Befehl. Geben Sie ‘Y’ ein, um die Installation zu bestätigen.

sudo apt install python3 python3-pip python3-venv

Sobald die Installation abgeschlossen ist, melden Sie sich bei Ihrem Benutzer an.

su - username

Erstellen Sie nun ein neues ‘~/app‘-Verzeichnis und wechseln Sie in dieses. Dieses Verzeichnis wird verwendet, um Ihr FastAPI-Projekt zu speichern.

mkdir -p ~/app; cd ~/app

Führen Sie den folgenden Befehl aus, um eine neue ‘venv‘-virtuelle Umgebung zu erstellen und aktivieren Sie sie. Damit wird Ihre Shell-Eingabeaufforderung wie ‘(venv) user@hostname‘.

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

Von hier aus muss Ihre Arbeitsumgebung in der ‘venv’-virtuellen Umgebung sein. Sie können sich von ‘venv’ mit dem folgenden Befehl abmelden.

deactivate

FastAPI-Projekt erstellen

Jetzt, da Sie Ihre Python-virtuelle Umgebung erstellt und aktiviert haben, installieren wir FastAPI und erstellen die Projektstruktur.

Führen Sie den ‘pip3’-Befehl aus, um die Pakete ‘fastapi’ und ‘uvicorn’ zu installieren.

pip3 install fastapi uvicorn

• Das ‘fastapi’ ist das Haupt-FastAPI-Web-Framework zum Erstellen von APIs in Python
• Das ‘uvicorn’ ist die Implementierung des ASGI (Asynchronous Server Gateway Interface) Webservers in Python.

Nachdem die Installation abgeschlossen ist, erstellen Sie neue Dateien und Verzeichnisse mit dem folgenden Befehl.

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

Unten sehen Sie unsere FastAPI-Projektstruktur.

server/app.py

Jetzt, da Ihr Projekt bereit ist, lassen Sie uns die Datei ‘server/app.py’ ändern, die die Hauptanwendung Ihres FastAPI-Projekts ist.

Öffnen Sie die Datei ‘app.py‘ mit Ihrem Texteditor und kopieren Sie das folgende Skript.

from fastapi import FastAPI  
  
app = FastAPI()  
  
@app.get("/")  
async def root():  
 return {"message": "Hallo FastAPI!"}

• Importieren Sie das FastAPI-Modul in Ihr Projekt und binden Sie es an die Variable ‘app’
• Erstellen Sie eine neue Funktion ‘root’, die ‘Hallo FastAPI!’ zurückgibt
• Die Funktion ‘root’ reagiert auf die GET-Methode auf der Stamm-URL
• ‘async’ kennzeichnet Ihre Funktion als asynchrone Funktion und kann ‘await’ innerhalb ihres Körpers verwenden, wenn sie aufgerufen wird

main.py

In diesem Abschnitt werden wir die Datei ‘main.py’ ändern, die verwendet wird, um Ihr FastAPI-Projekt über ‘uvicorn’ (ASGI-Webserver in Python) auszuführen.

Öffnen Sie nun das Skript ‘ main.py ‘ und fügen Sie den folgenden Code ein.

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

• Importieren Sie das ‘uvicorn’-Modul
• Wenn das Skript ‘main.py’ ausgeführt wird, wird das ‘app’- oder FastAPI-Modul innerhalb der ‘server/app.py’ geladen
• FastAPI wird auf ‘0.0.0.0’ mit Port ‘8080’ ausgeführt
• Aktivieren Sie das automatische Neuladen, wenn der Code über ‘reload=True’ geändert wird

Führen Sie Ihr FastAPI-Projekt aus

Jetzt, da Ihr Projekt bereit ist, lassen Sie uns Ihr erstes FastAPI-Projekt ausführen.

Führen Sie das Skript ‘main.py’ wie folgt aus, und Ihr FastAPI wird auf Ihrem System ausgeführt.

python3 main.py

Öffnen Sie jetzt Ihren Webbrowser und besuchen Sie http://SERVERIP:8080/. Wenn Ihre Installation erfolgreich war, sehen Sie die Nachricht ‘Hallo FastAPI!’. Sie können auch über ‘curl’ vom Terminal darauf zugreifen.

Schließlich können Sie die API-Dokumentation unter http://SERVERIP:8080/docs > aufrufen, die von Swagger UI bereitgestellt wird.

Verbindung von FastAPI zu MongoDB

In diesem Leitfaden erstellen Sie eine grundlegende API mit FastAPI und MongoDB. Ihre API sollte in der Lage sein, CRUD mit dem MongoDB-Datenbankserver durchzuführen. In diesem Schritt verbinden Sie Ihr Projekt mit dem MongoDB-Server.

Zuerst führen Sie den folgenden ‘pip3’-Befehl aus, um den MongoDB-Treiber ‘motor‘ in Ihr Projekt zu installieren. ‘motor’ bietet nicht-blockierenden und coroutine-basierten API-Zugriff auf den MongoDB-Server.

pip3 install motor

server/database.py

Nachdem das ‘motor‘-Modul installiert ist, lassen Sie uns das Skript ‘server/database.py‘ ändern.

Öffnen Sie die Datei ‘server/database.py’ mit Ihrem Texteditor und geben Sie das folgende Skript ein. Dies wird verwendet, um eine Verbindung zum MongoDB-Server über das ‘motor’-Modul herzustellen.

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")

• Importieren Sie ‘AsyncIOMotorClient’ aus ‘motor.motor_asyncio’
• Erstellen Sie eine neue Konstante ‘MONGODB_HOST’ und verweisen Sie auf den MongoDB-Server ‘mongodb://localhost:27017’
• Stellen Sie eine Verbindung zum MongoDB-Server über die Variable ‘connection’ her
• Stellen Sie eine Verbindung zur Datenbank ‘items’ über die Variable ‘database’ her
• Greifen Sie auf Sammlungen in der Datenbank mit der Variable ‘item_collection’ zu

Erstellen eines Datenbankmodells mit pydantic

In diesem Abschnitt entwerfen Sie Ihre Daten über ‘pydantic‘, das Modellierung für unsere MongoDB-Datenbank bereitstellt.

Installieren Sie das ‘pydantic’-Modul mit dem folgenden ‘pip3’-Befehl. Das ‘pydantic‘-Modul ist eine Datenvalidierungsbibliothek, mit der Sie Datenbankschemata über Modelle erstellen können.

pip3 install pydantic

Öffnen Sie jetzt die Datei ‘server/models/itemModels.py‘ mit Ihrem Texteditor und kopieren Sie das folgende Skript.

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": "Unternehmens-Smartwatch",  
 "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": "Neue Smartwatch",  
 "category": "neue-smartwatch",  
 "stocks": 5,  
 "price": 500,  
 }  
 }

• Importieren Sie die Module ‘BaseModel’ und ‘Field’ aus ‘pydantic’
• Importieren Sie das Modul ‘Optional’ aus ‘typing’
• Erstellen Sie das folgende ‘Item’-Datenbankschema für FastAPI: - ‘name’ und ‘category’ mit dem Typ String
• ‘stocks’ und ‘price’ mit dem Typ Integer
• ‘price’ muss größer als 0 sein
• Erweitern Sie das Datenmodell über die ‘Config’-Klasse, indem Sie ein Beispiel für Daten bereitstellen, die der Benutzer in die Anfrage aufnehmen kann
• Erstellen Sie das folgende ‘ItemUpdate’-Schema, bei dem jedes Feld optional ist.

Hinzufügen von CRUD-Operationen

An diesem Punkt haben Sie eine Verbindung zum MongoDB-Server hergestellt und ein Datenbankschema über ‘pydantic’ erstellt. Lassen Sie uns nun die CRUD-Operationen mit FastAPI und MongoDB erstellen.

Öffnen Sie das Skript ‘server/database.py‘ erneut und erstellen Sie eine neue Funktion ‘item_helper‘ mit dem Typ ‘dict‘. Rufen Sie diese Funktion auf, um detaillierte Daten zu einem Artikel zu erhalten.

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

Fügen Sie die folgende Zeile hinzu, um das Modul ‘ObjectId‘ aus ‘bson.objectid’ zu importieren. Der ‘ObjectId‘ ist Teil des Datentyps in BSON, den MongoDB für die Datenspeicherung und die Darstellung von JSON-Daten verwendet.

from bson.objectid import ObjectId

Erstellen eines Artikels

Zuerst erstellen Sie eine asynchrone Funktion, die in der Lage ist, neue Daten zur MongoDB-Datenbank hinzuzufügen.

Erstellen Sie eine neue Funktion ‘add_item‘ wie folgt:

# Neuen Artikel hinzufügen  
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)

• Die Funktion ‘add_item’ akzeptiert ein Dictionary mit Ihren Artikeldetails
• Über die ‘item_collection’ wird auf Dokumente in der Datenbank zugegriffen und die ‘insert_one’-Abfrage ausgeführt, um einen neuen Artikel hinzuzufügen
• Der neue Artikel wird bei erfolgreicher Operation ausgegeben

Alle Artikel abrufen

Zweitens erstellen Sie eine neue Funktion ‘get_items‘, die in der Lage ist, alle verfügbaren Artikel in Ihrer Datenbank abzurufen.

Erstellen Sie eine neue Funktion ‘get_items‘ zum Abrufen aller Artikel aus MongoDB.

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

• Sie erstellen eine leere Liste von ‘items’
• Verwenden Sie die ‘find()’-Abfrage, um alle Daten zu suchen und durch sie zu iterieren
• Jeder Artikel wird über die ‘append’-Methode zur Liste ‘items’ hinzugefügt
• Nachdem die Schleife abgeschlossen ist, werden Ihre Artikel angezeigt

Bestimmten Artikel basierend auf der ID abrufen

Als Nächstes erstellen Sie eine neue Funktion, die in der Lage ist, Daten für einen bestimmten Selektor ‘id’ abzurufen. Dies zeigt Ihnen die detaillierten Daten zu bestimmten Artikeln.

Erstellen Sie eine neue Funktion ‘get_item‘, um die Daten bestimmter Artikel abzurufen. Die Funktion ‘get_item’ akzeptiert eine Zeichenfolge von ‘id’ als Selektor und gibt ein Dictionary zurück.

# Bestimmten Artikel abrufen  
async def get_item(id: str) -> dict:  
 item = await item_collection.find_one({"_id": ObjectId(id)})  
 if item:  
 return item_helper(item)  
 return "Artikel nicht gefunden."

• Die ‘find_one()’-Abfrage wird verwendet, um Daten basierend auf der ‘id’ abzurufen
• Wenn ein Artikel gefunden wird, werden die Details im Format des ‘item_helper’-Dictionaries angezeigt
• Wenn der Artikel nicht verfügbar ist, lautet die Antwort ‘Artikel nicht gefunden’

Einen Artikel aktualisieren

Jetzt erstellen Sie eine neue Funktion zum Aktualisieren eines Artikels. Sie können auch teilweise Ihre Artikel über die API aktualisieren.

Definieren Sie die neue Funktion ‘change_item‘ wie folgt:

# Artikel aktualisieren  
async def change_item(id: str, data: dict):  
 if len(data) < 1:  
 return "Bitte geben Sie Ihre Daten ein"  
 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

• Die Funktion ‘change_item’ nimmt zwei Argumente, die ‘id’ des Zielartikels und ‘data’ als neue Daten
• Wenn die Daten leer oder ‘< 1’ sind, wird die Operation abgebrochen
• Diese Funktion sucht einen Artikel basierend auf dem Selektor ‘id’
• Wenn die ‘id’ gefunden wird, wird die ‘item_update’-Abfrage ausgeführt
• Wenn die ‘item_update’ erfolgreich ist, wird ‘True’ zurückgegeben, andernfalls ‘False’

Einen Artikel löschen

Zuletzt erstellen Sie die Funktion ‘delete_item’, um Artikel über einen bestimmten Selektor zu löschen.

Um einen Artikel zu löschen, erstellen wir die Funktion ‘delete_item‘ und verwenden den Selektor ‘id’ wie folgt:

# Artikel löschen  
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'Artikel {id} gelöscht.')  
 return "Artikel nicht gefunden."

• Die ‘find_one()’-Abfrage sucht nach einem Artikel basierend auf der angegebenen ‘id’
• Wenn der Artikel gefunden wird, wird er über die ‘delete_one()’-Abfrage gelöscht und es wird ‘Artikel id gelöscht’ zurückgegeben
• Wenn der Artikel nicht verfügbar ist, wird ‘Artikel nicht gefunden’ angezeigt

Routen für CRUD-Operationen hinzufügen

An diesem Punkt haben wir asynchrone Funktionen für CRUD-Operationen mit FastAPI erstellt. Lassen Sie uns nun die Route oder den Endpunkt für jede Operation erstellen.

Bearbeiten Sie die Datei ‘server/routes/item.py‘ mit Ihrem bevorzugten Editor.

server/routes/item.py

Zuerst fügen Sie die Module ‘APIRouter‘ und ‘Body‘ aus ‘fastapi’ hinzu. Dann fügen Sie ‘jsonable_encode‘ aus ‘fastapi.encoders’ hinzu.

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

Importieren Sie jede Funktion aus der Datei ‘database.py’.

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

Importieren Sie die Modelle ‘Item’ und ‘ItemUpdate’ aus der Datei ‘itemModels.py’.

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

Rufen Sie die Klasse ‘APIRouter’ über die Variable ‘router’ auf.

router = APIRouter()

Route zum Hinzufügen neuer Artikel

Jetzt fügen wir eine Route zum Hinzufügen neuer Artikel hinzu. In diesem Beispiel können Sie einen neuen Artikel über POST an die URL ‘/item‘ hinzufügen.

Fügen Sie die folgenden Zeilen hinzu, um Routen zum Hinzufügen neuer Artikel einzurichten. Jeder POST an die Stamm-URL des Artikels wird als Einfügen neuer Daten behandelt.

# Operation zum Hinzufügen neuer Artikel  
@router.post("/")  
async def add_item_data(item: Item = Body(...)):  
 item = jsonable_encoder(item)  
 new_item = await add_item(item)  
 return new_item

• Die Funktion ‘add_item_data’ akzeptiert das ‘Item’-Schema, das Teil des ‘Body’ Ihrer Anfrage sein wird
• Ihr Artikel wird über ‘jsonable_encoder’ in das Dictionary-Format konvertiert
• Fügen Sie Ihre Dictionary-Daten über die Funktion ‘add_item’ (siehe database.py) in die Variable ‘new_item’ ein
• Geben Sie Ihre eingefügten Daten ‘new_item’ als Antwort zurück

Route zum Abrufen aller Artikel

Fügen Sie das folgende Skript hinzu, um eine Route zum Abrufen von Daten einzurichten. Jede GET-Anfrage an die Stammartikel-URL ruft alle Ihre Daten ab.

# Alle verfügbaren Artikel abrufen  
@router.get("/")  
async def get_item_data():  
 items = await get_items()  
 if items:  
 return items  
 return "Kein verfügbarer Artikel."

• Erstellen Sie die Funktion ‘get_item_data’, die die Funktion ‘get_item’ aus der Datei ‘database.py’ ausführt
• Wenn Artikel verfügbar sind, erhalten Sie die Liste aller Ihrer Artikel
• Wenn kein Artikel vorhanden ist, erhalten Sie die Antwort ‘Kein verfügbarer Artikel’

Route zum Abrufen eines bestimmten Artikels

Um die Details eines bestimmten Artikels abzurufen, verwenden wir die ‘id’ als Selektor. Jede GET-Anfrage an ‘/id’ gibt einen detaillierten Artikel der angeforderten ‘id’ zurück.

# Zeigen Sie die Details des Artikels über die id an  
@router.get("/{id}")  
async def get_item_details(id):  
 item_details = await get_item(id)  
 if item_details:  
 return item_details  
 return "Artikel nicht gefunden."

• Die Funktion ‘get_item_details’ wird erstellt und die ‘id’ aus der URL übergeben
• Die Funktion ‘get_item’ (siehe database.py) wird aufgerufen und die ‘id’ ebenfalls als Argument übergeben
• Wenn der Artikel gefunden wird, werden die Details des Artikels angezeigt
• Wenn kein Artikel mit dieser spezifischen ‘id’ vorhanden ist, erhalten Sie ‘Artikel nicht gefunden’

Route zum Aktualisieren eines Artikels

Kopieren Sie den folgenden Code, um die Route für den aktualisierten Artikel festzulegen:

# Artikel aktualisieren  
@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: Artikel {id} aktualisiert.'}  
 return "Fehler"

• Die Funktion ‘update_item’ nimmt zwei Argumente, ‘id’ als Selektor und die ‘data’, die auf dem ‘ItemUpdate’-Modell basiert
• Die Daten werden in der Variable ‘data’ überprüft
• Der ‘updated_item’ führt die Funktion ‘change_item’ aus der Datei ‘database.py’ aus
• Wenn das Update erfolgreich ist, sehen Sie die Ausgabe ‘Erfolg’

Route zum Löschen eines Artikels

Fügen Sie die folgenden Zeilen hinzu, um die Funktion ‘remove_item’ zum Löschen von Artikeln zu erstellen. Jede DELETE-Operation an einem bestimmten ‘/id’ entfernt den Artikel, der mit der ‘id’ übereinstimmt.

# Artikel über id löschen  
@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'Artikel {id} nicht verfügbar.'}

• Die Funktion ‘remove_item’ führt ‘delete_item’ aus und übergibt den Selektor ‘id’
• Die Löschoperation wird in der Variable ‘item_to_delete’ gespeichert und ausgeführt
• Wenn ein Artikel nicht verfügbar ist, erhalten Sie die Rückgabe ‘Artikel id nicht verfügbar’

server/app.py

Jetzt, da Sie die Datei ‘server/routes/item.py’ abgeschlossen haben, lassen Sie uns diese in der Datei ‘server/app.py’ einfügen.

Öffnen Sie die Datei ‘app.py‘ mit Ihrem Texteditor.

Importieren Sie den ‘router’ aus der Datei ‘server/routes/item.py‘ als ‘ItemRouter’.

from server.routes.item import router as ItemRouter

Fügen Sie den ‘ItemRouter’ mit dem Standardpräfix ‘/item‘ ein. Die CRUD-Operationen werden über die URL ‘/item‘ behandelt.

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

Jetzt sind Ihre CRUD-Endpunkte unter folgender Adresse verfügbar:

• Neuen Artikel hinzufügen: POST an ‘/item‘
• Alle Artikel abrufen: GET an ‘/item‘
• Bestimmten Artikel abrufen: GET an ‘/item/id’. Die ‘id’ wird von MongoDB generiert
• Artikel aktualisieren: PUT an ‘/item/id’
• Artikel löschen: DELETE an ‘/item/id’

CRUD-Operationen testen

Stellen Sie zunächst sicher, dass Ihr FastAPI-Projekt läuft, oder führen Sie das Skript ‘main.py’ wie folgt aus:

python3 main.py

Navigieren Sie zu http://SERVERIP:8080/docs und Sie sehen jede Route, die Sie erstellt haben.

Unten sehen Sie ein Beispiel zum Hinzufügen eines neuen Artikels.

Rufen Sie alle verfügbaren Artikel über die API ab.

Rufen Sie bestimmte Artikel über den ‘id’-Selektor ab.

Aktualisieren Sie teilweise Daten von bestimmten Artikeln.

Unten sehen Sie die aktualisierten Daten.

Unten sehen Sie die Löschoperation über den ‘id’-Selektor.

Fazit

Herzlichen Glückwunsch! Sie haben die Installation von FastAPI mit MongoDB auf Ubuntu 24.04 abgeschlossen. Sie haben auch gelernt, wie Sie FastAPI mit MongoDB über das ‘motor’-Modul verbinden, Datenmodelle über ‘pydantic’ erstellen, CRUD-Operationen mit FastAPI erstellen und wie Sie Endpunkte für Ihre API erstellen.