Mit dem auf Python basierenden Framework FastAPI setzen Sie im Handumdrehen eine maßgeschneiderte REST-Schnittstelle für Webanwendungen auf.

Die Abkürzung API steht für den englischen Begriff Application Programming Interface. Dabei handelt es sich um Schnittstellen, die eine Applikation bereitstellt. Über diese Schnittstellen können Entwickler auf Funktionen der Anwendung zugreifen. Grundsätzlich unterscheidet man dabei zwischen internen und externen APIs.

Interne APIs dienen dazu, den Quellcode innerhalb einer Anwendung zu organisieren. Externe APIs ermöglichen den Zugriff auf eine Anwendung von außen. Auf diesem Weg lassen sich fertige Funktionen anderer Anwendungen leicht in eigene Programme integrieren. Einer der Hauptaspekte, die beim Einsatz von APIs im Vordergrund steht, ist das Kapseln von Komplexität: Die Schnittstelle versteckt komplexe Abläufe hinter einfachen Aufrufen.

Die Kommunikation von Web-APIs erfolgt über sogenannte Endpunkte, die man über URLs anspricht. Als Protokoll kommt dabei REST zum Einsatz. Dabei sind die Request-Typen GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS, CONNECT und TRACE möglich. In den meisten Fällen arbeitet man aber nur mit GET und POST. Die Datenübermittlung erfolgt im JSON-Format. Nähere Informationen zu JSON finden Sie bei Interesse im Internet [1].

Eines der Hauptmerkmale von REST ist die Zustandslosigkeit. Das bedeutet, dass die Dienste keinerlei Zustandsdaten der Aufrufer vorhalten. Es besteht also keine dauerhafte Verbindung.

FastAPI

Mit dem auf Python basierenden Framework FastAPI kann man sehr schnell und einfach APIs erstellen. Der Name ist Programm: Tatsächlich liegt die Ausführungsgeschwindigkeit des mit FastAPI erstellten Codes recht hoch.

Ein weiteres interessantes Feature von FastAPI ist die automatische Dokumentation der definierten Schnittstellen. Während der API-Server läuft, erreicht man die Dokumentation unter der URL http://<I>API-Server<I>:8000/docs. Die Dokumentation wird mit einer Swagger-UI [2] erzeugt. Damit erhält man nicht nur eine aktuelle Dokumentation der APIs, sondern kann diese auch direkt testen. Wir sehen uns das im Laufe des Artikels noch einmal an einem konkreten Beispiel an. Falls Sie noch weitergehende Fragen zu FastAPI haben, besuchen Sie bitte die Homepage des Projekts [3].

Bevor wir im nächsten Abschnitt mit der Installation von FastAPI beginnen, sollten wir noch klären, wie man die API bereitstellt. Damit das Framework arbeiten kann, benötigt es einen Container, in dem die Programme laufen. Hier ist der Uvicorn-Webserver das Mittel der Wahl, eine Implementierung eines ASGI-Webservers in Python. Das Kürzel ASGI steht für Asynchronous Server Gateway Interface, eine Standardschnittstelle zwischen Webservern, Frameworks und Anwendungen. Weitere Details zu Uvicorn erfahren Sie auf der Webseite des Projekts [4].

Installation von FastAPI

Im folgenden Beispiel installieren wir FastAPI unter Ubuntu. Die Installationsschritte funktionieren aber auch auf jedem beliebigen anderen Linux in der gleichen Art und Weise. Es kann allerdings vorkommen, dass Sie noch einige zusätzliche Pakete aufspielen müssen. Das hängt vom verwendeten System ab.

Um die FastAPI-Installation sauber vom Rest des Systems zu trennen, setzen wir zusätzlich mit dem Tool Venv ein virtuelles Python-Environment auf. Bitte beachten Sie dabei, dass Sie jedes Mal das source-Kommando absetzen müssen, bevor Sie mit dem Environment arbeiten können. Diesen Preis gilt es zu zahlen, wenn man eine Trennung der Umgebungen möchte. Die Kommandos zur Installation der virtuellen Umgebung für FastAPI fasst Listing 1 zusammen.

