Wie stellt man eine FastAPI-Anwendung bereit?

Es gibt zwar viele Hosting-Anbieter, aber nur wenige bieten ein Common Gateway Interface (CGI) oder das Modul mod_wsgi zur Unterstützung von Python-Hosting an. Unter den Entwicklern, die an der Stack Overflow-Entwicklerumfrage 2023 teilgenommen haben, steht die Containerisierung mit Docker bei der Anwendungsentwicklung und -bereitstellung jedoch an erster Stelle.

Für Python-Anwendungen, die mit einem Framework wie FastAPI entwickelt wurden, ist das Deployment über einen Container-as-a-Service (CaaS) so einfach wie das Hochladen des Codes auf GitHub. In diesem Blog erfahren Sie, wie Sie Ihre FastAPI-Anwendung dockerisieren und über einen CaaS bereitstellen.

Wichtigste Informationen

• Docker und FastAPI sind ein starkes Duo; sie ermöglichen optimierte, paketierte Bereitstellungen mit integrierten Abhängigkeiten.

• FastAPI zeichnet sich durch asynchrone Abläufe, Datenvalidierung und OpenAPI aus, hat aber Defizite bei der Unterstützung durch die Community und der Kompatibilität.

• Back4app erleichtert die FastAPI-Bereitstellung, synchronisiert mit GitHub für automatische Updates und bietet die Einrichtung von Cloud-Datenbanken.

Was ist FastAPI?

FastAPI ist ein leichtgewichtiges Open-Source-Python-Web-Framework für die Entwicklung von RESTful-APIs.

Es wurde 2018 auf den Markt gebracht und unterstützt das Pydantic-Modell und Starlette, was es auf die gleiche Leistungsstufe wie Node.js und Golang stellt. Das Framework ist außerdem anpassbar und ermöglicht es Ihnen, Ihre Codebasis flexibel zu gestalten.

Durch die Unterstützung von JSON Schema und Type-Hinting in Python ab Version 3.6 ermöglicht das Pydantic-Modell FastAPI das einfache Parsen von Daten und deren Validierung zur Laufzeit.

Das Starlette-Framework führt das Asynchronous Server Gateway Interface (ASGI) in FastAPI ein; damit können Sie asynchrone Operationen in Python RESTful APIs durchführen und Ihren Code auf dem Uvicorn ASGI-Server ausführen.

Wie Nodemon in Node.js lauscht der Uvicorn-Server auf Änderungen in den API-Routen und initiiert die Laufzeit für jede Aktualisierung neu.

Obwohl nur 7,42 % der Entwickler, die an der Stack Overflow-Entwicklerumfrage 2023 teilgenommen haben, angaben, dass sie FastAPI verwenden, beziffert GitHub die Gesamtzahl der Nutzer zum Zeitpunkt der Erstellung dieses Artikels auf 203.000.

Mit über 498 Mitwirkenden und 190 Veröffentlichungen zum Zeitpunkt der Erstellung dieses Artikels erhält FastAPI regelmäßig Updates und Patches.

Die Frage, ob FastAPI mit Golang und Node.js mithalten kann, ist unter Entwicklern noch immer umstritten.

Während andere zustimmen, behaupten einige, dass FastAPI zwar eine deutliche Verbesserung für die Webentwicklung mit Python darstellt, aber immer noch nicht mit der Leistung von Golang und Node.js mithalten kann.

Vorteile von FastAPI

• Unterstützung für asynchrone Operationen: Neben den standardmäßigen synchronen Operationen von Python unterstützt FastAPI auch Funktionsdeklarationen mit async/await. Dank Starlette, das auch WebSocket-Unterstützung bietet. Dadurch wird die Gleichzeitigkeit Ihres Programms erhöht, so dass Ihre Anwendung andere Operationen ausführen kann, während sie auf langsamere Operationen wie Datenbankabfragen wartet.

• Unterstützung für die Datenvalidierung: Unter Verwendung des Pydantic BaseModel nutzt FastAPI die Datentyp-Hinweise von Python, um beim Parsen von Daten Strenge zu wahren. Dadurch wird verhindert, dass der falsche Datentyp in die Datenbank gelangt. Im Gegensatz zu dynamischen Modellen, die zusätzliche Validierungsbibliotheken erfordern, ist die Modellvalidierung in FastAPI daher einfach und schnell verfügbar.

