So richten Sie eine FastAPI-Anwendung mit einer NoSQL-Datenbank ein

Bei der Entwicklung von Python-Anwendungen ist FastAPI eine der besten Optionen für leistungsstarke Lösungen. Es bietet Geschwindigkeit, Einfachheit und Unterstützung für asynchrones Programmieren und ist damit ideal für die Entwicklung moderner, skalierbarer Anwendungen. In diesem Tutorial führen wir Sie durch den Prozess der Einrichtung einer FastAPI-Anwendung mit einer NoSQL-Datenbank. Wenn es um die Speicherung und Verwaltung von Daten geht, bieten NoSQL-Datenbanken Flexibilität und Skalierbarkeit und sind damit ideal für Anwendungen, die mit vielfältigen und komplexen Datenstrukturen umgehen müssen.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

• Einen Server mit Ubuntu sowie einen Nicht-Root-Benutzer mit sudo-Rechten und einer aktiven Firewall. Informationen zur Einrichtung finden Sie in unserer Anleitung zur Servergrundkonfiguration, die für Ihre Ubuntu-Version relevant ist. Bitte stellen Sie sicher, dass Sie eine unterstützte Ubuntu-Version verwenden.
• Grundkenntnisse in der Nutzung der Linux-Kommandozeile. Falls Sie eine Einführung oder eine Auffrischung benötigen, können Sie unseren Leitfaden zur Linux-Kommandozeile nutzen.
• Führen Sie sudo apt-get update im Ubuntu-Terminal aus, um sicherzustellen, dass Ihr System über die neuesten Softwareversionen und Sicherheitsupdates verfügt.
• Diese Anleitung ist gültig für die aktuellen Ubuntu-Versionen: Ubuntu 24.04, Ubuntu 22.04 und Ubuntu 20.04. Falls Sie eine Ubuntu-Version <= 18.04 verwenden, empfehlen wir Ihnen, auf eine neuere Version zu aktualisieren, da ältere Versionen nicht mehr unterstützt werden. Diese Anleitungen helfen Ihnen beim Upgrade Ihrer Ubuntu-Version.

Schritt 1 - Einrichten der Python-Umgebung auf Ihrem System

In diesem Tutorial verwenden wir das Python3-Paket zum Ausführen von Befehlen. Neuere Ubuntu-Versionen verfügen bereits über eine vorinstallierte Python-3-Version. Überprüfen Sie die Installation mit folgendem Befehl:

python3 --version

Falls dabei ein Fehler auftritt, können Sie das Paket mit folgendem Befehl installieren bzw. neu installieren:

sudo apt-get install python3

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

sudo apt-get install python3-pip

Schritt 2 - Erstellen einer virtuellen Umgebung

Wenn Sie Ubuntu-Version < 24.04 verwenden, ist die Erstellung einer virtuellen Umgebung nicht zwingend erforderlich. Dennoch ist es eine gute Praxis, die Abhängigkeiten Ihres Projekts zu isolieren.

Ab Python 3.11 und pip 22.3 wurde PEP 668 eingeführt, wodurch Python-Umgebungen als „extern verwaltet“ markiert werden. Dies bedeutet, dass die Installation von Paketen mit pip außerhalb einer virtuellen Umgebung möglicherweise fehlschlägt.

Erstellen Sie eine virtuelle Umgebung für Ihr Projekt, um mögliche Konflikte zwischen verschiedenen Paketversionen zu vermeiden:

sudo apt-get install python3-venv
python3 -m venv fastapi-env
source fastapi-env/bin/activate

Nach erfolgreicher Ausführung wird die Terminal-Eingabeaufforderung wie folgt angezeigt:

(fastapi-env) user@machine:~$

Schritt 3 - Installation der benötigten Bibliotheken und Pakete

In diesem Schritt installieren Sie einige Pakete und Bibliotheken, die erforderlich sind, um diesem Tutorial erfolgreich zu folgen.

Beginnen wir mit der Installation von fastapi, das für den Aufbau Ihrer FastAPI-Anwendung erforderlich ist, und uvicorn, das für die Ausführung der FastAPI-Anwendung benötigt wird.

pip install fastapi uvicorn
pip install motor

Wir verwenden MongoDB als NoSQL-Datenbank. Um mit MongoDB innerhalb Ihrer FastAPI-Anwendung zu interagieren, müssen Sie motor installieren, einen asynchronen Python-Treiber für MongoDB.

