👉🏿 ↗️ 🙎🏻 Warum sollten Sie sofort mit FastAPI beginnen? 🕊️ 🧢 📠

Hallo Khabrovites! Am Vorabend des Beginns der Klassen in den Gruppen von grundlegenden und fortgeschrittenen Kurse „Python Entwickler“ haben wir eine weitere nützliche Übersetzung für Sie vorbereitet.

Python war schon immer beliebt für die Entwicklung leichter Webanwendungen dank großartiger Frameworks wie Flask, Django, Falcon und mehr. Aufgrund der führenden Position von Python als maschinelle Lernsprache ist es besonders nützlich, um Modelle zu verpacken und als Service bereitzustellen.

Seit Jahren ist Flask das Hauptwerkzeug für solche Aufgaben, aber falls Sie noch nichts davon gehört haben, ist an seiner Stelle ein neuer Anwärter aufgetaucht. FastAPI ist ein relativ neues Python-Framework, das von seinen Vorgängern inspiriert wurde. Es verbessert ihre Funktionalität und behebt viele Mängel. FastAPI wurde auf Starlette aufgebaut und bietet eine Menge fantastischer Funktionen.

In letzter Zeit hat er sehr an Popularität gewonnen, und nach den letzten 8 Monaten, in denen ich jeden Tag mit ihm zusammengearbeitet habe, kann ich zuversichtlich sagen, dass der ganze Hype um ihn völlig gerechtfertigt ist. Wenn Sie es noch nicht ausprobiert haben, habe ich fünf Gründe für Sie zusammengestellt, warum Sie es trotzdem kennenlernen sollten.

Schöne einfache Oberfläche

Alle Frameworks sind gezwungen, ein Gleichgewicht zwischen Funktionalität und Freiheit für den Entwickler herzustellen. Django ist mächtig, aber zu stur. Flask hingegen ist hoch genug, um Handlungsfreiheit zu bieten, aber dem Benutzer bleibt viel übrig. FastAPI ist in dieser Hinsicht näher an Flask, schafft es jedoch, ein noch gesünderes Gleichgewicht zu erreichen.

Lassen Sie uns zum Beispiel sehen, wie FastAPI einen Endpunkt definiert.

from fastapi import FastAPI
from pydantic import BaseModel


class User(BaseModel):
    email: str
    password: str


app = FastAPI()


@app.post("/login")
def login(user: User):
    # ...
    # do some magic
    # ...
    return {"msg": "login successful"}

Es verwendet Pydantic, um das Schema zu definieren, eine ebenso beeindruckende Python-Bibliothek für die Datenvalidierung. Sieht einfach aus, aber unter der Haube ist viel los. Die Verantwortung für die Validierung der Eingabedaten wird an FastAPI delegiert. Wenn beispielsweise eine falsche Anforderung gesendet wird, enthält das E-Mail-Feld einen Wert des Typs int. Der entsprechende Fehlercode wird zurückgegeben, die Anwendung stürzt jedoch nicht ab und löst einen internen Serverfehler aus (500). Und es ist alles fast kostenlos.

Einfache Beispielanwendung mit uvicorn:

uvicorn main:app

Die Anwendung kann jetzt Anfragen annehmen. In diesem Fall sieht die Anfrage folgendermaßen aus:

curl -X POST "http://localhost:8000/login" -H  "accept: application/json" -H  "Content-Type: application/json" -d "{\"email\":\"string\",\"password\":\"string\"}"

Das i-Tüpfelchen ist die automatische Erstellung von Dokumentationen gemäß OpenAPI über die interaktive Swagger-Oberfläche.

Swagger-Schnittstelle für FastAPI-Anwendungen

Async

Einer der größten Nachteile der Python WSGI-Webframeworks im Vergleich zu ihren Gegenstücken in Node.js oder Go war die Unfähigkeit, Anforderungen asynchron zu verarbeiten. Seit der Einführung von ASGI ist dies kein Problem mehr, und FastAPI implementiert diese Funktion vollständig. Sie müssen lediglich die Endpunkte mit dem Schlüsselwort async wie folgt deklarieren:

@app.post("/")
async def endpoint():
    # ...
    # call async functions here with `await`
    # ...
    return {"msg": "FastAPI is awesome!"}

Abhängigkeitsspritze

FastAPI bietet eine wirklich coole Möglichkeit, Abhängigkeiten zu verwalten. Obwohl Entwickler nicht gezwungen sind, Embedded Injection zu verwenden, um Abhängigkeiten von Endpunkten zu behandeln, wird dies dringend empfohlen.