• Vollständig standardisiert: FastAPI entspricht der OpenAPI-Spezifikation für die Bereitstellung von HTTP-APIs im Web, so dass Verbraucheranwendungen und Clients eine API, die sie verwenden möchten, leicht verstehen können. Unter der Haube wird außerdem die JSON-Schema-Deklaration verwendet, um sicherzustellen, dass die vom Benutzer übermittelten Test- und Live-Daten gültig sind, bevor sie an die Datenbank übermittelt werden.

• Flexibilität: Im Gegensatz zu Django ist der Entwickler bei FastAPI nicht auf einen bestimmten Codebase-Architekturstandard festgelegt. Stattdessen überlässt es diese Entscheidung dem Entwickler. Daher können Sie Ihre Codebasis mit flexiblen Namenskonventionen gestalten und allgemeine App-Einstellungen und Unit-Test-Suites von unterwegs aus deklarieren. Auch die Modularisierung des Codes und die Separation of Concern (SOC) sind einfach zu handhaben. Und wenn Sie objektorientiert programmieren (OOP), was wir empfehlen, können Sie Ihre Modelle ganz einfach in Ihre Endpunktklassen einbauen. Das Hinzufügen von API-Endpunkten zu Ihren Routen ist ebenfalls sehr einfach.

• Es hat eine kurze Lernkurve: Obwohl die Benutzergemeinschaft kleiner ist als bei Frameworks wie Flask und Django, zeichnet sich FastAPI durch seine umfassende Dokumentation und seine Tutorials aus. Mit einem Entwicklungshintergrund, insbesondere in Python oder JavaScript, können Sie es leicht erlernen. Seine allgemeine Einfachheit und Flexibilität tragen zu schnelleren Entwicklungsprozessen bei.

Nachteile

• Geringe Unterstützung durch die Community: FastAPI hat nicht so viele Nutzer wie Django oder Flask. Es ist noch relativ neu. Daher ist die Unterstützung durch die Community geringer, was insbesondere für neue Entwickler eine Herausforderung darstellen kann.

• Begrenzte Versionskompatibilität: FastAPI unterstützt nur neuere Versionen von Python, beginnend mit Python 3.6 aufwärts. Daher müssen Rechner oder Server, auf denen Python-Versionen vor 3.6 laufen, ein Upgrade durchführen, um FastAPI erfolgreich installieren und ausführen zu können.

FastAPI-Bereitstellungsoptionen

Infrastructure-as-a-Service (IaaS) und Container-as-a-Service (CaaS) sind skalierbare Cloud-Infrastrukturen für die Bereitstellung von Anwendungen.

Sie können eine FastAPI-Anwendung zwar über einen Virtual Private Server (VPS) oder Shared Hosting bereitstellen, aber keine dieser Optionen ist so skalierbar wie IaaS oder CaaS.

IaaS

Ein IaaS ist eine Plattform, die On-Demand-Computing-Ressourcen in der Cloud bereitstellt.

Sie liefert alle virtualisierten Ressourcen, die für die Einrichtung eines Deployment-Servers für Ihre Anwendung erforderlich sind, in der Regel auf einer Pay-as-you-go-Basis.

Neben der Recheninfrastruktur umfasst ein IaaS auch Speicher und andere Netzwerkressourcen wie Load Balancer, VPNs, Firewalls, DNS-Verwaltung und mehr.

Sie sind für die Verwaltung Ihrer Datenverarbeitungsumgebung verantwortlich und können die Ressourcen an die Anforderungen Ihrer Anwendung anpassen oder skalieren.

CaaS

Ein CaaS ist ein Platform-as-a-Service (PaaS), mit dem Sie Ihre Anwendung in der Cloud als Container bereitstellen können.

Im Gegensatz zu einem IaaS verwaltet ein CaaS alle Berechnungsgrundlagen, die für das Hosting Ihrer Anwendung erforderlich sind, unter einer Haube.

Dazu gehören die Container-Laufzeitumgebung, die Orchestrierung, die Speicherung, der Lastausgleich und vieles mehr.

So können Sie sich auf die Entwicklung Ihrer Anwendung konzentrieren, ohne sich um die Verwaltung der Infrastruktur kümmern zu müssen.

Da Sie Ihre Anwendung als Container bereitstellen, ist die CI/CD-Integration einfach, ohne sich um technische Konfigurationen kümmern zu müssen. Dies ermöglicht eine schnellere Veröffentlichung und Aktualisierung der Anwendung.

