Wie man eine schnelle API-Anwendung mit einer NoSQL-Datenbank startet

Einführung

Bei der Entwicklung von Python-Anwendungen erweist sich FastAPI als optimale Wahl für leistungsstarke Lösungen. Es bietet Geschwindigkeit, Einfachheit und Unterstützung für asynchrone Programmierung und ist damit ideal für die Entwicklung moderner, skalierbarer Anwendungen. Dieses Tutorial führt Sie durch die Einrichtung einer FastAPI-Anwendung mit einer NoSQL-Datenbank. NoSQL-Datenbanken bieten Flexibilität und Skalierbarkeit beim Speichern und Verwalten von Daten und sind daher eine hervorragende Ressource für Anwendungen, die vielfältige und komplexe Datenstrukturen verwalten müssen.

Voraussetzungen

• Ein Server mit Ubuntu, auf dem ein Benutzer ohne Root-Rechte (sudo) und eine aktivierte Firewall läuft. Anweisungen zur Einrichtung finden Sie in unserer Anleitung „Erste Schritte mit einem Server“. Wählen Sie dazu Ihre Ubuntu-Distribution aus der Liste aus. Bitte stellen Sie sicher, dass Sie eine unterstützte Ubuntu-Version verwenden.
• Einführung in die Linux-Befehlszeile: Zur Einführung oder Auffrischung Ihres Wissens über die Befehlszeile können Sie sich diesen Leitfaden zur Linux-Befehlszeile ansehen.
• Führen Sie im Ubuntu-Terminal den Befehl sudo apt-get update aus, um sicherzustellen, dass Ihr System über die neuesten Versionen und Sicherheitsupdates für die in den auf Ihrem System konfigurierten Repositories verfügbare Software verfügt.

Schritt 1 – Richten Sie die Python-Umgebung auf Ihrem Rechner ein.

In diesem Tutorial verwenden wir das Paket python3, um Befehle auszuführen. Die neueste Version von Ubuntu enthält bereits Python 3. Um die Installation zu überprüfen, führen Sie folgenden Befehl aus:

python3 --version

Falls der Fehler erneut auftritt, können Sie das Paket durch Ausführen folgender Befehl installieren/neu installieren:

sudo apt-get install python3

Als Nächstes müssen Sie pip installieren, um Python-Pakete und deren Abhängigkeiten sicher zu installieren.

sudo apt-get install python3-pip

Schritt 2 – Erstellen einer virtuellen Umgebung

Bei Verwendung einer Ubuntu-Version < 24.04 ist die Erstellung einer virtuellen Umgebung nicht erforderlich, es empfiehlt sich jedoch, die Projektabhängigkeiten zu trennen.

Ab Python 3.11 und pip 22.3 gibt es einen neuen PEP 668, der besagt, dass Python-Basisumgebungen als «extern verwaltet» gekennzeichnet werden sollten. Das bedeutet, dass Sie pip nicht erfolgreich zum Installieren von Paketen verwenden können, es sei denn, Sie arbeiten in einer virtuellen Umgebung.

In diesem Schritt erstellen Sie eine virtuelle Umgebung für Ihr Projekt, die die Abhängigkeiten Ihres Projekts isoliert, um potenzielle Konflikte zwischen verschiedenen Paketversionen zu vermeiden. Führen Sie die folgenden Befehle im Terminal aus:

sudo apt-get install python3-venv

Dadurch wird das venv-Paket installiert, das zum Erstellen einer virtuellen Umgebung erforderlich ist.

python3 -m venv fastapi-env

Dieser Befehl erstellt eine virtuelle Umgebung namens „fastapi-env“ in Ihrem Arbeitsverzeichnis. Um in dieser Umgebung arbeiten zu können, müssen Sie sie aktivieren.

source fastapi-env/bin/activate

Bei erfolgreicher Ausführung wird das Terminalpräfix wie folgt angezeigt:

(fastapi-env) user@machine:~$

Sie können nun mit der Installation der erforderlichen Abhängigkeiten innerhalb dieser virtuellen Umgebung beginnen.

Schritt 3 – Installieren Sie die benötigten Bibliotheken und Pakete

In diesem Schritt installieren Sie einige Pakete und Bibliotheken, die für das erfolgreiche Befolgen dieses Tutorials erforderlich sind.

Beginnen wir mit der Installation von Fastapi, das zum Erstellen Ihrer FastAPI-Anwendung benötigt wird, und Unicorn, das zum Ausführen Ihrer FastAPI-Anwendung benötigt wird.

pip install fastapi uvicorn

In diesem Tutorial verwenden wir MongoDB als NoSQL-Datenbank. Um von Ihrer FastAPI aus mit MongoDB zu interagieren, müssen Sie die Engine installieren. Dabei handelt es sich um einen asynchronen Python-Treiber für MongoDB.

pip install motor

Schritt 4 – MongoDB auf Ubuntu installieren und einrichten

Um MongoDB auf Ihrem Ubuntu-Rechner zu installieren, führen Sie die folgenden Befehle im Terminal aus:

wget -qO - https://www.mongodb.org/static/pgp/server-7.0.asc | sudo gpg --dearmor -o /usr/share/keyrings/mongodb-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/mongodb-archive-keyring.gpg] https://repo.mongodb.org/apt/ubuntu $(lsb_release -cs)/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list

Bei erfolgreicher Ausführung gibt dieser Parameter „echo“ zurück. Jetzt schnell ausführen:

sudo apt-get update

Dadurch wird sichergestellt, dass Sie nach der Einrichtung Ihrer MongoDB-Schlüssel die neuesten Updates erhalten.

