Wie man mit NoSQL-Datenbank eine schnelle API-Anwendung einrichtet

Einführung

Beim Entwickeln von Python-Anwendungen zeichnet sich FastAPI durch eine hohe Leistung und einfache Nutzung aus. Es bietet Geschwindigkeit, Einfachheit und Unterstützung für asynchrone Programmierung, was es zu einer idealen Wahl für die Entwicklung modern scalierbarer Anwendungen macht.
In diesem Lehrgang werden wir Ihnen Schritte durchlaufen, um eine FastAPI-Anwendung mit einer NoSQL-Datenbank einzurichten. Bei der Speicherung und Verwaltung von Daten bieten NoSQL-Datenbanken Flexibilität und Skalierbarkeit, was sie zu einer großen Wahl für Anwendungen macht, die vielfältige und komplexe Datenstrukturen verarbeiten müssen.

Voraussetzungen

Bevor Sie beginnen, müssen Sie sicherstellen, dass Sie folgendes haben:

• Ein Server, der Ubuntu ausführt, zusammen mit einem nicht-root-Benutzer mit sudo-Berechtigungen und einer aktiven Firewall. Wenn Sie Hilfe benötigen, um dies einzurichten, wählen Sie Ihre Distribution von dieser Liste aus und folgen unserem Leitfaden für die Einrichtung des initialen Servers. Stellen Sie sicher, dass Sie mit einer unterstützten Version von Ubuntu arbeiten.

• Vertrautheit mit der Linux-Kommandozeile. Wenn du eine Einführung oder einen Erinnerungskurs in der Kommandozeile brauchst, kannst du diese Anleitung über Linux-Kommandozeile-Primer aufrufen.

• Führe sudo apt-get update im Ubuntu-Terminal aus, um sicherzustellen, dass dein System die neuesten Versionen und Sicherheitsupdates für die Software erhält, die aus den Repositories auf deinem System konfiguriert ist.

Schritt 1 – Einrichten des Python-Umgebens auf Ihrem Rechner

Im Verlauf dieses Leitfadens verwenden wir das Paket python3, um Befehle auszuführen. Die neuesten Ubuntu-Versionen verfügen über eine Python 3-Installation, um die Installation zu verifizieren, führen Sie den folgenden Befehl aus:

python3 --version

Wenn dies zu einem Fehler führt, können Sie das Paket installieren oder neu installieren, indem Sie die folgende Befehlsausführung durchführen:

sudo apt-get install python3

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

sudo apt-get install python3-pip

Schritt 2 – Erstellen eines virtuellen Umgebens

Ab Python 3.11 und pip 22.3 gibt es eine neue PEP 668, die die Markierung von Python-Basisumgebungen als „extern verwaltet“ vorschreibt, was bedeutet, dass Sie ohne eine virtuelle Umgebung nicht erfolgreich Pakete mit pip installieren können.

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

sudo apt-get install python3-venv

Dies installiert das erforderliche venv-Paket, das zur Erstellung einer virtuellen Umgebung notwendig ist.

python3 -m venv fastapi-env

Dieser Befehl erstellt eine virtuelle Umgebung namens fastapi-env innerhalb Ihres Arbeitsverzeichnisses. Um in dieser Umgebung zu arbeiten, müssen Sie sie aktivieren.

source fastapi-env/bin/activate

Nach erfolgreicher Ausführung sehen Sie die Befehlszeile mit folgendem Präfix:

(fastapi-env) user@machine:~$

Nun können Sie in dieser virtuellen Umgebung die erforderlichen Abhängigkeiten installieren.

Schritt 3 – Installieren von erforderlichen Bibliotheken und Paketen

In diesem Schritt werden Sie einige Pakete und Bibliotheken installieren, die erforderlich sind, um diesen Leitfaden erfolgreich fortzusetzen.

Wir beginnen mit der Installation von fastapi, die benötigt wird, um Ihre FastAPI-Anwendung zu erstellen, und uvicorn, das benötigt wird, um die FastAPI-Anwendung zu starten.

pip install fastapi uvicorn

In diesem Leitfaden verwenden wir MongoDB als NoSQL-Datenbank. Um mit MongoDB innerhalb Ihrer FastAPI zu interagieren, müssen Sie motor installieren, das ein asynchrones Python-Treiber für MongoDB ist.

pip install motor

