Erstellen Sie eine App mit FastAPI für Python

FastAPI ist ein schnelles und leichtes Web-Framework zum Erstellen moderner Anwendungsprogrammierschnittstellen mit Python 3.6 und höher. In diesem Tutorial gehen wir durch die Grundlagen des Erstellens einer App mit FastAPI, und Sie erhalten eine Ahnung, warum es als eines der besten Open-Source-Frameworks des Jahres 2021 nominiert wurde.

Sobald Sie bereit sind, Ihre eigenen FastAPI-Apps zu entwickeln, müssen Sie nicht lange suchen, um einen Ort zu finden, an dem sie gehostet werden können. Kinstas Anwendungs-Hosting- und Datenbank-Hosting-Dienste bieten eine Platform as a Service, die auf Python stark ist.

Lassen Sie uns zuerst die Grundlagen lernen.

Vorteile von FastAPI

Nachfolgend sind einige der Vorteile aufgeführt, die das FastAPI-Framework einem Projekt bringt.

• Geschwindigkeit: Wie der Name schon sagt, ist FastAPI ein sehr schnelles Framework. Seine Geschwindigkeit ist vergleichbar mit der von Go und Node.js, die allgemein als eine der schnellsten Optionen zum Erstellen von APIs gelten.
• Einfach zu erlernen und zu codieren: FastAPI hat bereits fast alles herausgefunden, was Sie benötigen, um eine produktionsreife API zu erstellen. Als Entwickler, der FastAPI verwendet, müssen Sie nicht alles von Grund auf neu programmieren. Mit nur wenigen Codezeilen haben Sie eine einsatzbereite RESTful-API.
• Umfassende Dokumentation: FastAPI verwendet die OpenAPI-Dokumentationsstandards, sodass die Dokumentation dynamisch generiert werden kann. Diese Dokumentation enthält detaillierte Informationen zu den Endpunkten, Antworten, Parametern und Rückgabecodes von FastAPI.
• APIs mit weniger Fehlern: FastAPI unterstützt die benutzerdefinierte Datenvalidierung, die es Entwicklern ermöglicht, APIs mit weniger Fehlern zu erstellen. Die Entwickler von FastAPI rühmen sich damit, dass das Framework zu weniger vom Menschen verursachten Fehlern führt – bis zu 40 % weniger.
• Type Hints: Das Types-Modul wurde in Python 3.5 eingeführt. Damit können Sie den type einer Variablen deklarieren. Wenn der Typ einer Variablen deklariert wird, können IDEs eine bessere Unterstützung bieten und Fehler genauer vorhersagen.

Erste Schritte mit FastAPI

Um diesem Tutorial zu folgen und mit FastAPI zu beginnen, müssen Sie zuerst ein paar Dinge tun.

Stellen Sie sicher, dass Sie über einen Texteditor/eine IDE für Programmierer wie Visual Studio Code verfügen. Weitere Optionen sind Sublime Text und Espresso.

Es ist üblich, dass Ihre Python-Apps und ihre Instanzen in virtuellen Umgebungen ausgeführt werden. Virtuelle Umgebungen ermöglichen die gleichzeitige Ausführung verschiedener Paketsätze und Konfigurationen und vermeiden Konflikte aufgrund inkompatibler Paketversionen.

Um eine virtuelle Umgebung zu erstellen, öffnen Sie Ihr Terminal und führen Sie diesen Befehl aus:

 $ python3 -m venv env

Sie müssen auch die virtuelle Umgebung aktivieren. Der Befehl dafür variiert je nach verwendetem Betriebssystem und verwendeter Shell. Hier sind einige CLI-Aktivierungsbeispiele für eine Reihe von Umgebungen:

 # On Unix or MacOS (bash shell): /path/to/venv/bin/activate # On Unix or MacOS (csh shell): /path/to/venv/bin/activate.csh # On Unix or MacOS (fish shell): /path/to/venv/bin/activate.fish # On Windows (command prompt): \path\to\venv\Scripts\activate.bat # On Windows (PowerShell): \path\to\venv\Scripts\Activate.ps1

(Einige Python-fähige IDEs können auch so konfiguriert werden, dass sie die aktuelle virtuelle Umgebung aktivieren.)

Installieren Sie jetzt FastAPI:

 $ pip3 install fastapi

