Wie kann man Fast API mit einer relationalen Datenbank auf Ubuntu verwenden?

Einführung

FastAPI hat schnell an Popularität gewonnen als ein hochleistungsfähiges, einfach zu verwendendes Web-Framework für die Erstellung von APIs mit Python. Bei der Kombination mit einer relationalen Datenbank kann FastAPI zur Erstellung leistungsfähiger und skalierbarer Anwendungen verwendet werden. Diese Anleitung führt Sie durch den Prozess der Einrichtung einer FastAPI-Anwendung mit einer relationalen Datenbank auf einem Ubuntu 24.04-Rechner. Wir werden alles von der Installation der notwendigen Werkzeuge bis zur Konfiguration der Datenbank und der Erstellung von API-Endpunkten abdecken.

Verwende FastAPI mit einer PostgreSQL-Datenbank

• Python-Umgebung einrichten
• Erstellen und Aktivieren einer Virtualisierungsumgebung
• Installieren und Einrichten von PostgreSQL
• Schnelles FastAPI-Anwendungsentwickeln
• Erforderliche Bibliotheken installieren
• Python-Anwendung ausführen
• FastAPI-Anwendungsendpunkte testen

Voraussetzungen

Bevor du die Schritte in diesem Leitfaden befolgst, brauchst du:

• Einen Server, der Ubuntu ausführt, sowie einen nicht-root-Benutzer mit sudo-Rechten und einer aktiven Firewall. Wenn du Hilfe benötigst, um dies zu setzen, wähle deine Distribution aus dieser Liste und folge unserem Leitfaden für die Initialisierung des Servers. Stelle sicher, dass du mit einer unterstützten Version von Ubuntu arbeitest.

• Vertrautheit mit der Linux-Kommandozeile. Wenn du dich an die Kommandozeile erinnern oder lernen möchtest, kannst du diese Anleitung zu Linux-Kommandozeile-Primer besuchen.

• Führe sudo apt-get update im Ubuntu-Terminal aus, um sicherzugehen, dass dein System die neuesten Versionen und Sicherheitsupdates für die Software erhalten hat, die aus den auf deinem System konfigurierten Repositories verfügbar sind.

Schritt 1 – Python-Umgebung einrichten

Ubuntu 24.04 enthält Python 3 standardmäßig.Öffnen Sie den Terminal und führen Sie den folgenden Befehl aus, um die Installation von Python 3 zu prüfen:

python3 --version

Wenn Python 3 bereits auf Ihrem Rechner installiert ist, wird dieser Befehl die aktuelle Version der Python 3-Installation zurückgeben. Wenn er nicht installiert ist, können Sie den folgenden Befehl ausführen und die Installation von Python 3 erhalten:

sudo apt install python3

Nächstes müssen Sie die Paketinstaller pip und dev auf Ihrem System installieren. Führen Sie den folgenden Befehl im Terminal aus:

sudo apt install python3-pip python3-dev

In diesem Tutorial verwenden wir PostgreSQL als relationale Datenbank. Um mit der PostgreSQL-Datenbank zu interagieren, müssen Sie die libpq-dev installieren, indem Sie den folgenden Befehl verwenden:

sudo apt install libpq-dev

Schritt 2 – Erstellen und Aktivieren des virtuellen Umgebens

Der nächste Schritt besteht darin, ein virtuelles Umfeld innerhalb Ihrer Ubuntu-Installation zu erstellen, um Python-Pakete von Ihrem Systemumfeld zu isolieren. Um dies zu tun, gehen Sie zu Ihrem Arbeitsverzeichnis und führen Sie die folgenden Befehle aus:

python3 -m venv fastapi-env

Dieser Befehl wird ein neues virtuelles Umfeld in einem Verzeichnis namens fastapi-env erzeugen. Es wird seine eigene Sammlung von dedizierten Python-Paketen haben, isoliert von anderen Projekten.

Um sicherzustellen, dass die von nun an installierten Pakete innerhalb dieses isolierten Umfeldes installiert werden, müssen Sie es aktivieren, indem Sie ausführen:

source fastapi-env/bin/activate

Bei der Ausführung wird die Terminalbenachrichtigung mit Ihrem virtuellen Umgebungsnamen als Präfix erkennbar sein, z.B. wie folgt:

Output
(fastapi-env) ubuntu@user:

Schritt 3 – PostgreSQL installieren und einrichten

Der nächste Schritt besteht darin, PostgreSQL (oder Ihre Wahl der relationalen Datenbank) zu installieren.

sudo apt install postgresql postgresql-contrib

Nun ist es Zeit, den PostgreSQL-Dienst innerhalb Ihrer virtuellen Umgebung zu starten und zu aktivieren.

sudo systemctl start postgresql
sudo systemctl enable postgresql

Um PostgreSQL mit FastAPI zu installieren und zu verwenden, müssen Sie einige Dinge installieren:

1. asyncpg: Dies ist ein asynchrones PostgreSQL-Treiber, der FastAPI erlaubt, mit einer PostgreSQL-Datenbank zu interagieren.
2. SQLAlchemy: Dies ist ein ORM-Tool, das Ihnen hilft, Datenbankschemas und Abfragen als Python-Code zu verwalten, anstatt Roh SQL zu schreiben.
3. databases: Dies ist eine Datenbankbibliothek für asynchrone Operationen, die von SQLAlchemy für den asynchronen Betrieb mit FastAPI benötigt werden.

Um diese zu installieren, führen Sie den folgenden konsolidierten Befehl aus:

pip install asyncpg sqlalchemy databases

Der nächste Schritt besteht darin, eine Postgres-Datenbank und einen Benutzer mit den erforderlichen Rechten zu erstellen.

sudo -u postgres psql
CREATE DATABASE <user_db>;
CREATE ROLE <username> WITH PASSWORD '<password>';
GRANT ALL PRIVILEGES ON DATABASE <user_db> TO <username>;
exit

Schritt 4 – Erstellen eines Beispielpython-Anwendungen

Sie benötigen eine ausführbare Python-Anwendung, die über FastAPI auf Ihre Datenbank zugreift. Wenn Sie noch keine laufende Python-Anwendung haben, können Sie schnell eine erstellen, indem Sie die folgenden Schritte ausführen:

Erstellen Sie eine neue Python-Datei mit dem Namen postgres_db.py in Ihrem Projektverzeichnis.

nano postgres_db.py

Im Texteditor schreiben Sie die Logik, um eine Datenbankverbindung zu erstellen und eine Tabelle in der Datenbank zu erstellen. In diesem Beispiel erstellen wir eine PostgreSQL-Datenbankverbindung mit dem databases-Paket und definieren die Struktur einer books-Tabelle mithilfe von SQLAlchemy.

from databases import Database
from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, Float

DB_URL = "postgresql://username:password@localhost/user_db"

database = Database(DB_URL)
metadata = MetaData()

books = Table (
  "books",
  metadata,
  Column("id", Integer, primary_key=True, index=True),
  Column("title", String, index=True),
  Column("author", String, index=True),
  Column("price", Float),
)

engine = create_engine(DB_URL)
metadata.create_all(engine)

Speichern und schließen Sie die Datei.

Erstellen Sie als Nächstes eine Datei mit dem Namen main.py im selben Verzeichnis.

nano main.py

Schreiben Sie die Hauptlogik Ihrer Anwendung in diese Datei:

from fastapi import FastAPI
from typing import List
from pydantic import BaseModel
from postgres_db import books, database

app = FastAPI()

class BookCreate(BaseModel):
    title: str
    author: str
    price: float

class BookResponse(BaseModel):
    id: int
    title: str
    author: str
    price: float

class Config:
  orm_mode=True

@app.on_event("startup")
async def startup():
    await database.connect()

@app.on_event("shutdown")
async def shutdown():
    await database.disconnect()

@app.post("/books/", response_model=BookResponse)
async def create_book(book: BookCreate):
    query = books.insert().values(title=book.title, author=book.author, price=book.price)
    last_book_id = await database.execute(query)

    query = books.select().where(books.c.id == last_book_id)
    inserted_book = await database.fetch_one(query)
    return inserted_book

@app.get("/books/", response_model=List[BookResponse])
async def get_books():
    query = books.select()
    return await database.fetch_all(query)

Dieser Code verwendet FastAPI, um neue Bucheinträge in der PostgreSQL-Datenbank zu speichern und die Sammlung von Büchern daraus abzurufen.

Schritt 5 – Erforderliche Bibliotheken installieren

In Ihrer Python-Anwendung verweisen Sie auf verschiedene Bibliotheken und Pakete. Bevor Sie die Anwendung ausführen, stellen Sie sicher, dass die erforderlichen Bibliotheken installiert sind.

pip install fastapi uvicorn psycopg2

Schritt 6 – Python-Anwendung ausführen

Jetzt ist es Zeit, die von Ihnen erstellte Anwendung auszuführen.

uvicorn main:app --reload

uvicorn ist ein Asynchrones Server Gateway Interface (ASGI), das zur Bereitstellung von FastAPI-Anwendungen verwendet wird. Die Verwendung von uvicorn ist die bevorzugte Methode, um eine FastAPI-Anwendung auszuführen, da FastAPI selbst ein asynchrones Web-Framework ist.

Wenn der obige Befehl ohne auf einen Fehler zu treffen ausgeführt wird, sehen Sie eine Ausgabe ähnlicherartig dem folgenden:

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 [XXXX] using StatReload
INFO:     Started server process [YYYY]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

In einem Web-Browser navigieren Sie zu http://127.0.0.1:8000, um die Abfrage-Ausgabe zu sehen.

Schritt 7 [OPTIONAL] – Testen der Endpunkte

Sie können die in Ihrem main.py definierten Endpunkte (d.h. POST und GET) testen, indem Sie HTTP-Anfragen an den auf http://127.0.0.1:8000 laufenden Server senden.

{
  "title": "The Great Gatsby",
  "author": "F. Scott Fitzgerald",
  "price": 10.99
}

Ähnlichermaßen können Sie einen GET-Aufruf an denselben Server tätigen, um die Liste der Bücher, die in Ihrer Postgres-Datenbank vorhanden sind, abzurufen.

Fazit

In diesem Tutorial haben Sie den Prozess beschrieben, wie Sie eine einfache FastAPI-Anwendung einrichten, die mit einer PostgreSQL-Datenbank interagiert. Diese Schritte sind auch für AI-Anwendungen von Vorteil, insbesondere wenn Sie eine Web-API zum Interagieren mit Ihren AI-Modellen oder die Verwaltung von Daten, die mit Ihren AI-Prozessen in Verbindung stehen, aufbauen müssen. Mit dieser Grundlage können Sie Ihre FastAPI-Projekte nun aufbauen und erweitern.

Bleiben Sie aufmerksam auf weitere Artikel über die Arbeit mit FastAPI.