Als Nächstes müssen Sie eine OpenSSL-Abhängigkeit auf Ihrem System installieren, die für die Installation von MongoDB erforderlich ist.

wget http://archive.ubuntu.com/ubuntu/pool/main/o/openssl/libssl1.1_1.1.1f-1ubuntu2_amd64.deb
sudo dpkg -i libssl1.1_1.1.1f-1ubuntu2_amd64.deb

Beim Ausführen werden Sie aufgefordert, die Dienste neu zu starten. Installieren Sie MongoDB nach dem Neustart mit folgendem Befehl:

sudo apt-get install -y mongodb

Starten und aktivieren Sie die MongoDB-Dienste:

sudo systemctl start mongod
sudo systemctl enable mongod

Sie können den Status des MongoDB-Dienstes überprüfen und die Verbindung testen, indem Sie die folgenden Befehle ausführen:

sudo systemctl status mongod

mongo --eval 'db.runCommand({connectionStatus: 1})'

Schritt 5 – Erstellen einer FastAPI-Anwendung

Der nächste Schritt ist die Erstellung einer FastAPI-Anwendung. Erstellen Sie dazu in Ihrem Arbeitsverzeichnis eine Datei namens database.py:

nano database.py

Dadurch öffnet sich ein leerer Texteditor. Schreiben Sie hier Ihre Datenbankverbindungslogik.

from motor.motor_asyncio import AsyncIOMotorClient
MONGO_DETAILS = "mongodb://localhost:27017"
client = AsyncIOMotorClient(MONGO_DETAILS)
db = client.mydatabase
collection = db.mycollection

Angenommen, die Sammlung „mydatabase“ enthält bereits Daten, erstellen Sie nun eine Datei namens „main.py“, die Ihre Anwendungslogik enthält. In der unten stehenden FastAPI-Anwendung wird eine Datenbankverbindung mithilfe der Pfade aus „database.py“ für die KI-Vorhersage definiert. Mithilfe dieser Pfade werden die Eingaben validiert.

nano main.py

Schreiben Sie die Logik in den Texteditor:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from sklearn.linear_model import LinearRegression
import numpy as np
from database import collection
app = FastAPI()
# simple dataset and model
x = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])
model = LinearRegressions()
model.fit(x, y)
# define the Pydantic model for input validation
class InputData(BaseModel):
feature: float
# route_1 for predicting the output based on input feature
@app.post("/predict/")
async def predict(input_data: InputData):
try:
prediction = model.predict([[input_data.feature]])
return {"prediction": prediction[0]}
except Exception as ex:
raise HTTPException(status_code=400, detail=str(ex))
# route_2 to interact with MongoDB
@app.get("/items/")
async def get_item():
items = []
async for item in collection.find():
items.append(item)
return items
# route_3 to add a new item to MongoDB
@app.post("/items/")
async def create_item(item: dict):
new_item = await collection.insert_one(item)
created_item = await collection.fine_one({"_id": new_item.inserted_id})
return created_item

Hier eine Zusammenfassung der Funktionen dieses Programms:

• Lineares Regressionsmodell aus sklearn: Dieses Modell sagt eine Ausgabe auf der Grundlage eines Eingabemerkmals voraus.
• Eingabedaten des Pydantic-Modells: Diese Struktur definiert die erwartete Eingabe für den Vorhersage-Endpunkt. In diesem Fall handelt es sich um eine Gleitkommazahl.
• MongoDB-Routen: Mit den Routen /items/ und POST /items/ können Sie Elemente abrufen und in Ihre MongoDB-Sammlung einfügen.

Schritt 6 – Führen Sie die FastAPI-Anwendung aus

Um dieses Programm erfolgreich auszuführen, müssen Sie die im Programm verwendeten Bibliotheken und Pakete installieren.

pip install pydantic scikit-learn numpy

Verwenden Sie nun den folgenden Befehl, um dieses Programm auszuführen:

uvicorn main:app --reload

Die Ausgabe dieses Befehls lautet wie folgt:

Output
INFO: Will watch for changes in these directories: ['/path/to/your/project']
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO: Started reloader process [XXXXX] using statreload
INFO: Started server process [XXXXX]
INFO: Waiting for application startup.
INFO: Application startup complete.

FastAPI hat automatisch eine interaktive API-Dokumentation mit Swagger UI generiert. Sie können diese unter http://127.0.0.1:8000/docs aufrufen.

Sie können Tools wie curl oder Postman verwenden, um einen Endpunkt aufzurufen, der basierend auf Ihrer Eingabe einen Wert vorhersagt.

curl -X POST "http://127.0.0.1:8000/predict/" -H "Content-type: application/json" -d '{"feature": 3}'

Schritt 7 [Optional] – Führen Sie die Anwendung mit Docker Compose aus

Sie können Ihre Anwendung in einem Container kapseln und mit Docker Compose ausführen. Die Containerisierung vereinfacht den Bereitstellungsprozess, da sie das Bereitstellen, Skalieren und Warten Ihrer Anwendung erleichtert.

Ergebnis

In diesem Tutorial haben Sie gelernt, wie Sie erfolgreich eine FastAPI-Anwendung mit MongoDB starten und eine einfache KI-basierte Anwendung erstellen, die in der Lage ist, Eingabevorhersagen zu speichern und abzurufen.

Die Kombination aus FastAPI und NoSQL-Datenbank bietet eine leistungsstarke und flexible Umgebung für die Entwicklung und Skalierung KI-gestützter Anwendungen.