FastAPI ist ein Framework zum Erstellen von APIs, aber zum Testen Ihrer APIs benötigen Sie einen lokalen Webserver. Uvicorn ist ein blitzschneller ASGI-Webserver (Asynchronous Server Gateway Interface) für Python, der sich hervorragend für die Entwicklung eignet. Um Uvicorn zu installieren, führen Sie diesen Befehl aus:

 $ pip3 install "uvicorn[standard]"

Erstellen Sie nach erfolgreicher Installation eine Datei namens main.py im Arbeitsverzeichnis Ihres Projekts. Diese Datei ist Ihr Einstiegspunkt für Ihre Anwendung.

Ein schnelles FastAPI-Beispiel

Sie testen Ihre FastAPI-Installation, indem Sie schnell einen Beispielendpunkt einrichten. Fügen Sie in Ihrer main.py -Datei den folgenden Code ein und speichern Sie die Datei:

 # main.py from fastapi import FastAPI app = FastAPI() @app.get("/") async def root(): return {"greeting":"Hello world"}

Das obige Snippet erstellt einen einfachen FastAPI-Endpunkt. Nachfolgend finden Sie eine Zusammenfassung dessen, was jede Zeile tut:

• from fastapi import FastAPI : Die Funktionalität für Ihre API wird von der FastAPI-Python-Klasse bereitgestellt.
• app = FastAPI() : Dies erstellt eine FastAPI-Instanz.
• @app.get("/") : Dies ist ein Python-Decorator, der FastAPI angibt, dass die darunter liegende Funktion für die Bearbeitung von Anfragen zuständig ist.
• @app.get("/") : Dies ist ein Decorator, der die Route angibt. Dadurch wird eine GET -Methode auf der Route der Site erstellt. Das Ergebnis wird dann von der Wrapped-Funktion zurückgegeben.
• Andere mögliche Operationen, die zur Kommunikation verwendet werden, sind @app.post() , @app.put() , @app.delete() , @app.options() , @app.head() , @app.patch() und @app.trace() .

Führen Sie im Dateiverzeichnis den folgenden Befehl in Ihrem Terminal aus, um den API-Server zu starten:

 $ uvicorn main:app --reload

In diesem Befehl ist main der Name Ihres Moduls. Das app -Objekt ist eine Instanz Ihrer Anwendung und wird in den ASGI-Server importiert. Das Flag --reload weist den Server an, automatisch neu zu laden, wenn Sie Änderungen vornehmen.

Sie sollten in Ihrem Terminal so etwas sehen:

 $ uvicorn main:app --reload INFO: Will watch for changes in these directories: ['D:\\WEB DEV\\Eunit\\Tests\\fast-api'] INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) INFO: Started reloader process [26888] using WatchFiles INFO: Started server process [14956] INFO: Waiting for application startup. INFO: Application startup complete.

Navigieren Sie in Ihrem Browser zu http://localhost:8000 , um zu bestätigen, dass Ihre API funktioniert. Sie sollten „Hello“: „World“ als JSON-Objekt auf der Seite sehen. Dies zeigt, wie einfach es ist, eine API mit FastAPI zu erstellen. Alles, was Sie tun mussten, war, eine Route zu definieren und Ihr Python-Wörterbuch zurückzugeben, wie in Zeile sechs des obigen Ausschnitts zu sehen ist.

Verwenden von Typhinweisen

Wenn Sie Python verwenden, sind Sie es gewohnt, Variablen mit grundlegenden Datentypen wie int , str , float und bool zu kommentieren. Ab Python Version 3.9 wurden jedoch erweiterte Datenstrukturen eingeführt. Dadurch können Sie mit Datenstrukturen wie dictionaries , tuples und lists arbeiten. Mit den Typhinweisen von FastAPI können Sie das Schema Ihrer Daten mithilfe von pydantischen Modellen strukturieren und dann die pydantischen Modelle verwenden, um Hinweise einzugeben und von der bereitgestellten Datenvalidierung zu profitieren.

Im folgenden Beispiel wird die Verwendung von Typhinweisen in Python mit einem einfachen Essenspreisrechner, calculate_meal_fee , demonstriert:

 def calculate_meal_fee(beef_price: int, meal_price: int) -> int: total_price: int = beef_price + meal_price return total_price print("Calculated meal fee", calculate_meal_fee(75, 19))