FAST API-Bereitstellungsprozess

Lassen Sie uns den Bereitstellungsprozess Schritt für Schritt durchgehen, beginnend mit den Voraussetzungen.

Da wir unsere FastAPI-Anwendung mithilfe von Back4App-Containern bereitstellen werden, sollten wir uns zunächst einen Überblick über die Voraussetzungen verschaffen, bevor wir fortfahren.

Überblick über Back4App Containers

Back4App Containers ist eine Cloud-Plattform, die es Ihnen ermöglicht, dockerisierte Anwendungen schnell in der Cloud bereitzustellen.

Die Plattform synchronisiert sich mit Ihrem GitHub-Repository und aktualisiert Ihre Bereitstellung automatisch, sobald Sie eine neue Version veröffentlichen. Auf diese Weise lassen sich manuelle Container-Updates und Server-Ausfallzeiten vermeiden.

Mit Back4App Containers müssen Sie lediglich Ihren Code und nachfolgende Releases von Ihrem lokalen Rechner aus auf GitHub pushen, während die Plattform die Orchestrierung der Container-Images übernimmt.

Back4App bietet außerdem eine Echtzeit-Verfolgung des Deployments und Echtzeit-Protokollierung.

So können Sie die Bereitstellungsschritte nachverfolgen und den Fehlerpunkt bestimmen – falls es einen gibt.

Und wenn Ihre Anwendung während der Laufzeit abstürzt, was bei einer interpretierten Sprache wie Python vorkommen kann, hilft Ihnen die Echtzeit-Protokollierung, Fehler in der Konsole zu verfolgen und schnell zu beheben.

Hier sind die wichtigsten Funktionen von Back4App:

• Synchronisieren Sie Ihre Back4App-Anwendung ganz einfach mit Ihrem Codebase-Repository auf GitHub.

• Stellen Sie Ihre Anwendung über einen Back4App-Container in der Cloud bereit, indem Sie Ihren Code und nachfolgende Updates in Ihr GitHub-Repository pushen.

• Alles was Sie brauchen ist ein Dockerfile. Back4App übernimmt die Installation aller Abhängigkeiten für Sie.

• Verschlüsseln Sie Ihre Umgebungsvariablen während des Deployments und nachfolgender Releases ganz einfach.

• Überwachen Sie Deployments in Echtzeit und verwalten Sie Rollbacks.

• Überwachen Sie die Nutzungshistorie Ihrer Anwendung mit Echtzeitprotokollen.

• Deployment von mobilen und Web-Anwendungen in der Cloud

Python herunterladen und installieren

Wir werden in diesem Blog Python 3.10.6 verwenden. Sie können aber jede Python-Version verwenden, die nicht älter als 3.6 ist.

Gehen Sie zu python.org, um die neueste kompatible Python-Version für Ihr Betriebssystem herunterzuladen und zu installieren – falls Sie das nicht bereits getan haben. Andernfalls können Sie diesen Abschnitt ignorieren.

Klicken Sie nach dem Download auf die Installationsdatei und folgen Sie den Anweisungen auf dem Bildschirm, um Python auf Ihrem lokalen Rechner zu installieren.

Stellen Sie sicher, dass Sie die Option python.exe zu PATH hinzufügen ankreuzen, um Python zu Ihrem Systemvariablenpfad hinzuzufügen; dadurch wird es über die Befehlszeile ausführbar.

Wenn Sie einen Mac verwenden, wird dieser bereits standardmäßig mit Python 2.7 ausgeliefert. Sie können diese mit Homebrew über das Terminal auf die neueste Version aktualisieren:

brew install python3

Führen Sie den folgenden Befehl in Ihrem Terminal aus, um Ihre Python-Version zu überprüfen.

python --version

Aktivieren Sie eine virtuelle Python-Umgebung und installieren Sie FastAPI

Erstellen Sie als nächstes ein neues Projektverzeichnis und öffnen Sie die Kommandozeile zu diesem Ordner. Aktivieren Sie dann eine virtuelle Python-Umgebung mit venv.

Dieses Paket wird mit Python ausgeliefert und muss nicht installiert werden. Es ermöglicht Ihnen, Python-Abhängigkeiten isoliert zu verwalten, anstatt sie global zu installieren.

