Leser wie Sie helfen, MUO zu unterstützen. Wenn Sie über Links auf unserer Website einen Kauf tätigen, erhalten wir möglicherweise eine Affiliate-Provision. Weiterlesen.

Das Erstellen einer REST-API ist oft eine mechanische Aufgabe, die viel Boilerplate-Design und Routineprogrammierung erfordert. Zum Glück können Tools wie FastAPI viele lästige Details entlasten.

Mit FastAPI können Sie schnell eine effiziente, vollständige REST-API für Ihre CRUD-Anwendung erstellen. Mit MongoDB als Datenquelle führt Sie dieses Tutorial dazu, im Handumdrehen Ihre eigene API einzurichten.

Was ist FastAPI?

FastAPI ist ein schnelles und quelloffenes Python-Webframework zum Erstellen von APIs. Es bietet integrierte Unterstützung für asynchrone Anfragen, automatische Validierung von Daten und automatische Dokumentation von API-Endpunkten.

Die Vorteile von FastAPI gegenüber anderen Python-Frameworks

  • FastAPI ist relativ schneller als andere Frameworks wie Django und Flask. Dies liegt daran, dass FastAPI auf asyncio aufbaut, einer asynchronen E/A-Bibliothek für Python, die gleichzeitige Anforderungen schneller verarbeiten kann.
    instagram viewer
  • FastAPI bietet eine saubere und einfache Möglichkeit, APIs mit minimalem Aufwand zu erstellen, da es weniger Code erfordert als Flask oder Django.
  • Schließlich erleichtert FastAPI das Generieren von Dokumentationen für Endpunkte. Es verwendet Swagger, um Dokumentation zu erstellen, die Sie zum Testen von Endpunkten verwenden können, indem Sie Anforderungen ausführen und Antworten anzeigen.

Richten Sie eine MongoDB-Datenbank ein

Um loszulegen, müssen Sie Richten Sie die MongoDB-Datenbank lokal ein. Alternativ können Sie sich für die einfachere Option von entscheiden Einrichten eines MongoDB-Clusters in der Cloud.

Erstellen Sie als Nächstes mithilfe des installierten Tools für die grafische Benutzeroberfläche von MongoDB, Compass, eine Datenbankverbindung. Drücke den Neue Verbindung und geben Sie den Verbindungs-URI an, um eine Verbindung mit dem lokal ausgeführten MongoDB-Server herzustellen.

Erstellen Sie schließlich eine neue Datenbank und Sammlung, um Ihre Test-API-Daten zu speichern.

Richten Sie einen FastAPI-Server ein

Erstellen Sie mit einem Terminal einen Projektordner und geben Sie dieses neue Verzeichnis ein.

Sie finden den Code dieses Projekts in seiner GitHub-Repository.

Überprüfen Sie als Nächstes, ob Sie die Python-Version 3.6+ ausführen. Wenn nicht, installieren Sie die neueste Python Ausführung.

python --version

Installieren Sie anschließend Virtualenv, um eine isolierte virtuelle Entwicklungsumgebung zu erstellen. Dies wird dringend empfohlen, da Sie dadurch Konflikte vermeiden können, insbesondere wenn Sie verschiedene Versionen von Paketen für verschiedene Projekte verwenden.

pip installiere virtualenv

Erstellen Sie als Nächstes eine virtuelle Umgebung namens „venv“ in Ihrem aktuellen Verzeichnis:

virtualenv venv

Aktivieren Sie abschließend die virtuelle Umgebung.

# Unter Unix oder MacOS: 
Quelle venv/bin/activate
# Unter Windows:
 .\venv\Scripts\activate

Nachdem Sie die virtuelle Umgebung konfiguriert haben, installieren Sie die FastAPI-, PyMongo- und Uvicorn-Pakete.

pip installiere fastapi pymongo uvicorn

PyMongo ist eine Python-basierte Bibliothek zum Arbeiten mit der MongoDB-Datenbank. Es bietet eine API, die alle Funktionen von MongoDB unterstützt und es Ihnen ermöglicht, mit MongoDB zu interagieren, ohne rohe MongoDB-Abfragen schreiben zu müssen.