Beachten Sie, dass Typhinweise die Ausführung Ihres Codes nicht ändern.

Interaktive FastAPI-API-Dokumentation

FastAPI verwendet die Swagger-Benutzeroberfläche, um eine automatische interaktive API-Dokumentation bereitzustellen. Um darauf zuzugreifen, navigieren Sie zu http://localhost:8000/docs und Sie sehen einen Bildschirm mit all Ihren Endpunkten, Methoden und Schemas.

Diese automatische, browserbasierte API-Dokumentation wird von FastAPI bereitgestellt, und Sie müssen nichts weiter tun, um sie zu nutzen.

Eine alternative browserbasierte API-Dokumentation, die ebenfalls von FastAPI bereitgestellt wird, ist Redoc. Um auf Redoc zuzugreifen, navigieren Sie zu http://localhost:8000/redoc , wo Ihnen eine Liste Ihrer Endpunkte, der Methoden und ihrer jeweiligen Antworten angezeigt wird.

Einrichten von Routen in FastAPI

Der @app -Decorator ermöglicht es Ihnen, die Methode der Route anzugeben, z. B. @app.get oder @app.post , und unterstützt GET , POST , PUT und DELETE sowie die weniger gebräuchlichen Optionen HEAD , PATCH und TRACE .

Erstellen Sie Ihre App mit FastAPI

In diesem Tutorial werden Sie durch die Erstellung einer CRUD-Anwendung mit FastAPI geführt. Die Anwendung kann:

• Erstellen Sie einen Benutzer
• Lesen Sie den Datenbankeintrag eines Benutzers
• Aktualisieren Sie einen vorhandenen Benutzer
• Löschen Sie einen bestimmten Benutzer

Um diese CRUD-Vorgänge auszuführen, erstellen Sie Methoden, die die API-Endpunkte verfügbar machen. Das Ergebnis ist eine In-Memory-Datenbank, die eine Liste von Benutzern speichern kann.

Sie verwenden die pydantic-Bibliothek, um die Datenvalidierung und Einstellungsverwaltung mit Anmerkungen vom Typ Python durchzuführen. Für die Zwecke dieses Lernprogramms deklarieren Sie die Form Ihrer Daten als Klassen mit Attributen.

In diesem Lernprogramm wird die In-Memory-Datenbank verwendet. Auf diese Weise können Sie schnell mit der Verwendung von FastAPI zum Erstellen Ihrer APIs beginnen. Für die Produktion können Sie jedoch jede Datenbank Ihrer Wahl verwenden, z. B. PostgreSQL, MySQL, SQLite oder sogar Oracle.

Erstellen der App

Sie beginnen mit der Erstellung Ihres Benutzermodells. Das Benutzermodell hat die folgenden Attribute:

• id : Ein universeller eindeutiger Bezeichner (UUID)
• first_name : Der Vorname des Benutzers
• last_name : Der Nachname des Benutzers
• gender : Das Geschlecht des Benutzers
• roles , bei der es sich um eine Liste mit admin und user handelt

Erstellen Sie zunächst eine neue Datei namens models.py in Ihrem Arbeitsverzeichnis und fügen Sie dann den folgenden Code in models.py ein, um Ihr Modell zu erstellen:

 # models.py from typing import List, Optional from uuid import UUID, uuid4 from pydantic import BaseModel from enum import Enum from pydantic import BaseModel class Gender(str, Enum): male = "male" female = "female" class Role(str, Enum): admin = "admin" user = "user" class User(BaseModel): id: Optional[UUID] = uuid4() first_name: str last_name: str gender: Gender roles: List[Role]

Im obigen Code:

• Ihre User -Klasse erweitert BaseModel , das dann aus pydantic importiert wird.
• Sie haben die Attribute des Benutzers wie oben beschrieben definiert.

Im nächsten Schritt erstellen Sie Ihre Datenbank. Ersetzen Sie den Inhalt Ihrer main.py -Datei durch den folgenden Code:

 # main.py from typing import List from uuid import uuid4 from fastapi import FastAPI from models import Gender, Role, User app = FastAPI() db: List[User] = [ User( id=uuid4(), first_name="John", last_name="Doe", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Jane", last_name="Doe", gender=Gender.female, roles=[Role.user], ), User( id=uuid4(), first_name="James", last_name="Gabriel", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Eunit", last_name="Eunit", gender=Gender.male, roles=[Role.admin, Role.user], ), ]