Führen Sie den folgenden Befehl im Terminal aus, um eine virtuelle Umgebung zu erstellen. Ersetzen Sie dabei env_name durch den Namen Ihrer bevorzugten Umgebung.

py -m venv env_name

Führen Sie den folgenden Befehl aus, um die virtuelle Umgebung zu aktivieren.

.\env_name\Scripts\activate

FastAPI und Uvicorn installieren

Der nächste Schritt ist die Installation des FastAPI-Frameworks und der Uvicorn-Server-Laufzeitumgebung in der aktiven virtuellen Umgebung. Dabei werden auch Pydantic und Starlette installiert.

Erstellen Sie eine Datei requirements.txt im Stammverzeichnis Ihres Projekts und geben Sie die zu installierenden Pakete ein, wie unten gezeigt.

fastapi
uvicorn

Unten sehen Sie die Demonstration in VSCode. Sie können weitere Abhängigkeiten an diese Datei anhängen, wenn es nötig ist.

Führen Sie den folgenden Befehl über das Terminal aus, um die aufgeführten Abhängigkeiten zu installieren. Stellen Sie sicher, dass die virtuelle Umgebung noch aktiv ist.

pip install install -r requirements.txt

Der Befehl installiert das angegebene Paket wie unten gezeigt.

Nach der Installation aktualisieren Sie die Datei requirements.txt mit dem folgenden Befehl:

pip freeze > requirements.txt

Der obige Befehl überschreibt die Datei requirements.txt mit den installierten Abhängigkeiten, einschließlich ihrer korrekten Versionsnummern.

Stellen Sie sicher, dass Sie dies jedes Mal tun, wenn Sie eine neue Abhängigkeit in Ihrer virtuellen Umgebung installieren.

Die Datei requirements.txt sieht nach der Aktualisierung wie folgt aus:

Projekt-Einführung

Wir werden eine einfache „Hello World“-FastAPI-Anwendung schreiben und sie mit den kostenlosen Back4App-Containern bereitstellen.

Machen Sie sich keine Sorgen, wenn Ihr Projekt komplexer ist. Das Deployment erfolgt im selben Schritt, und Sie erhalten außerdem kostenlose monatliche Betriebszeit.

Wenn Ihre Anwendung jedoch täglich viele Anfragen bearbeitet, sollten Sie nach der Bereitstellung ein Upgrade durchführen, um Ihren Besuchern ein reibungsloses Benutzererlebnis ohne Ausfallzeiten zu bieten.

App Code

Legen Sie in Ihrem Projekt-Stammverzeichnis ein neues Router-Verzeichnis an und erstellen Sie in diesem Verzeichnis eine Datei main.py.

Diese Datei verwaltet die API-Endpunkte Ihrer Anwendung und den Router. Überspringen Sie den folgenden Abschnitt, wenn Sie bereits ein Projekt zum Einsatz haben.

Hier ist der „Hello World“-Code:

from fastapi import FastAPI, APIRouter
import uvicorn

app = FastAPI()
class HelloWorld():
    def read_hello(self):
        return {"data": "Hello World"}
router = APIRouter()
router.add_api_route('/api/v2/hello-world', 
endpoint = HelloWorld().read_hello, methods=["GET"])
app.include_router(router)

if __name__ == "__main__":
   uvicorn.run("main:app", host="127.0.0.1", port=8000, reload=True)

Um den uvicorn-Server zu starten und den hello-world-API-Endpunkt zu testen, führen Sie die Datei main.py über die Befehlszeile aus:

python main.py

Dies startet den Entwicklungsserver auf Port 8000 wie angegeben.

Da es sich um eine GET-Anfrage handelt, können wir sie direkt in einem beliebigen Webbrowser testen. Unten sehen Sie das Ergebnis.

Dockerisierung der App

Als nächstes erstellen Sie eine Dockerdatei in Ihrem Projektstammordner. Dazu erstellen Sie eine neue Datei in VS Code und benennen sie Dockerfile.

Nach der Erstellung geben Sie die folgenden Befehle ein, um ein Docker-Image zu erstellen:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["uvicorn", "router.main:app", "--host", "0.0.0.0", "--port", "8000"]

Auf GitHub pushen

Wechseln Sie zu Ihrem GitHub-Konto und gehen Sie zu Repositories. Starten Sie ein neues Repository, indem Sie oben rechts auf Neu klicken.