Uvicorn hingegen ist ein asynchroner Webserver, der auf dem Python-Modul asyncio basiert. Seine Hauptfunktion besteht darin, Ihre FastAPI-Server unterwegs neu zu laden. Die Verwendung von Uvicorn ist ähnlich wie Arbeiten mit Nodemon.

Erstellen Sie den FastAPI-Server

Erstellen Sie schließlich einen einfachen FastAPI-Server, der auf Anfragen von der Home-Route wartet. Erstellen Sie im Stammverzeichnis Ihres Projektordners eine server.py-Datei und fügen Sie den folgenden Code hinzu.

aus schnellapi importieren FastAPI
app = FastAPI()
@app.get("/")
asynchrondefheim():
zurückkehren {"Nachricht": "Hallo Welt"}

Führen Sie zuletzt den folgenden Befehl aus, um den Entwicklungsserver hochzufahren. Uvicorn stellt Ihre Anwendung auf Port 8000 bereit.

uvicon-Server: app --reload

Fahren Sie fort und sehen Sie sich die Serverantwort in Ihrem Browser unter an http://localhost: 8000.

Erstellen Sie die REST-API mit CRUD-Vorgängen

Erstellen Sie nun die REST-API, die die CRUD-Methoden implementiert (Erstellen, Lesen, Aktualisieren und Löschen). Erstellen Sie im Stammverzeichnis Ihres Projektordners vier Ordner: „config“, „models“, „routes“ und „schemas“.

├── Konfig
├── Modelle
├── Routen
├── Schemata
└── server.py

1. Konfigurieren Sie die Datenbankverbindung

Erstellen Sie im Konfigurationsverzeichnis eine neue Datei, db.py, und fügen Sie den folgenden Code hinzu.

aus Pymongo importieren MongoClient
db_connection = MongoClient("mongodb://localhost: 27017")
db = db_connection.datenbankname
Sammlung = db["Sammlungsname"]
  • Verwenden Sie die Methode MongoClient(), um eine Verbindung zu einer MongoDB-Datenbank herzustellen. Es akzeptiert eine Verbindungs-URI-Zeichenfolge als Argument, das den Host und Port des MongoDB-Servers angibt.
  • Die beiden Variablen geben an, auf welche Datenbank und Sammlung in Ihrem MongoDB-Server der Server zugreifen soll.

2. Definieren Sie ein Datenmodell

Dieses Modell definiert die Struktur Ihrer Daten in der Datenbank, einschließlich der Felder und Datentypen.

Erstellen Sie im Modellverzeichnis eine neue Datei, user_model.py, und fügen Sie den folgenden Code hinzu.

aus pydantisch importieren Basismodell 
KlasseBenutzer(Basismodell):
 Name: Str
 Rolle: Str
  • Der obige Code erstellt eine Klasse namens User, die eine Unterklasse der BaseModel-Klasse aus der Pydantic-Bibliothek ist. Die Benutzerklasse hat zwei Felder, Name und Rolle, deren Datentypen auf Zeichenfolgen festgelegt sind.
  • Sie können die Pydantic-Bibliothek mit FastAPI verwenden, um Datenmodelle zu erstellen. Sie können es auch verwenden, um Daten zu validieren, zu serialisieren (JSON zu Python) und zu deserialisieren (Python zu JSON).

3. Definieren Sie ein Datenschema

Aus dem erstellten Datenmodell können Sie das Schema für Ihre Daten definieren. Erstellen Sie im Verzeichnis Schemas eine neue Datei: user_schema.py, und fügen Sie den folgenden Code hinzu.

defuser_serializer(Benutzer) -> diktieren:
zurückkehren {
'Ausweis':str (benutzer["_Ausweis"]),
'Name':Benutzer["Name"],
'Rolle':Benutzer["Rolle"]
 }
defusers_serializer(Benutzer) -> Liste:
zurückkehren [user_serializer (Benutzer) für Benutzer In Benutzer]

4. Definieren Sie die API-Routen

Definieren Sie abschließend die Routen für die verschiedenen CRUD-Operationen.

Erstellen Sie im Routenverzeichnis eine neue Datei: user_routes.py, und fügen Sie den folgenden Code hinzu.

Daten mit der Post-Methode hinzufügen

Erstellen Sie die Post-Route, um Daten hinzuzufügen.

