Top 5 asynchrone Web-Frameworks für Python

von

Asynchrone Programmierung ist jetzt ein erstklassiger Bürger in Python. Wenn Sie ein Webentwickler sind, gibt es erstaunliche Frameworks, aus denen Sie wählen können!

Während ich dies schreibe, ist asynchron nicht mehr nur ein Schlagwort in der Python-Community. Mit der Veröffentlichung seiner asyncio Bibliothek in Version 3.5 erkannte Python die Auswirkungen von Node.js auf die Webentwicklung an und führte zwei neue Schlüsselwörter in die Sprache ein – async und await. Dies war eine sehr große Sache, da die Python-Sprache äußerst vorsichtig ist, die Kernsyntax zu erweitern, es sei denn, es besteht ein dringender Bedarf, was nur zeigt, wie grundlegend wichtig die Python-Entwickler die asynchronen Fähigkeiten betrachteten.

Infolgedessen wurden Schleusen der asynchronen Programmierung geöffnet: Neue und alte Bibliotheken begannen, die Coroutinen-Funktion zu nutzen, asynchrone Frameworks wurden immer beliebter und es werden noch heute neue geschrieben. Eine Leistung auf Augenhöhe oder besser als die von Node.js ist keine Seltenheit, und wenn Ihre Lademuster nicht viele CPU-lastige Aufgaben beinhalten, gibt es keinen Grund, warum Sie nicht ein paar tausend Anfragen pro Sekunde stellen können.

Aber genug Motivation!

Sehen wir uns die aktuelle Python-Landschaft an und sehen uns einige der besten asynchronen Frameworks an.

Inhaltsverzeichnis

Tornado

Überraschenderweise, Tornado ist überhaupt kein neues Framework. Die Erstveröffentlichung erfolgte im Jahr 2009 (vor genau zehn Jahren zum Zeitpunkt des Schreibens) und seitdem liegt der Schwerpunkt auf der Bereitstellung einer felsenfesten asynchronen Programmierung mit hoher Parallelität.

Tornado ist im Grunde kein Webframework. Es ist eine Sammlung von asynchronen Modulen, die auch zum Erstellen des Web-Framework-Moduls verwendet werden. Genauer gesagt handelt es sich bei diesen Modulen um:

  • Coroutinen und andere Primitive (tornado.gen, tornado.locks, tornado.queues usw.)
  • Netzwerkmodule (tornado.ioloop, tornado.iostream etc.)
  • Asynchrone Server und Clients (tornado.httpser, tornado.httpclient usw.)

Diese wurden kombiniert, um die endgültigen Framework-Module zu erstellen: tornado.web, tornado.routing, tornado.template usw.

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

Tornado hat eine starke und engagierte Anhängerschaft in der Python-Community und wird von erfahrenen Architekten verwendet, um hochleistungsfähige Systeme zu bauen. Es ist ein Framework, das seit langem die Antwort auf die Probleme der Parallelität hat, aber vielleicht nicht zum Mainstream geworden ist, da es den WSGI-Standard nicht unterstützt und zu viel Buy-in war (denken Sie daran, dass der Großteil der Python-Bibliotheken immer noch synchron ist ).

  So fügen Sie Kopf- und Fußzeilen in Google Docs hinzu

Sanic

Sanic ist ein „modernes“ Framework im wahrsten Sinne des Wortes: Es unterstützt keine Python-Versionen unter 3.6, unterstützt die einfache und universelle async/await-Syntax von Haus aus und zwingt Sie daher nicht dazu, viel zu lesen der Dokumentation und behalten Sie Grenzfälle im Hinterkopf, bevor Sie Ihren ersten HTTP-Handler schreiben können.

Als Ergebnis ist die resultierende Syntax recht angenehm (zumindest meiner Meinung nach); Es ähnelt Code, den Sie mit jedem anderen Mikroframework (z. B. Flask, CherryPy) schreiben würden, mit nur wenigen Async-Einstreuungen:

from sanic import Sanic
from sanic.response import json

app = Sanic()

@app.route("/")
async def test(request):
    return json({"hello": "world"})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000)

