Eigene Foren mit FastAPI erstellen: Schritt 1 – Ein minimales Forum

Es gibt bereits viele Forum-Produkte auf dem Markt, aber sind Sie immer noch frustriert, weil keines davon Ihre speziellen Bedürfnisse erfüllt? Wenn ja, warum erstellen Sie nicht selbst ein Forum von Grund auf neu?

Lassen Sie sich nicht von riesigen Forum-SaaS-Plattformen wie Discourse einschüchtern; der Aufbau eines Forums ist nicht so schwierig, wie es scheint.

In der kommenden Artikelreihe führen wir Sie Schritt für Schritt von Grund auf zum Erstellen einer voll funktionsfähigen, modernen Forum-Website mit dem beliebten Python-Web-Framework FastAPI.

Diese Tutorial-Reihe richtet sich an Anfänger. Am Ende dieses ersten Artikels haben Sie ein lauffähiges Mini-Forum, ähnlich dem unten gezeigten:

Beginnen wir ohne weitere Umschweife:

Schritt 1: Einrichtung der Umgebung

Bereiten wir zunächst die Entwicklungsumgebung vor.

Projektverzeichnis und virtuelle Umgebung erstellen

Erstellen Sie einen dedizierten Ordner für das Projekt und darin eine virtuelle Umgebung.

Zur Einfachheit werden wir das integrierte venv-Modul von Python verwenden. Es gibt viele andere großartige Werkzeuge für virtuelle Umgebungen wie poetry, die Sie selbst erkunden können.

# Projektverzeichnis erstellen und betreten
mkdir fastapi-forum
cd fastapi-forum

# Virtuelle Umgebung erstellen
python3 -m venv venv

# Virtuelle Umgebung aktivieren
# Windows:
# venv\Scripts\activate
# macOS / Linux:
source venv/bin/activate

Nach erfolgreicher Aktivierung sehen Sie (venv) vor Ihrer Kommandozeilenaufforderung.

FastAPI und Uvicorn installieren

Als Nächstes installieren wir die Kernbibliotheken, die für diesen Artikel benötigt werden: fastapi und uvicorn.

• fastapi: Das Framework selbst.
• uvicorn: Ein ASGI-Server, der zum Ausführen unserer FastAPI-Anwendung verwendet wird.

pip install fastapi "uvicorn[standard]"

"uvicorn[standard]" installiert uvicorn zusammen mit einigen empfohlenen Abhängigkeiten für eine optimale Leistung.

Schritt 2: „Hallo, Forum!“ Die FastAPI-App zum Laufen bringen

Mit der vorbereiteten Umgebung schreiben wir unsere erste Zeile FastAPI-Code. Erstellen Sie eine Datei mit dem Namen main.py im Verzeichnis fastapi-forum und fügen Sie den folgenden Inhalt hinzu:

main.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello, Forum!"}

Was macht dieser Code?

1. Erstellt eine Instanz von FastAPI und nennt sie app.
2. @app.get("/") ist ein Dekorator. Er teilt FastAPI mit, dass die Funktion read_root unten GET-Anfragen an den Pfad / bearbeitet.
3. Wenn eine Anfrage den Root-Pfad erreicht, gibt die Funktion ein Python-Dictionary zurück, das FastAPI automatisch in eine JSON-Antwort umwandelt.

Führen Sie als Nächstes die Anwendung in Ihrem Terminal aus:

uvicorn main:app --reload

• main: Bezieht sich auf die Datei main.py.
• app: Bezieht sich auf die FastAPI-Instanz app, die Sie in main.py erstellt haben.
• --reload: Dies ist ein sehr nützlicher Parameter, der den Server nach Codeänderungen automatisch neu startet.

Öffnen Sie nun Ihren Browser und navigieren Sie zu http://127.0.0.1:8000. Sie sehen:

{ "message": "Hello, Forum!" }

Glückwunsch! Ihre erste FastAPI-Anwendung läuft jetzt erfolgreich!

Schritt 3: Die Kern-Datenstruktur definieren

Unser Forum dient zur Veröffentlichung von Beiträgen und daher benötigen wir eine klare Datenstruktur, die definiert, wie ein „Beitrag“ aussieht. FastAPI empfiehlt die Verwendung von Pydantic für die Daten definiert und Validierung. Es ist in FastAPI integriert und sehr leistungsfähig.

Definieren wir ein Post-Modell in main.py.

main.py (Aktualisiert)

from fastapi import FastAPI
from pydantic import BaseModel
from typing import List

# 1. Das Datenmodell definieren
class Post(BaseModel):
    id: int
    title: str
    content: str

app = FastAPI()