aus schnellapi importieren APIRouter
aus Modelle.Benutzermodell importieren Benutzer
aus schemas.user_schema importieren users_serializer
aus bson importieren Objekt Identifikation
aus config.db importieren Sammlung
Benutzer = APIRouter()
@user.post("/")
asynchrondefcreate_user(Benutzer: Benutzer):
 _id = collection.insert_one (dict (Benutzer))
 user = users_serializer (collection.find({"_Ausweis": _id.inserted_id}))
zurückkehren {"Status": "OK","Daten": Benutzer}
  • FastAPI stellt die APIRouter()-Methode bereit, die ein Router-Objekt definiert, das eine Schnittstelle bereitstellt, um API-Anforderungen an einen Server zu stellen.
  • Geben Sie eine Postroute an, die ein neues Benutzerobjekt in der Datenbank erstellt, indem die Daten nach der Serialisierung in die Sammlung eingefügt werden. Speichern und übergeben Sie als Nächstes die insert_id, um die zugehörigen Daten in der Sammlung zu finden, und geben Sie schließlich einen Status „Ok“ mit den Daten in der Antwort zurück, wenn die Post-Anforderung erfolgreich ist.
  • Die Methoden insert_one und find werden vom PyMongo-Client definiert.

Fügen Sie nun den folgenden Code zu server.py hinzu, um die Routen zu initialisieren.

aus routen.benutzer_routen importieren Benutzer
app.include_router (Benutzer)

Testen Sie die Post-Route in Ihrem Browser mit dem von FastAPI bereitgestellten Swagger-UI-API-Tool.

Lesen Sie Daten mit der Get-Methode

Nachdem Sie die Post-Route definiert und die Routen initialisiert haben, definieren Sie die restlichen anderen Routen.

@user.get("/")
asynchrondeffind_all_users():
 users = users_serializer (collection.find())
zurückkehren {"Status": "OK","Daten": Benutzer}

@user.get("/{id}")
asynchrondefget_one_user(ID: str):
 user = users_serializer (collection.find({"_Ausweis": ObjectId (id)}))
zurückkehren {"Status": "OK","Daten": Benutzer}

Definieren Sie zwei Get-Routen, die alle Daten in der Sammlung abrufen, und rufen Sie basierend auf der ID bestimmte Daten aus der Sammlung ab.

Aktualisieren Sie Daten mit der Put-Methode

Erstellen Sie die Put-Route, um die gespeicherten Daten in der Datenbank zu aktualisieren.

@user.put("/{id}")
asynchrondefupdate_user(ID: str, Benutzer: Benutzer):
 collection.find_one_and_update(
 {
"_Ausweis": ObjectId (id)
 }, 
 {
"$satz": dict (Benutzer)
 })
 user = users_serializer (collection.find({"_Ausweis": ObjectId (id)}))
zurückkehren {"Status": "OK","Daten": Benutzer}

Die Put-Methode verwendet die ID, um die spezifischen Daten in der Sammlung zu finden, und aktualisiert den Wert der Felder im Dokument mit den neuen Daten, die von der API übergeben werden. Sie können dann anhand der ID nach den aktualisierten Daten suchen und diese in der API-Antwort zurückgeben.

Löschen Sie Daten mit der Delete-Methode

Erstellen Sie die Löschroute, um die gespeicherten Daten in der Datenbank zu löschen.

@user.delete("/{id}")
asynchrondefBenutzer löschen(ID: str):
 collection.find_one_and_delete({"_Ausweis": ObjectId (id)})
 users = users_serializer (collection.find())
zurückkehren {"Status": "OK","Daten": []}

Die Löschroute übernimmt die ID des spezifischen Dokuments, das Sie aus der Sammlung löschen möchten.

Erstellen Sie REST-APIs mit FastAPI

FastAPI bietet eine großartige Möglichkeit zum bequemen Erstellen von Backend-Python-Web-APIs. Die integrierten Tools für die Datenbankintegration und die automatische API-Erstellung machen den Prozess einfach.

Sie können sogar noch einen Schritt weiter gehen und vollwertige Apps erstellen. Versuchen Sie, einen Front-End-Client mit gängigen Technologien wie React, Angular oder Vue zu integrieren.