Schritt 4 – Installieren und Einrichten von MongoDB auf Ubuntu

Um MongoDB auf Ihrem Ubuntu-Rechner zu installieren, führen Sie die folgenden Kommandos 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

Nach erfolgreicher Ausführung gibt dies das echo-Parameter zurück. Jetzt führen Sie schnell:

sudo apt-get update

Dies stellt sicher, dass Sie die neuesten Updates erhalten, nachdem Sie die MongoDB-Schlüssel eingerichtet haben.

Der nächste Schritt besteht darin, eine openssl-Abhängigkeit auf Ihrem System zu 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

Nach der Ausführung werden Sie dazu aufgefordert, Dienste neu zu starten. Nach dem Neustart installieren Sie MongoDB mit dem folgenden 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 – FastAPI-Anwendung erstellen

Der nächste Schritt besteht darin, eine FastAPI-Anwendung zu erstellen. Erstellen Sie im Ihren Arbeitsverzeichnis ein database.py Datei:

nano database.py

Dadurch wird ein leeres Texteditormenü geöffnet. Schreiben Sie Ihre Datenbankverbindungslogik hierhin.

from motor.motor_asyncio import AsyncIOMotorClient

MONGO_DETAILS = "mongodb://localhost:27017"

client = AsyncIOMotorClient(MONGO_DETAILS)

db = client.mydatabase

collection = db.mycollection

Vorgehensweise: Nehmen wir an, dass die mycollection von mydatabase mit einigen Daten befüllt ist, so erstellen Sie nun eine main.py, die die Logik Ihrer Anwendung enthält. In der folgenden FastAPI-App wird eine Datenbankverbindung mit Hilfe von database.py hergestellt, und Routen für die AI-Voraussage definiert. Mit diesen Routen wird der Input validiert.

nano main.py

Schreiben Sie in der Texteditor die Logik:

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

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

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

# definiere das Pydantic-Modell für die Eingabevalidierung
class InputData(BaseModel):
  feature: float

# route_1 zum Vorhersagen des Ausgangs auf der Basis von Eingabeparametern
@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 zum Interagieren mit MongoDB
@app.get("/items/")
async def get_item():
  items = []
  async for item in collection.find():
    items.append(item)
  return items

# route_3 zum Hinzufügen eines neuen Eintrags zu 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

Das bedeutet, dass diese Anwendung Folgendes erledigt:

• Lineares Regressionsmodell von sklearn: Dieses Modell prognostiziert ein Ausgangsdatum auf der Basis eines einzigen Eingabeparameters.
• Eingabedaten aus Pydantic-Modell: Dies definiert die erwartete Eingabestruktur für den Prediktions-Endpunkt. In diesem Fall ist es ein float.
• MongoDB-Routen: Die Routen /items/ und POST /items/ ermöglichen es Ihnen, Elemente in Ihrer MongoDB-Sammlung abzurufen und einzufügen.

Schritt 6 – FastAPI-Anwendung ausführen

Um diese Anwendung erfolgreich auszuführen, müssen Sie die Libraries und Packages, die in der Anwendung verwendet werden, installieren.

pip install pydantic scikit-learn numpy

Verwenden Sie nun den folgenden Befehl, um diese Anwendung auszuführen:

uvicorn main:app --reload

Die Ausgabe dieses Befehls wird sein:

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 mit Swagger UI interaktive API-Dokumentation generiert. Sie können darauf zugreifen, indem Sie zu http://127.0.0.1:8000/docs navigieren.

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

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 in einem Containerisierungsprozess zusammen mit docker-compose ausführen. Die Containerisierung Ihrer Anwendung vereinfacht den Deployment-Prozess, indem Sie Ihre Anwendung einfacher deployen, skalieren und verwalten können. Um Ihre Anwendung als Dockerfile zu definieren, folgen Sie den in Deploy FastAPI Application using Docker Compose beschriebenen Schritten.

Fazit

In diesem Tutorial haben Sie gelernt, wie Sie eine FastAPI-Anwendung mit MongoDB erfolgreich einrichten können, um eine einfache AI-basierte App zu erstellen, die Eingabepredictions speichern und abrufen kann.

Die Kombination von FastAPI und einer NoSQL-Datenbank bietet eine leistungsstarke und flexible Umgebung für den Bau und die Skalierung von AI-getriebenen Anwendungen.