Wechseln Sie zu Ihrem GitHub-Konto und gehen Sie zu Repositories. Starten Sie ein neues Repository, indem Sie oben rechts auf Neu klicken.

Wenn Sie Ihren Code bereits auf GitHub gepusht haben, fügen Sie die Dockerdatei zu der Kopie auf Ihrem lokalen Rechner hinzu und pushen Sie sie erneut in Ihr Repository.

Geben Sie Ihrem Repository einen Namen und klicken Sie unten rechts auf Repository erstellen.

Als Nächstes initialisieren Sie ein lokales Repository mit dem init-Befehl wie gezeigt:

git init

Ignorieren Sie den venv-Ordner und Ihre .env-Datei mit .gitignore, um zu vermeiden, dass sie in Ihr Repository übertragen werden.

Erstellen Sie dazu eine .gitignore-Datei in Ihrem Projektstammordner und geben Sie die Ordner und Dateien ein, die Sie ignorieren möchten, wie unten gezeigt.

Führen Sie die folgenden Befehle nacheinander über Ihr Terminal aus, um Ihren Code in Ihr Repository zu übertragen.

1. git add .
2. git commit -m "commit message"
3. git branch -m main
4. git remote add origin <URL of the created repository>
5. git push -u origin main

Bereitstellen der App mit einem Back4App-Container

Falls noch nicht geschehen, müssen Sie ein neues Back4App-Konto erstellen. Um den Vorgang zu beschleunigen, verwenden Sie die Anmeldemöglichkeit bei Google oder GitHub.

Sobald Sie angemeldet sind, klicken Sie auf das Widget Build new app.

Gehen Sie zu Container als Service.

Klicken Sie auf der folgenden Seite auf GitHub Repo importieren. Erteilen Sie GitHub die Erlaubnis, Back4App zu autorisieren, wenn Sie dazu aufgefordert werden.

Klicken Sie im geöffneten Modal unter Repository-Zugriff auf Repositories auswählen. Wählen Sie das Repository aus, das das Projekt enthält, das Sie bereitstellen möchten, und klicken Sie auf Save.

Back4App wird das ausgewählte Repository automatisch synchronisieren. Sobald Sie zu Back4App weitergeleitet werden, klicken Sie rechts neben dem hinzugefügten GitHub-Repository auf Auswählen.

Füllen Sie als nächstes das Feld App-Name mit Ihrem bevorzugten App-Namen aus.

Wenn Ihre FastAPI-Anwendung Geheimnisse innerhalb einer .env-Datei maskiert hat, klicken Sie auf Umgebungsvariablen, um Ihre Umgebungsvariablen einzugeben. Klicken Sie auf Variable hinzufügen und geben Sie Ihren Variablennamen in Großbuchstaben ein.

Stellen Sie sicher, dass Sie dieselbe Namenskonvention wie die Variablen in der .env-Datei Ihres Projekts verwenden, um Namensfehler zu vermeiden.

In diesem Schritt werden Ihre Variablenwerte verschlüsselt und zu Ihrer Bereitstellung hinzugefügt. Klicken Sie abschließend auf App erstellen, um Ihre FastAPI-Anwendung bereitzustellen.

Die Bereitstellungsinstanz für die FastAPI-Anwendung wird wie unten dargestellt ausgeführt.

Um die Live-Version Ihrer Anwendung anzuzeigen, klicken Sie auf die URL in der linken Seitenleiste. Wenn Sie in diesem Fall https://testapp-omisolaidowu.b4a.run/api/v2/hello-world aufrufen, erhalten Sie die erwartete Antwort.

Zusammenfassung

Es ist einfach, eine Anwendung mit der FastAPI von Python zu entwickeln. Aber, sie nahtlos für die Kunden bereitzustellen, ist eine andere Sache.

CaaS hilft nicht nur bei der schnelleren Bereitstellung, sondern ist auch weniger technisch. Sie haben zwar gesehen, wie man eine FastAPI-Anwendung bereitstellt, aber das ist noch nicht alles.

Vielleicht möchten Sie die clientseitige Anwendung auf einer separaten Container-Instanz bereitstellen und sich mit den FastAPI-Endpunkten verbinden, indem Sie die generierte URL als Basis-URL verwenden.

Wenn Ihnen dieser Artikel gefallen hat, lesen Sie bitte unser Tutorial über die Bereitstellung einer Flask-Anwendung.