Schritt 4 - Installation und Einrichtung von MongoDB auf Ubuntu

Installieren Sie MongoDB mit den folgenden Befehlen:

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

Führen Sie ein Update durch, um sicherzustellen, dass alle Pakete auf dem neuesten Stand sind:

sudo apt-get update

Dadurch wird sichergestellt, dass Sie nach der Einrichtung der 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 MongoDB-Installation 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

Während der Ausführung werden Sie aufgefordert, Dienste neu zu starten. Nach dem Neustart installieren Sie MongoDB 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 besteht darin, eine FastAPI-Anwendung zu erstellen. In Ihrem Arbeitsverzeichnis erstellen Sie eine database.py-Datei:

nano database.py

Dies öffnet einen leeren Texteditor. Schreiben Sie hier die Logik für die Datenbankverbindung:

# database.py
from motor.motor_asyncio import AsyncIOMotorClient

MONGO_DETAILS = "mongodb://localhost:27017"

client = AsyncIOMotorClient(MONGO_DETAILS)

db = client.mydatabase

collection = db.mycollection

Angenommen, mycollection in mydatabase enthält bereits einige Daten, erstellen Sie nun eine main.py-Datei, die die Logik Ihrer Anwendung enthält:

nano main.py

Schreiben Sie in den Texteditor die Logik für Ihre FastAPI-Anwendung:

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

# Einfacher Datensatz und Modell
x = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])

model = LinearRegression()
model.fit(x, y)

# Definition des Pydantic-Modells zur Eingabevalidierung
class InputData(BaseModel):
  feature: float

# Route 1: Vorhersage der Ausgabe basierend auf der Eingabevariable
@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: Interaktion mit MongoDB - Abrufen von Elementen
@app.get("/items/")
async def get_item():
  items = []
  async for item in collection.find():
    items.append(item)
  return items

# Route 3: Einfügen eines neuen Elements in MongoDB
@app.post("/items/")
async def create_item(item: dict):
  new_item = await collection.insert_one(item)
  created_item = await collection.find_one({"_id": new_item.inserted_id})
  return created_item

Anwendungsübersicht

• Lineares Regressionsmodell aus Scikit-learn: Dieses Modell sagt eine Ausgabe basierend auf einer einzelnen Eingangsvariable voraus.
• InputData aus Pydantic: Definiert die erwartete Eingabestruktur für den Vorhersage-Endpunkt. In diesem Fall handelt es sich um eine Gleitkommazahl.
• MongoDB-Routen:
  • Die GET /items/-Route ermöglicht das Abrufen gespeicherter Elemente aus MongoDB.
  • Die POST /items/-Route ermöglicht das Hinzufügen neuer Elemente zu MongoDB.

Schritt 6 - Starten der FastAPI-Anwendung

Um diese Anwendung erfolgreich auszuführen, müssen Sie die erforderlichen Bibliotheken und Pakete installieren.

pip install pydantic scikit-learn numpy

Nun können Sie die Anwendung mit folgendem Befehl starten:

uvicorn main:app --reload

Ausgabe der Anwendung

Wenn Sie den obigen Befehl ausführen, zeigt das Terminal eine ähnliche Ausgabe wie diese:

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 generiert automatisch eine interaktive API-Dokumentation mit Swagger UI. Sie können darauf zugreifen, indem Sie die folgende URL in Ihrem Browser öffnen http://127.0.0.1:8000/docs.

Testen des API-Endpunkts

Sie können curl oder Postman verwenden, um eine Anfrage an den Endpunkt zu senden und eine Vorhersage basierend auf Ihrer Eingabe zu erhalten. Verwenden Sie dazu den folgenden Befehl:

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

Schritt 7 [OPTIONAL] – Anwendung mit Docker Compose ausführen

Sie können Ihre Anwendung containerisieren und mit Docker Compose ausführen. Die Containerisierung vereinfacht den Bereitstellungsprozess, indem sie Ihre Anwendung einfacher zu verwalten, zu skalieren und bereitzustellen macht.

Fazit

In diesem Tutorial haben Sie gelernt, wie Sie eine FastAPI-Anwendung mit MongoDB einrichten, um eine einfache KI-basierte Anwendung zu erstellen, die Vorhersagen speichern und abrufen kann.

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