In main.py :

• Sie haben db mit dem Typ List initialisiert und das User übergeben
• Sie haben eine In-Memory-Datenbank mit vier Benutzern erstellt, jeder mit den erforderlichen Attributen wie first_name , last_name , gender und roles . Dem Benutzer Eunit werden die Rollen admin und user zugewiesen, während den anderen drei Benutzern nur die Rolle user zugewiesen wird.

Datenbankeinträge lesen

Sie haben Ihre In-Memory-Datenbank erfolgreich eingerichtet und mit Benutzern gefüllt. Der nächste Schritt besteht also darin, einen Endpunkt einzurichten, der eine Liste aller Benutzer zurückgibt. Hier kommt FastAPI ins Spiel.

Fügen Sie in Ihrer main.py -Datei den folgenden Code direkt unter Ihrem Hello World Endpunkt ein:

 # main.py @app.get("/api/v1/users") async def get_users(): return db

Dieser Code definiert den Endpunkt /api/v1/users und erstellt eine asynchrone Funktion, get_users , die den gesamten Inhalt der Datenbank db zurückgibt.

Speichern Sie Ihre Datei, und Sie können Ihren Benutzerendpunkt testen. Führen Sie den folgenden Befehl in Ihrem Terminal aus, um den API-Server zu starten:

 $ uvicorn main:app --reload

Navigieren Sie in Ihrem Browser zu http://localhost:8000/api/v1/users . Dies sollte eine Liste aller Ihrer Benutzer zurückgeben, wie unten zu sehen:

Zu diesem Zeitpunkt sieht Ihre main.py -Datei folgendermaßen aus:

 # main.py from typing import List from uuid import uuid4 from fastapi import FastAPI from models import Gender, Role, User app = FastAPI() db: List[User] = [ User( id=uuid4(), first_name="John", last_name="Doe", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Jane", last_name="Doe", gender=Gender.female, roles=[Role.user], ), User( id=uuid4(), first_name="James", last_name="Gabriel", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Eunit", last_name="Eunit", gender=Gender.male, roles=[Role.admin, Role.user], ), ] @app.get("/") async def root(): return {"Hello": "World",} @app.get("/api/v1/users") async def get_users(): return db

Erstellen Sie Datenbankeinträge

Der nächste Schritt besteht darin, einen Endpunkt zu erstellen, um einen neuen Benutzer in Ihrer Datenbank zu erstellen. Fügen Sie das folgende Snippet in Ihre main.py -Datei ein:

 # main.py @app.post("/api/v1/users") async def create_user(user: User): db.append(user) return {"id": user.id}

In diesem Snippet haben Sie den Endpunkt zum Senden eines neuen Benutzers definiert und den Decorator @app.post , um eine POST -Methode zu erstellen.

Sie haben auch die Funktion create_user , die den user des User akzeptiert, und den neu erstellten user db an die Datenbank angehängt (hinzugefügt). Schließlich gibt der Endpunkt ein JSON-Objekt der neu erstellten Benutzer- id zurück.

Sie müssen die von FastAPI bereitgestellte automatische API-Dokumentation verwenden, um Ihren Endpunkt zu testen, wie oben gezeigt. Dies liegt daran, dass Sie mit dem Webbrowser keine Post-Anfrage stellen können. Navigieren Sie zu http://localhost:8000/docs , um dies mit der von SwaggerUI bereitgestellten Dokumentation zu testen.

Datenbankeinträge löschen

Da Sie eine CRUD-App erstellen, muss Ihre Anwendung in der Lage sein, eine bestimmte Ressource zu löschen. Für dieses Tutorial erstellen Sie einen Endpunkt, um einen Benutzer zu löschen.

Fügen Sie den folgenden Code in Ihre main.py -Datei ein:

 # main.py from uuid import UUID from fastapi HTTPException @app.delete("/api/v1/users/{id}") async def delete_user(id: UUID): for user in db: if user.id == id: db.remove(user) return raise HTTPException( status_code=404, detail=f"Delete user failed, id {id} not found." )

Hier ist eine zeilenweise Aufschlüsselung der Funktionsweise dieses Codes:

• @app.delete("/api/v1/users/{id}") : Sie haben den Löschendpunkt mit dem Decorator @app.delete() erstellt. Der Pfad ist immer noch /api/v1/users/{id} , aber dann wird die id abgerufen, die eine Pfadvariable ist, die der ID des Benutzers entspricht.
• async def delete_user(id: UUID): : Erstellt die Funktion delete_user , die die id aus der URL abruft.
• for user in db: : Dies weist die App an, die Benutzer in der Datenbank zu durchlaufen und zu prüfen, ob die übergebene id mit einem Benutzer in der Datenbank übereinstimmt.
• db.remove(user) : Wenn die id mit einem Benutzer übereinstimmt, wird der Benutzer gelöscht; Andernfalls wird eine HTTPException mit dem Statuscode 404 ausgelöst.

Datenbankeinträge aktualisieren

Sie werden einen Endpunkt erstellen, um die Details eines Benutzers zu aktualisieren. Zu den Details, die aktualisiert werden können, gehören die folgenden Parameter: first_name , last_name und roles .

Fügen Sie in Ihrer Datei "models.py " den folgenden Code unter Ihrem User ein, also nach der Klasse User(BaseModel): :

 # models.py class UpdateUser(BaseModel): first_name: Optional[str] last_name: Optional[str] roles: Optional[List[Role]]

In diesem Codeausschnitt erweitert die Klasse UpdateUser BaseModel . Anschließend legen Sie die aktualisierbaren Benutzerparameter wie first_name , last_name und roles als optional fest.

Jetzt erstellen Sie einen Endpunkt, um die Details eines bestimmten Benutzers zu aktualisieren. Fügen Sie in Ihrer main.py -Datei den folgenden Code nach @app.delete decorator ein:

 # main.py @app.put("/api/v1/users/{id}") async def update_user(user_update: UpdateUser, id: UUID): for user in db: if user.id == id: if user_update.first_name is not None: user.first_name = user_update.first_name if user_update.last_name is not None: user.last_name = user_update.last_name if user_update.roles is not None: user.roles = user_update.roles return user.id raise HTTPException(status_code=404, detail=f"Could not find user with id: {id}")

Im obigen Code haben Sie Folgendes getan:

• Erstellt @app.put("/api/v1/users/{id}") , den Aktualisierungsendpunkt. Es hat eine variable Parameter id , die der ID des Benutzers entspricht.
• Eine Methode namens update_user , die die UpdateUser -Klasse und id übernimmt.
• Es wurde eine for -Schleife verwendet, um zu prüfen, ob der mit der übergebenen id verknüpfte Benutzer in der Datenbank vorhanden ist.
• Geprüft, ob einer der Parameter des Benutzers is not None (nicht null) ist. Wenn ein Parameter wie first_name , last_name oder roles nicht null ist, wird er aktualisiert.
• Wenn die Operation erfolgreich ist, wird die Benutzer-ID zurückgegeben.
• Wenn der Benutzer nicht gefunden wurde, wird eine HTTPException -Ausnahme mit dem Statuscode 404 und der Meldung Could not find user with id: {id} ausgelöst.

Stellen Sie zum Testen dieses Endpunkts sicher, dass Ihr Uvicorn-Server ausgeführt wird. Wenn es nicht läuft, geben Sie diesen Befehl ein:

 uvicorn main:app --reload

Unten ist ein Screenshot des Tests.

Sehen Sie, wie FastAPI von Menschen verursachte Fehler um bis zu 40 Prozent reduzieren konnte. Fangen Sie gleich hier an: Click to Tweet

Zusammenfassung

In diesem Tutorial haben Sie das FastAPI-Framework für Python kennengelernt und selbst gesehen, wie schnell Sie eine FastAPI-basierte Anwendung zum Laufen bringen können. Sie haben gelernt, wie Sie CRUD-API-Endpunkte mit dem Framework erstellen – Datenbankdatensätze erstellen, lesen, aktualisieren und löschen.

Wenn Sie jetzt Ihre Web-App-Entwicklung auf die nächste Stufe bringen möchten, sollten Sie sich Kinstas Plattform für Anwendungs-Hosting und Datenbank-Hosting ansehen. Wie FastAPI ist es äußerst einfach.