# 2. Eine Liste als In-Memory-Datenbank verwenden
# Hinweis: Dies dient nur zur Demonstration. Die Daten gehen beim Neustart des Servers verloren!
db: List[Post] = [
    Post(id=1, title="What is FastAPI?", content="A modern, high-performance Python web framework..."),
    Post(id=2, title="Introduction to Pydantic", content="Pydantic is a library for data validation and settings management..."),
]

@app.get("/")
def read_root():
    return {"message": "Welcome to my forum!"}

# Nachfolgende APIs werden hier hinzugefügt...

Wir haben eine Post-Klasse erstellt, die von pydantic.BaseModel erbt. Wir haben definiert, dass ein Beitrag drei Felder haben soll: id (Integer), title (String) und content (String).

Wir haben auch eine Liste namens db erstellt und sie mit zwei Post-Objekten vorab gefüllt, um unsere Datenbank zu simulieren.

Schritt 4: Die Kern-APIs implementieren

Ein Basis-Forum benötigt zwei Funktionen: Beiträge anzeigen und Beiträge erstellen. Implementieren wir die entsprechenden API-Endpunkte.

1. Alle Beiträge abrufen

Wir benötigen einen Endpunkt, der alle Beiträge in unserer db-Liste zurückgibt. Fügen Sie den folgenden Code zu main.py hinzu:

main.py (Fortgesetzt)

... # Vorheriger Code bleibt unverändert

# 3. API zum Abrufen der Beitragsliste
@app.get("/api/posts", response_model=List[Post])
def get_posts():
    return db

• @app.get("/api/posts"): Wir definieren einen neuen Pfad /api/posts, der GET-Anfragen bearbeitet.
• response_model=List[Post]: Dies teilt FastAPI mit, dass der Antwortkörper für diesen Endpunkt eine Liste von Post-Objekten sein wird. FastAPI verwendet dies für die Datenvalidierung, -konvertierung und die klare Dokumentation in der API-Dokumentation.

2. Einen neuen Beitrag erstellen

Als Nächstes kommt der Endpunkt zum Erstellen eines neuen Beitrags.

Installieren Sie zunächst python-multipart, um die Verarbeitung von Formulardaten zu unterstützen:

pip install python-multipart

main.py (Fortgesetzt)

# ... Vorheriger Code bleibt unverändert

# 4. API zum Erstellen eines neuen Beitrags
@app.post("/api/posts", response_model=Post)
def create_post(title: str = Form(...), content: str = Form(...)):
    new_id = len(db) + 1
    new_post = Post(
        id=new_id,
        title=title,
        content=content
    )
    db.append(new_post)
    return new_post

Das Parameterformat title: str = Form(...) weist FastAPI an, die Daten aus Formularfeldern zu extrahieren.

Warum sind die Ein-/Ausgabeformate Felder? Weil wir später eine HTML-Seite erstellen werden, auf der Benutzer über ein Formular Inhalte einreichen können.

Schritt 5: Eine einfache interaktive Seite

Eine reine API kann nicht wirklich als Forum bezeichnet werden. Wir können HTMLResponse von FastAPI verwenden, um schnell eine nutzbare HTML-Seite zu erstellen, die es Benutzern ermöglicht, Beiträge direkt in ihrem Browser zu erstellen und anzuzeigen.

Wir erstellen einen neuen Pfad GET /posts, um diese Seite anzuzeigen.

main.py (Endgültige vollständige Version)

from fastapi import FastAPI, Form
from fastapi.responses import HTMLResponse, RedirectResponse
from pydantic import BaseModel
from typing import List

# --- Datenmodelle ---
class Post(BaseModel):
    id: int
    title: str
    content: str

# --- In-Memory-Datenbank ---
db: List[Post] = [
    Post(id=1, title="What is FastAPI?", content="A modern, high-performance Python web framework..."),
    Post(id=2, title="Introduction to Pydantic", content="Pydantic is a library for data validation and settings management..."),
]

app = FastAPI()

# --- HTML-Vorlage ---
def generate_html_response():
    posts_html = ""
    for post in reversed(db):  # Neue Beiträge oben anzeigen
        posts_html += f"""
        <div style="border: 1px solid #ccc; padding: 10px; margin-bottom: 10px;">
            <h3>{post.title} (ID: {post.id})</h3>
            <p>{post.content}</p>
        </div>
        """

    html_content = f"""
    <html>
        <head>
            <title>Mein FastAPI Forum</title>
            <style>
                body {{ font-family: sans-serif; margin: 2em; }}
                input, textarea {{ width: 100%; padding: 8px; margin-bottom: 10px; box-sizing: border-box; }}
                button {{ padding: 10px 15px; background-color: #007BFF; color: white; border: none; cursor: pointer; }}
                button:hover {{ background-color: #0056b3; }}
            </style>
        </head>
        <body>
            <h1>Willkommen in meinem Forum</h1>
            <h2>Neuen Beitrag erstellen</h2>
            <form action="/api/posts" method="post">
                <input type="text" name="title" placeholder="Titel des Beitrags" required><br>
                <textarea name="content" rows="4" placeholder="Inhalt des Beitrags" required></textarea><br>
                <button type="submit">Posten</button>
            </form>
            <hr>
            <h2>Beitragsliste</h2>
            {posts_html}
        </body>
    </html>
    """
    return HTMLResponse(content=html_content, status_code=200)