Sanic ist wohl das beliebteste und beliebteste asynchrone Framework in der Python-Welt. Es hat fast alle Funktionen, die Sie sich für Ihre Projekte wünschen – Routing, Middleware, Cookies, Versionierung, Blaupausen, klassenbasierte Ansichten, statische Dateien, Streaming, Sockets usw. – und was es nicht sofort bietet – Templating, Datenbankunterstützung, Datei-I/O, Warteschlangen – können hinzugefügt werden, da es ab heute gerade genug asynchrone Bibliotheken dafür gibt.

Vibrora

Vibrora ist ein enger Cousin von Sanic, außer dass es darauf fixiert ist, der schnellste Python-Webserver da draußen zu werden. Tatsächlich begrüßt Sie der allererste Besuch seiner Website mit einem Rahmenvergleich:

Wie Sie sehen können, behauptet Vibora, um ein Vielfaches schneller zu sein als die klassischen Frameworks und mehr als doppelt so schnell wie Sanic, sein nächster Konkurrent. Benchmarks sind natürlich mit Vorsicht zu genießen. 🙂

Obwohl Vibora in Syntax und Funktionen mit Sanic vergleichbar ist (oder vielleicht sogar etwas besser ist, da es beliebte Bibliotheken bündelt und Dinge wie Templating sofort verfügbar sind), würde ich Sanic für ausgereifter halten, da es schon länger existiert und hat eine größere Gemeinschaft.

from vibora import Vibora, JsonResponse

app = Vibora()

@app.route('/')
async def home():
    return JsonResponse({'hello': 'world'})

if __name__ == '__main__':
    app.run(host="0.0.0.0", port=8000)

Wenn Sie jedoch ein Leistungsjunkie sind, könnte Vibora Ihr Boot schwimmen lassen. Das heißt, zum Zeitpunkt des Schreibens wird Vibora komplett neu geschrieben, um noch schneller zu werden, und das Verknüpfung zu seiner Performance-Version sagt, dass es sich in „schwerer Entwicklung“ befindet. Es wird eine Enttäuschung für diejenigen sein, die Vibora früher in die Hand genommen haben und sich bald mit bahnbrechenden Änderungen auseinandersetzen müssen, aber hey, es ist noch früh in der asynchronen Python-Welt, und niemand erwartet, dass die Dinge stabil sind.

  So verbessern Sie die GPS-Tracking-Genauigkeit in Ihren Trainings-Apps

Quart

Wenn Sie gerne in Flask entwickeln, aber den Mangel an asynchroner Unterstützung bereuen, werden Sie es genießen Quart viel.

Quart ist konform mit der ASGI Standard, der ein Nachfolger des berühmten WSGI-Standards ist und Async-Unterstützung bietet. Das Interessante an Quart ist, dass es nicht nur Flask ähnelt, sondern tatsächlich mit der Flask-API kompatibel ist! Der Autor dieses Frameworks wollte das Flask-Feeling bewahren und ihm lediglich Unterstützung für Async, WebSockets und HTTP 2 hinzufügen. Daher können Sie Quart direkt aus der Flask-Dokumentation lernen, wobei Sie nur bedenken müssen, dass Funktionen in Quart asynchron sind.

from quart import Quart

app = Quart(__name__)

@app.route('/')
async def hello():
    return 'hello'

app.run()

Fühlt sich (fast) genauso an wie Flask, oder?!

Da Quart eine Weiterentwicklung von Flask ist, sind alle Funktionen in Flask verfügbar: Routing, Middleware, Sessions, Templating, Blueprints und so weiter. Tatsächlich können Sie Flask-Erweiterungen sogar direkt in Quart verwenden. Ein Haken ist, dass nur Python 3.7+ unterstützt wird, aber wenn Sie dann nicht die neueste Version von Python ausführen, ist Async vielleicht nicht der richtige Weg. 🙂

Die Dokumentation ist wirklich mangelhaft, wenn Sie keine früheren Erfahrungen mit Flask haben, aber ich kann Quart empfehlen, da es wahrscheinlich das einzige asynchrone Framework ist, das sich bald seiner 1.0-Veröffentlichung nähert.

FastAPI