Erstellen wir beispielsweise einen Endpunkt, an dem Benutzer bestimmte Artikel kommentieren können.

from fastapi import FastAPI, Depends
from pydantic import BaseModel


class Comment(BaseModel):
    username: str
    content: str


app = FastAPI()


database = {
    "articles": {
        1: {
            "title": "Top 3 Reasons to Start Using FastAPI Now",
            "comments": []
        }
    }
}


def get_database():
    return database


@app.post("/articles/{article_id}/comments")
def post_comment(article_id: int, comment: Comment, database = Depends(get_database)):
    database["articles"][article_id]["comments"].append(comment)
    return {"msg": "comment posted!"}

FastAPI get_database zur Laufzeit beim Aufrufen des Endpunkts, sodass Sie den Rückgabewert nach Belieben verwenden können. Dafür gibt es (mindestens) zwei gute Gründe.

Sie können Abhängigkeiten global überschreiben, indem Sie das Wörterbuch ändern app.dependency_overrides. Dies erleichtert das Testen und das Verspotten von Objekten.
Die Abhängigkeit (in unserem Fall get_database) kann komplexere Prüfungen durchführen und ermöglicht es Ihnen, diese von der Geschäftslogik zu entkoppeln. Die Sache ist stark vereinfacht. Zum Beispiel, so können Sie ganz einfach die Benutzerauthentifizierung implementieren.

Einfache Integration in Datenbanken

Was auch immer Sie wählen, sei es SQL, MongoDB, Redis oder irgendetwas anderes, FastAPI zwingt Sie nicht, Ihre Anwendung um eine Datenbank herum zu erstellen. Wenn Sie jemals über Django mit MongoDB gearbeitet haben, wissen Sie, wie schmerzhaft es sein kann. Mit FastAPI müssen Sie keinen zusätzlichen Hook ausführen, da das Hinzufügen der Datenbank zum Stack so einfach wie möglich ist. (Oder genauer gesagt, der Arbeitsaufwand wird von der von Ihnen ausgewählten Datenbank bestimmt, nicht von der Komplexität, die mit der Verwendung eines bestimmten Frameworks verbunden ist.)

Schauen Sie sich im Ernst die Schönheit an.

from fastapi import FastAPI, Depends

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker


engine = create_engine("sqlite:///./database.db")
Session = sessionmaker(bind=engine)


def get_db():
    return Session()


app = FastAPI()


@app.get("/")
def an_endpoint_using_sql(db = Depends(get_db)):
    # ...
    # do some SQLAlchemy
    # ...
    return {"msg": "an exceptionally successful operation!"}

Voila! Ich kann dich schon tippen sehen

pip install fastapi

im Terminal Ihres Computers.

GraphQL-Unterstützung

Wenn Sie mit einem komplexen Datenmodell arbeiten, kann REST eine große Hürde sein. Es ist nicht wirklich cool, wenn die kleinste Änderung auf der Vorderseite eine Aktualisierung des Endpunktschemas erfordert. In solchen Fällen spart GraphQL Sie. Während die GraphQL-Unterstützung für Python-Webframeworks nichts Neues ist, arbeiten Graphene und FastAPI gut zusammen. Es ist nicht erforderlich, zusätzliche Erweiterungen zu installieren, zum Beispiel graphene_djangofür Django. Alles wird von Anfang an funktionieren.

+1: Hervorragende Dokumentation

Natürlich kann ein Framework nicht großartig sein, wenn es eine schlechte Dokumentation hat. Django, Flask und andere haben dies gut gemacht, und FastAPI ist nicht weit dahinter. Da er viel jünger ist, gibt es natürlich noch kein einziges Buch über ihn, aber es ist nur eine Frage der Zeit.

Wenn Sie FastAPI in Aktion sehen möchten, habe ich eine großartige Anleitung für Sie. Ich habe ein detailliertes Tutorial geschrieben, mit dem Sie Ihr ML-Modell für Docker-, Docker Compose- und GitHub-Aktionen bereitstellen können!

Zusammenfassend lässt sich sagen, ob Sie ein schnelles und leichtes Framework für die Arbeit mit Ihrem Deep-Learning-Modell oder etwas Komplexeres suchen, FastAPI ist Ihre Option. Ich bin mir ziemlich sicher, dass es für Sie funktionieren wird.

Warum sollten Sie sofort mit FastAPI beginnen?