# --- Routen ---

@app.get("/", response_class=RedirectResponse)
def read_root():
    # Root-Pfad auf unsere Ansichtsseite umleiten
    return "/posts"

# Route zum Anzeigen der Seite
@app.get("/posts", response_class=HTMLResponse)
async def view_posts():
    return generate_html_response()

@app.post("/api/posts")
def create_post(title: str = Form(...), content: str = Form(...)):
    new_id = len(db) + 1
    new_post = Post(
        id=new_id,
        title=title,
        content=content
    )
    db.append(new_post)
    # Nach dem Posten zur Hauptseite zurückleiten, um einen Aktualisierungseffekt zu erzielen
    return RedirectResponse(url="/posts", status_code=303)

Wir verwenden die Funktion generate_html_response, um eine vollständige HTML-Seite dynamisch zu generieren, die das Formular und die Beitragsliste enthält. Obwohl primitiv, ist sie für diese Stufe absolut ausreichend.

GET /posts gibt direkt die generierte HTML-Seite zurück, sodass Benutzer die Forum-Oberfläche sehen können, wenn sie /posts besuchen. Zusätzlich wird der Root-Pfad / auf /posts umgeleitet, sodass Benutzer, die die Root-URL besuchen, automatisch zur Forum-Seite gelangen.

Sie bemerken möglicherweise, dass GET /api/posts entfernt wurde. Das liegt daran, dass wir keinen separaten API-Endpunkt mehr zum Abrufen der Beitragsliste benötigen; die Seite liest die Daten direkt aus der In-Memory-Datenbank db.

Wir haben auch die Logik für POST /api/posts geändert. Anstatt ein Post-Objekt zurückzugeben, leitet es nun zurück zur /posts-Seite, damit Benutzer die aktualisierte Beitragsliste unmittelbar nach der Übermittlung sehen können.

Das Forum ausführen

Stellen Sie nun sicher, dass Ihr Uvicorn-Server noch läuft. Aktualisieren oder besuchen Sie http://127.0.0.1:8000 und Sie sehen die Forum-Seite mit den vorhandenen Beiträgen und einem Formular zum Erstellen neuer Beiträge.

Nachdem Sie Inhalte in das Formular eingegeben und gesendet haben, sehen Sie Ihren neuen Beitrag in der Beitragsliste.

Den Projekt online bereitstellen

Ein Forum ist dazu gedacht, von allen genutzt zu werden, daher reicht es nicht aus, es nur lokal auszuführen. Als Nächstes können wir es online bereitstellen.

Eine einfache Bereitstellungsoption ist die Verwendung von Leapcell. Es ist eine Web-App-Hosting-Plattform, die Projekte in verschiedenen Sprachen und Frameworks hosten kann, einschließlich FastAPI, natürlich.

Befolgen Sie die nachstehenden Schritte:

1. Registrieren Sie ein Konto auf der Website.
2. Committen Sie Ihr Projekt auf GitHub. Sie können die offizielle Dokumentation von GitHub für die Schritte konsultieren. Leapcell wird den Code später aus Ihrem GitHub-Repository ziehen.
3. Klicken Sie auf der Leapcell-Seite auf „Create Service“.
4. Nachdem Sie Ihr FastAPI-Repo ausgewählt haben, sehen Sie, dass Leapcell die erforderlichen Konfigurationen automatisch ausgefüllt hat.
5. Klicken Sie unten auf „Submit“, um die Bereitstellung zu starten. Die Bereitstellung wird schnell abgeschlossen und Sie kehren zur Startseite der Bereitstellung zurück. Hier sehen wir, dass Leapcell eine Domain bereitgestellt hat. Dies ist die Online-Adresse Ihres Blogs.

Fazit

In nur wenigen kurzen Schritten haben wir einen Forum-Prototyp mit den wichtigsten Funktionen von Grund auf neu unter Verwendung von FastAPI erstellt.

Dieses Forum ist noch sehr unvollständig. Beispielsweise verschwinden alle neuen Beiträge, sobald der Server neu gestartet wird. Das ist offensichtlich inakzeptabel.

Im nächsten Artikel werden wir unserer Forum eine echte Datenbank vorstellen, um eine persistente Datenspeicherung zu ermöglichen.