Das letzte (aber beeindruckendste) Framework auf dieser Liste ist FastAPI. Nein, es ist kein reines API-Framework; Tatsächlich scheint FastAPI das funktionsreichste und dokumentationsreichste Framework zu sein, auf das ich bei der Recherche nach asynchronen Python-Frameworks gestoßen bin.

Es ist interessant festzustellen, dass der Framework-Autor mehrere andere Frameworks eingehend untersucht hat, von zeitgenössischen wie Django bis hin zu modernen wie Sanic, und sich auch technologieübergreifend mit NestJS (einem Node.js, Typescript-Webframework) beschäftigt hat. Ihre Entwicklungsphilosophie und umfangreiche Vergleiche sind nachzulesen hier.

Die Syntax ist recht angenehm; man kann sogar argumentieren, dass es viel angenehmer ist als die anderen Frameworks, auf die wir gestoßen sind:

rom fastapi import FastAPI

app = FastAPI()

@app.get("/users/me")
async def read_user_me():
    return {"user_id": "the current user"}

@app.get("/users/{user_id}")
async def read_user(user_id: str):
    return {"user_id": user_id}

Und jetzt die Liste der Killer-Features, die FastAPI andere Frameworks in den Schatten stellen:

  5 beste EHR/EMR-Software für das Gesundheitswesen

Automatische Generierung von API-Dokumenten: Sobald Ihre Endpunkte geschrieben wurden, können Sie mit der API über eine standardkonforme Benutzeroberfläche spielen. SwaggerUI, ReDoc und andere werden unterstützt.

Das Framework führt auch eine automatische Datenmodelldokumentation mit JSON-Schema durch.

Moderne Entwicklung: Ja, das Wort „modern“ wird viel herumgeworfen, aber ich fand, dass FastAPI tatsächlich seinen Worten Taten folgen lässt. Dependency Injection und Type Hinting sind erstklassige Bürger, die nicht nur gute Codierungsprinzipien durchsetzen, sondern auf lange Sicht Fehler und Verwirrung verhindern.

Umfangreiche Dokumentation: Ich weiß nicht, wie es euch geht, aber ich bin ein totaler Fan von guter Dokumentation. Und in diesem Bereich gewinnt FastAPI zweifellos. Es hat Seiten über Seiten mit Dokumenten, die fast jede kleine Feinheit erklären und „aufpassen!“ Momente für Entwickler aller Ebenen. Ich spüre ein klares „Herz und Seele“ in der Dokumentation hier, und der einzige Vergleich, den ich finden kann, ist die Django-Dokumentation (ja, FastAPI-Dokumentation ist so gut!).

Über die Grundlagen hinaus: FastAPI unterstützt WebSockets, Streaming sowie GraphQL und verfügt außerdem über alle traditionellen Helfer wie CORS, Sessions, Cookies und so weiter.

Und was ist mit der Leistung? Nun, FastAPI basiert auf der erstaunlichen Starlette-Bibliothek, was zu einer Leistung führt, die mit Node und in einigen Fällen sogar mit Go! Alles in allem habe ich wirklich das Gefühl, dass FastAPI als das beste Async-Framework für Python nach vorne rennen wird.

Fazit

Heutzutage ist in der asynchronen Python-Landschaft viel los. Neue Frameworks tauchen auf, alte werden neu geschrieben und Bibliotheken werden weiterentwickelt, um dem asynchronen Verhalten zu entsprechen. Während Python über eine integrierte Unterstützung für eine Ereignisschleife verfügt und es möglich ist, Teile Ihrer Anwendung asynchron zu machen, können Sie sich dafür entscheiden, alles zu tun und auf einem der Frameworks hier aufzubauen. Achten Sie nur darauf, die Langfristigkeit im Auge zu behalten: Einige der asynchronen Python-Frameworks befinden sich in einem frühen Stadium und werden schnell weiterentwickelt, was Ihrem Entwicklungsprozess schaden und die Geschäftskosten erhöhen wird. Vorsicht ist angesagt!

Aber alles gesagt und getan; Python ist produktionsbereit, um eine leichte Leistung zu liefern, wenn es um Web-Frameworks geht. Wenn Sie schon so lange daran denken, zu Node zu migrieren, müssen Sie das jetzt nicht tun! 🙂

Hört sich cool an? Master Python heute!