In der heutigen, technologiegetriebenen Welt ist das Erstellen schneller, effizienter und skalierbarer APIs für Entwickler von entscheidender Bedeutung. Eine leistungsstarke Kombination, die an Popularität gewinnt, ist die Verwendung von FastAPI mit MongoDB. FastAPI ist, wie der Name schon sagt, ein modernes, hochleistungsfähiges Web-Framework für die Erstellung von APIs mit Python 3.7+, das schnell zu codieren und auszuführen ist. Inzwischen ist MongoDB eine NoSQL-Datenbank, die für ihre Skalierbarkeit und Flexibilität bekannt ist. Zusammen bieten sie eine robuste Lösung für die Erstellung von APIs, die alles von einem kleinen Projekt bis zu einer groß angelegten Anwendung bewältigen können.
Warum sollten Sie dieses Duo also für Ihr nächstes Projekt in Betracht ziehen? Lassen Sie uns eintauchen!
Erste Schritte: Einrichten Ihrer Umgebung
Bevor wir mit dem Erstellen unserer API beginnen, richten wir unsere Umgebung ein. Sie benötigen Python auf Ihrem System installiert, zusammen mit pip zur Verwaltung von Paketen.
Schritt 1: Installieren Sie FastAPI und Uvicorn
Zuerst installieren wir FastAPI. Öffnen Sie Ihr Terminal und führen Sie den folgenden Befehl aus:
pip install fastapi
Als Nächstes installieren wir Uvicorn, eine ASGI-Server-Implementierung für Python, die unsere FastAPI-Anwendung bedienen wird:
pip install uvicorn
Schritt 2: Installieren Sie Motor
Motor ist der Async-Treiber für MongoDB, der nahtlos mit FastAPI zusammenarbeitet. Um es zu installieren, führen Sie aus:
pip install motor
Großartig! Jetzt haben wir alles, was wir zum Codieren benötigen.
Erstellen Ihrer ersten FastAPI-Anwendung
Lassen Sie uns nun eine einfache FastAPI-Anwendung erstellen und sie mit MongoDB verbinden.
Schritt 1: Initialisieren Sie die FastAPI-App
Erstellen Sie eine neue Python-Datei (nennen wir sie main.py) und beginnen Sie mit dem Importieren von FastAPI und dem Initialisieren der App:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def read_root():
return {"message": "Welcome to the FastAPI with MongoDB tutorial!"}
Dieser Code richtet eine einfache FastAPI-Anwendung mit einem einzigen Endpunkt ein.
Schritt 2: Verbinden Sie sich mit MongoDB
Als Nächstes verbinden wir unsere FastAPI-Anwendung mit MongoDB mithilfe von Motor. Wir erstellen eine neue Datei namens database.py, um unsere Datenbankverbindung zu verwalten.
from motor.motor_asyncio import AsyncIOMotorClient
MONGO_DETAILS = "mongodb://localhost:27017"
client = AsyncIOMotorClient(MONGO_DETAILS)
database = client.mydatabase
In diesem Beispiel stellen wir eine Verbindung zu einer lokal ausgeführten MongoDB-Instanz her. Stellen Sie sicher, dass MongoDB auf Ihrem System installiert ist und ausgeführt wird.
Schritt 3: Definieren Sie Pydantic-Modelle
Pydantic-Modelle sind eine großartige Möglichkeit, Datenstrukturen zu definieren und die Datenvalidierung in FastAPI sicherzustellen. Erstellen Sie eine Datei models.py:
from pydantic import BaseModel
class Item(BaseModel):
name: str
description: str
price: float
available: bool = True
Dieses Modell definiert die Struktur eines Artikels in unserem Inventar.
Erstellen von API-Endpunkten
Nachdem die grundlegenden Einstellungen abgeschlossen sind, erstellen wir einige API-Endpunkte, um mit unserer MongoDB-Datenbank zu interagieren.
Schritt 1: Erstellen Sie die Items-Sammlung
Zuerst benötigen wir eine Sammlung in unserer MongoDB-Datenbank, um Elemente zu speichern. In main.py erstellen wir einen Endpunkt, um der Datenbank neue Elemente hinzuzufügen:
from fastapi import FastAPI, HTTPException
from database import database
from models import Item
from bson import ObjectId
app = FastAPI()
@app.post("/items/")
async def create_item(item: Item):
item_dict = item.dict()
result = await database["items"].insert_one(item_dict)
item_dict["_id"] = str(result.inserted_id)
return item_dict
Dieser Endpunkt ermöglicht es uns, neue Elemente in der MongoDB-Sammlung zu erstellen. Beachten Sie, wie wir die eingefügte ID zur besseren Lesbarkeit in eine Zeichenfolge konvertieren.
Schritt 2: Elemente abrufen
Als Nächstes erstellen wir einen Endpunkt, um alle Elemente aus der Datenbank abzurufen:
@app.get("/items/")
async def get_items():
items = await database["items"].find().to_list(1000)
for item in items:
item["_id"] = str(item["_id"])
return items
Dieser Endpunkt ruft alle Elemente aus der Sammlung items ab und konvertiert ihre IDs in Zeichenfolgen.
Schritt 3: Ein einzelnes Element abrufen
Um ein einzelnes Element anhand seiner ID abzurufen, fügen wir einen weiteren Endpunkt hinzu:
@app.get("/items/{item_id}")
async def get_item(item_id: str):
item = await database["items"].find_one({"_id": ObjectId(item_id)})
if item:
item["_id"] = str(item["_id"])
return item
raise HTTPException(status_code=404, detail="Item not found")
Dieser Endpunkt ruft ein Element anhand seiner ID ab und gibt es zurück oder löst einen 404-Fehler aus, wenn das Element nicht gefunden wird.
Schritt 4: Ein Element aktualisieren
Das Aktualisieren eines Elements ist mit FastAPI und Motor unkompliziert. Fügen Sie den folgenden Code hinzu, um ein Element anhand seiner ID zu aktualisieren:
@app.put("/items/{item_id}")
async def update_item(item_id: str, item: Item):
result = await database["items"].update_one(
{"_id": ObjectId(item_id)}, {"$set": item.dict()}
)
if result.modified_count == 1:
updated_item = await database["items"].find_one({"_id": ObjectId(item_id)})
updated_item["_id"] = str(updated_item["_id"])
return updated_item
raise HTTPException(status_code=404, detail="Item not found")
Dieser Endpunkt aktualisiert ein Element anhand seiner ID und gibt das aktualisierte Element zurück.
Schritt 5: Ein Element löschen
Zum Schluss fügen wir einen Endpunkt hinzu, um ein Element anhand seiner ID zu löschen:
@app.delete("/items/{item_id}")
async def delete_item(item_id: str):
result = await database["items"].delete_one({"_id": ObjectId(item_id)})
if result.deleted_count == 1:
return {"message": "Item deleted"}
raise HTTPException(status_code=404, detail="Item not found")
Dieser Endpunkt löscht ein Element und gibt eine Erfolgsmeldung oder einen 404-Fehler zurück, wenn das Element nicht gefunden wird.
So stellen Sie eine Verbindung zur MongoDB-Datenbank zu Apidog her
- Klicken Sie in der API auf "Processors Operation" und wählen Sie "Database Operations" aus.
2. Klicken Sie im Dropdown-Feld unter "Database Connection" auf "Manage Database Connection" und dann auf die Schaltfläche "New" in der oberen rechten Ecke.
3. Wählen Sie den MongoDB-Datenbanktyp aus und geben Sie dann die entsprechenden Verbindungsinformationen ein.
MongoDB-Datenbank bedienen
MongoDB speichert Daten im BSON-Dokumentformat. Um die Nutzungsgewohnheiten der meisten Benutzer zu erleichtern, reichen Sie beim Ändern von MongoDB-Datenbanken in Apidog JSON-Formatdateien ein. Das System ordnet jedes Feld automatisch dem entsprechenden BSON-Datentyp basierend auf dem tatsächlichen Inhalt des JSON zu.
Darunter ist das Feld _id relativ speziell. Gemäß den MongoDB-Spezifikationen muss jedes Dokument ein Feld _id als Primärschlüssel haben, und der Standarddatentyp dieses Felds ist ObjectId anstelle von String.
Wenn Sie ein Feld _id vom Typ ObjectId deklarieren müssen, können Sie das herkömmliche Zeichenfolgenformat verwenden. Wenn der Zeichenfolgeninhalt dem ObjectId-Format entspricht, ordnet Apidog ihn automatisch dem Typ ObjectId in BSON zu.
Angenommen, es gibt ein solches BSON-Dokument in MongoDB:
{ _id: ObjectId('6569a36afcf5ee79c08d2f94'), name: "Apidog"}Wenn Sie also Apidog verwenden, um das Dokument über _id abzufragen, ist der JSON-Wert, der in "Query Conditions" eingegeben werden muss:
{ "_id": "6569a36afcf5ee79c08d2f94" }Häufige Operationen
Für gängige CRUD-Operationen wird die Unterstützung über visuelle API-Operationen bereitgestellt. Sie müssen keinen JavaScript-Code schreiben, sondern nur die Aktion in "Operation Type" angeben, dann den "Collection Name" angeben und dann den entsprechenden Inhalt in JSON in "Query Conditions" schreiben.
Für die oben genannte Abfrageoperation können Sie beispielsweise das abgefragte Dokument in der Konsole anzeigen, nachdem Sie den Befehl eingegeben und "Console Log" aktiviert haben.
Erweiterte Befehle
Wenn Sie erweiterte Operationen benötigen, können Sie auch Datenbankbefehle direkt ausführen. Wählen Sie in "Operation Type" die Option "Run Database Command" aus und geben Sie dann den Datenbankbefehl im JSON-Format ein. Beachten Sie, dass sich der Datenbankbefehl nicht auf Methodenaufrufe wie db.collection.findOne() bezieht, sondern auf JSON-Daten in einem bestimmten Format.
Um beispielsweise die Anzahl der Dokumente in der Sammlung users abzufragen, können Sie den Datenbankbefehl count verwenden:
{ "count": "users"}Nachdem Sie den Befehl eingegeben haben, können Sie das Ergebnis in der Konsole anzeigen.
Testen Ihrer API
Um Ihre API zu testen, können Sie Tools wie Postman oder Apidog verwenden. Mit diesen Tools können Sie Anfragen an Ihre Endpunkte senden und die Antworten sehen, wodurch das Debuggen vereinfacht und sichergestellt wird, dass alles ordnungsgemäß funktioniert.
Verwenden von Apidog zum Testen
Apidog ist ein leistungsstarkes Tool zur API-Entwicklung und -Tests, das den Prozess des Erstellens, Testens und Verwaltens von APIs vereinfacht. So können Sie Apidog verwenden, um Ihre FastAPI MongoDB-Anwendung zu testen:
- Erstellen Sie ein neues Projekt: Öffnen Sie den Apidog-Client und erstellen Sie ein neues Projekt in Apidog.
2 Endpunkte hinzufügen: Fügen Sie die von Ihnen erstellten Endpunkte (/items/, /items/{item_id} usw.) zum Projekt hinzu.
3. Anfragen senden: Verwenden Sie das Tool, um GET-, POST-, PUT- und DELETE-Anfragen an Ihre Endpunkte zu senden und die Antworten zu beobachten.
4. Antworten validieren: Stellen Sie sicher, dass die Antworten mit den erwarteten Ausgaben übereinstimmen, und verwenden Sie die detaillierten Fehlermeldungen, um Probleme zu beheben.
Fazit
In diesem Tutorial haben wir die Grundlagen der Einrichtung einer FastAPI-Anwendung mit MongoDB behandelt. Wir haben eine einfache Inventar-API erstellt, mit der Sie Elemente erstellen, abrufen, aktualisieren und löschen können. Die Geschwindigkeit und Benutzerfreundlichkeit von FastAPI in Kombination mit der Flexibilität und Skalierbarkeit von MongoDB machen sie zu einem perfekten Paar für die Erstellung robuster APIs.
Durch die Nutzung von Tools wie Apidog können Sie den Entwicklungs- und Testprozess optimieren und sicherstellen, dass Ihre APIs zuverlässig und leistungsfähig sind.
Also, worauf warten Sie noch? Tauchen Sie ein in FastAPI und MongoDB und beginnen Sie noch heute mit dem Erstellen erstaunlicher APIs!