$ sudo apt update
$ sudo apt upgrade
$ mkdir fastAPI
$ cd fastAPI
$ python -m venv fastAPIenv
$ source fastAPIenv/bin/activate
$ wget https://bootstrap.pypa.io/get-pip.py
$ python get-pip.py
$ python -m pip install fastapi
$ pip install uvicorn

Erste API

An dieser Stelle folgt üblicherweise das klassische Beispielprogramm “Hello World”. Wir präsentieren es hier in einer leicht abgewandelten hessischen Form. Wie Sie in Listing 2 sehen, lässt sich eine API superleicht erstellen. Wir importieren zunächst das FastAPI-Framework (Zeile 1), erzeugen dann ein Applikationsobjekt (Zeile 2) und binden zum Schluss einen Endpunkt an die Applikation (Zeile 3). In unserem Beispiel ist das /. Zu dem Endpunkt hinterlegen wir eine Methode, die den Rückgabewert als JSON erzeugt (Zeile 4 und 5).

### main.py
from fastapi import FastAPI
application = FastAPI()
@application.get("/")
async def root():
  return {"message": "Ei Gude, wie?"}

Zum Start der API verwenden wir das Kommando uvicorn main:application. Das bedeutet übersetzt so viel wie: Hallo Uvicorn-Server, starte aus der Datei main.py den Teil mit dem Namen application. Wie Abbildung 1 zeigt, erledigt Uvicorn das auch anstandslos und gibt im Browser den erwarteten Text aus. Die URL für den Browser lautet http://localhost:8000.

Abbildung 1: Die Anzeige im Webbrowser mit den dazu passenden Ausgaben des Uvicorn-Servers.

Aufwendigere API

Wir wissen nun, wie man mit FastAPI eine einfache Schnittstelle aufbauen kann. Jetzt steigen wir ein wenig tiefer in das Thema ein. Die nächste API (Listing 3) stellt uns eine einfache Möglichkeit zum Speichern einer Einkaufsliste bereit.

### main.py
from fastapi import FastAPI
application = FastAPI()
Einkauf_Liste = []
@application.get("/Einkauf_Liste")
async def get_Einkauf_Liste():
  return Einkauf_Liste
@application.post("/Einkauf_Liste")
async def add_Einkauf_Liste(Artikel):
  Einkauf_Liste.append(Artikel)
  return "ok"

Der GET-Endpunkt @application.get("/Einkauf_Liste") gibt die vollständige Einkaufsliste zurück. Mit dem POST-Endpunkt @application.post("/Einkauf_Liste") können wir einen Artikel in die Liste einfügen. Beim derzeitigen Aufbau des Beispiels gehen die Einträge in der Liste noch verloren, sobald wir den Server neu starten. Daher verwenden wir hier beim Start des Servers den Parameter --reload (uvicorn main:application --reload). Das macht es überflüssig, den Server bei jeder Codeänderung neu zu starten.

Um zu testen, ob unsere API wie gewünscht funktioniert, verwenden wir das vorhandene Swagger-Frontend. Es ist unter der URL http://localhost:8000/docs zu erreichen. Wir wählen einfach den Endpunkt, den wir testen wollen, klicken auf Try it out und danach auf Execute. Wie Sie im unteren Teil von Abbildung 2 sehen, stehen auch bereits einige Artikel auf unserer Einkaufsliste.

Abbildung 2: Test der API zur Ausgabe der Einkaufsliste (Endpunkt GET).

Um einen weiteren Artikel hinzuzufügen, verwenden wir den zweiten Endpunkt und klicken wieder auf Try it out. Jetzt müssen wir allerdings den zusätzlichen Artikel, der auf die Liste soll, in ein Textfeld eingeben (Abbildung 3). Nach einem Klick auf Execute stehen auch die Bananen auf unserer Einkaufsliste.

