Digitale Prozessoptimierung benötigt eine stabile Basis. Wenn wir interne Tools (wie Preiskalkulatoren, KI-Bots oder Bestands-Checker) entwickeln, müssen diese sicher, schnell und zuverlässig erreichbar sein.

In diesem Projekt habe ich eine Microservices-Infrastruktur aufgebaut, die als Fundament für solche Business-Anwendungen dient. Sie kombiniert die Geschwindigkeit von Python (FastAPI) mit der Sicherheit eines modernen Reverse Proxies (Caddy).

Warum diese Architektur?

Für E-Commerce-Unternehmen ist “Time-to-Market” entscheidend. Diese Architektur erlaubt es, neue kleine Tools (“Microservices”) extrem schnell bereitzustellen, ohne jedes Mal die komplette Server-Infrastruktur neu aufzusetzen.

• Security First: Automatische HTTPS-Verschlüsselung schützt interne Firmendaten.
• Scalability: Der Caddy-Server kann Anfragen auf mehrere interne Services verteilen (Load Balancing).
• Efficiency: FastAPI verarbeitet Anfragen asynchron, was ideal für I/O-lastige Aufgaben wie Datenbankabfragen oder KI-Integrationen ist.

Das Backend: Services im Detail

Als Backend-Framework kommt FastAPI zum Einsatz. Hier exemplarisch zwei Business-Funktionen:

1. /generate: Eine Text-Analyse-Pipeline (z.B. für automatisierte Produktbeschreibungen).
2. /ask-ai: Eine Schnittstelle zu Large Language Models (LLM) für den internen Support-Bot.

Hinweis: Der Produktionscode wird hier bewusst nicht veröffentlicht. Unten sehen Sie ein vereinfachtes Referenzbeispiel, das nur das Architekturprinzip erklärt.

Vereinfachtes Beispiel (example_api.py):

from fastapi import FastAPI
from pydantic import BaseModel, Field

app = FastAPI()


class TextPayload(BaseModel):
    text: str = Field(..., max_length=500)


class AssistantPayload(BaseModel):
    prompt: str = Field(..., max_length=2000)
    model: str = Field("example/free-model")


@app.post("/api/text-tools")
async def text_tools(payload: TextPayload):
    value = payload.text
    return {
        "uppercase": value.upper(),
        "length": len(value),
    }


@app.get("/api/models")
async def list_models():
    # In der Praxis werden freie Modelle aus einem Provider geladen.
    return {
        "models": [
            {"id": "provider/model-a:free", "name": "Model A Free"},
            {"id": "provider/model-b:free", "name": "Model B Free"},
        ]
    }


@app.post("/api/assistant")
async def assistant(payload: AssistantPayload):
    # In der Praxis: Validierung, Rate-Limit, Provider-Request, Error-Handling.
    return {"result": f"Erklaerung fuer Modell {payload.model}"}

Der Webserver: Caddy

Um die API unter der gleichen Domain wie das Frontend verfügbar zu machen, verwende ich Caddy. Wir nutzen handle_path, um das /api Präfix zu entfernen, bevor die Anfrage an FastAPI weitergeleitet wird.

Auszug aus der Caddy-Konfiguration:

handle_path /api/* {
    reverse_proxy 127.0.0.1:8000
}

Live-Demo: Text-Analyzer

Geben Sie einen Text ein, um ihn vom Python-Backend analysieren zu lassen. (Stellen Sie sicher, dass das aktualisierte Skript lokal läuft).

Erweiterung: KI Code-Erklärer

Dieses zweite Beispiel nutzt den neuen /ask-ai Endpunkt. Geben Sie einen Code-Schnipsel ein, und das Backend leitet ihn sicher an ein LLM (via OpenRouter) weiter.

Der System-Prompt: Ein großer Vorteil dieser Architektur ist, dass wir dem Modell eine feste Rolle zuweisen können, die der Nutzer nicht ändern kann. Im Python-Backend wird jeder Anfrage dieser System-Prompt vorangestellt:

“Du bist ein Code-Erklärer. Erkläre den Code kurz, prägnant und auf Deutsch.”

Das garantiert, dass die KI immer hilfreich und fokussiert antwortet, egal was der Nutzer eingibt. Ihr API-Key bleibt dabei sicher auf dem Server.