Abbildung 3: Artikel lassen sich über die API mit in die Liste aufnehmen.

Anknüpfungspunkte

Unsere zwei Beispiele waren extrem einfach aufgebaut, zeigen aber gut, wie schnell man mit FastAPI eine laufende Anwendung erstellen kann. Selbst wenn die Anwendungsfälle komplexer werden, bleiben die resultierenden Programme klein und übersichtlich.

Wenn Sie sich intensiver in das Thema einarbeiten möchten, bietet sich die Homepage des FastAPI-Projekts als guter Anlaufpunkt an. Unter dem Punkt Tutorials [5] finden sich dort viele Schritt-für-Schritt-Anleitungen für den weiteren Einstieg. Dort ist zum Beispiel beschrieben, wie man die Daten aus den APIs in einer Datenbank speichern oder mit Pfadparametern arbeiten kann.

Darüber hinaus findet sich auf der Homepage neben zusätzlichen Informationen und Anregungen eine vollständige Dokumentation aller FastAPI-Funktionen. Für die Freunde des bewegten Bilds gibt es außerdem bei Youtube eine Menge guter Videos zum Thema. Kurz gesagt, es ist alles vorhanden, was Sie für einen schnellen Einstieg in das Framework benötigen.

Uvicorn-Einstellungen

Wir haben für unsere Beispiele den Uvicorn-Webserver verwendet. Von daher ist es sinnvoll, sich einige Parameter des Servers noch einmal genauer anzusehen. Bislang lief der Uvicorn-Server nur auf dem Localhost-Interface, man konnte also auch nur von Localhost aus auf die APIs zugreifen. Das reicht für die Entwicklung und die ersten Versuche völlig aus. Um die API aber von außen anzusprechen, müssen wir die Konfiguration des Servers anpassen.

Der Parameter --host ermöglicht es, den Server auf unterschiedlichen Interfaces anzusprechen. Darüber definieren Sie, auf welchen Schnittstellen der Server Anfragen annimmt. Um die Sache einfach zu halten, verwenden wir hier die IP-Adresse 0.0.0.0, was bedeutet, dass wir die API an alle verfügbaren Interfaces des Servers binden. Über den Parameter --port verändern Sie darüber hinaus bei Bedarf den Port, auf den die APIs zugreifen. In der Vorgabe erwartet der Server Anfragen auf dem Port 8000.

Während der Entwicklung ist der bereits erwähnte Parameter --reload extrem nützlich. Sobald Sie ihn setzen, überwacht Uvicorn die Dateien im Filesystem und lädt sie neu, sobald er eine Änderung feststellt. Ohne diese Option müssen Sie den Server nach jeder Änderung manuell neu starten. Da jeder zusätzlich gesetzte Parameter das Startkommando für den Server unübersichtlicher macht, gibt es die Möglichkeit, Uvicorn auch über Umgebungsvariablen zu parametrisieren. Deren Namen müssen komplett aus Großbuchstaben bestehen und mit UVICORN_ beginnen. Um zum Beispiel den Port zu verändern, setzen Sie die Umgebungsvariable UVICORN_PORT auf den gewünschten Wert.

Wir konnten hier aus Platzgründen nur auf die wichtigsten Parameter des Uvicorn-Servers eingehen. Eine komplette Übersicht aller Einstellungen finden Sie auf der Projekt-Homepage [6].

Fazit

Zwar ist der Autor eigentlich kein Freund von Python, muss aber zugeben, dass das FastAPI-Framework wirklich Spaß macht. Es ist schon beeindruckend, wie schnell und mühelos man eine API aufsetzen kann. Auch komplexere Verfahren lassen sich mit FastAPI leicht meistern.

Allerdings hatten wir hier nicht den Raum, tiefer in die Materie einzusteigen. Zumindest haben Sie aber alle für den Einstieg nötigen Informationsquellen und Werkzeuge kennengelernt. Der Autor wünscht Ihnen viel Spaß mit FastAPI. (jlu)