Zum Inhalt

Alternativen, Inspiration und Vergleiche

Was hat FastAPI inspiriert, ein Vergleich zu Alternativen, und was FastAPI von diesen gelernt hat.

EinfĂŒhrung

FastAPI wĂŒrde ohne die frĂŒhere Arbeit anderer nicht existieren.

Es wurden zuvor viele Tools entwickelt, die als Inspiration fĂŒr seine Entwicklung dienten.

Ich habe die Schaffung eines neuen Frameworks viele Jahre lang vermieden. Zuerst habe ich versucht, alle von FastAPI abgedeckten Funktionen mithilfe vieler verschiedener Frameworks, Plugins und Tools zu lösen.

Aber irgendwann gab es keine andere Möglichkeit, als etwas zu schaffen, das all diese Funktionen bereitstellte, die besten Ideen frĂŒherer Tools aufnahm und diese auf die bestmögliche Weise kombinierte, wobei Sprachfunktionen verwendet wurden, die vorher noch nicht einmal verfĂŒgbar waren (Python 3.6+ Typhinweise).

Vorherige Tools

Django

Es ist das beliebteste Python-Framework und genießt großes Vertrauen. Es wird zum Aufbau von Systemen wie Instagram verwendet.

Ist relativ eng mit relationalen Datenbanken (wie MySQL oder PostgreSQL) gekoppelt, daher ist es nicht sehr einfach, eine NoSQL-Datenbank (wie Couchbase, MongoDB, Cassandra, usw.) als Hauptspeicherengine zu verwenden.

Es wurde erstellt, um den HTML-Code im Backend zu generieren, nicht um APIs zu erstellen, die von einem modernen Frontend (wie React, Vue.js und Angular) oder von anderen Systemen (wie IoT-GerÀten) verwendet werden, um mit ihm zu kommunizieren.

Django REST Framework

Das Django REST Framework wurde als flexibles Toolkit zum Erstellen von Web-APIs unter Verwendung von Django entwickelt, um dessen API-Möglichkeiten zu verbessern.

Es wird von vielen Unternehmen verwendet, darunter Mozilla, Red Hat und Eventbrite.

Es war eines der ersten Beispiele fĂŒr automatische API-Dokumentation, und dies war insbesondere eine der ersten Ideen, welche „die Suche nach“ FastAPI inspirierten.

Hinweis

Das Django REST Framework wurde von Tom Christie erstellt. Derselbe Schöpfer von Starlette und Uvicorn, auf denen FastAPI basiert.

Inspirierte FastAPI

Eine automatische API-DokumentationsoberflÀche zu haben.

Flask

Flask ist ein „Mikroframework“, es enthĂ€lt weder Datenbankintegration noch viele der Dinge, die standardmĂ€ĂŸig in Django enthalten sind.

Diese Einfachheit und FlexibilitÀt ermöglichen beispielsweise die Verwendung von NoSQL-Datenbanken als Hauptdatenspeichersystem.

Da es sehr einfach ist, ist es relativ intuitiv zu erlernen, obwohl die Dokumentation an einigen Stellen etwas technisch wird.

Es wird auch hĂ€ufig fĂŒr andere Anwendungen verwendet, die nicht unbedingt eine Datenbank, Benutzerverwaltung oder eine der vielen in Django enthaltenen Funktionen benötigen. Obwohl viele dieser Funktionen mit Plugins hinzugefĂŒgt werden können.

Diese Entkopplung der Teile und die Tatsache, dass es sich um ein „Mikroframework“ handelt, welches so erweitert werden kann, dass es genau das abdeckt, was benötigt wird, war ein SchlĂŒsselmerkmal, das ich beibehalten wollte.

Angesichts der Einfachheit von Flask schien es eine gute ErgĂ€nzung zum Erstellen von APIs zu sein. Als NĂ€chstes musste ein „Django REST Framework“ fĂŒr Flask gefunden werden.

Inspirierte FastAPI

Ein Mikroframework zu sein. Es einfach zu machen, die benötigten Tools und Teile zu kombinieren.

Über ein einfaches und benutzerfreundliches Routingsystem zu verfĂŒgen.

Requests

FastAPI ist eigentlich keine Alternative zu Requests. Der Umfang der beiden ist sehr unterschiedlich.

Es wĂ€re tatsĂ€chlich ĂŒblich, Requests innerhalb einer FastAPI-Anwendung zu verwenden.

Dennoch erhielt FastAPI von Requests einiges an Inspiration.

Requests ist eine Bibliothek zur Interaktion mit APIs (als Client), wÀhrend FastAPI eine Bibliothek zum Erstellen von APIs (als Server) ist.

Die beiden stehen mehr oder weniger an entgegengesetzten Enden und ergÀnzen sich.

Requests hat ein sehr einfaches und intuitives Design, ist sehr einfach zu bedienen und verfĂŒgt ĂŒber sinnvolle Standardeinstellungen. Aber gleichzeitig ist es sehr leistungsstark und anpassbar.

Aus diesem Grund heißt es auf der offiziellen Website:

Requests ist eines der am hÀufigsten heruntergeladenen Python-Packages aller Zeiten

Die Art und Weise, wie Sie es verwenden, ist sehr einfach. Um beispielsweise einen GET-Request zu machen, wĂŒrden Sie schreiben:

response = requests.get("http://example.com/some/url")

Die entsprechende Pfadoperation der FastAPI-API könnte wie folgt aussehen:

@app.get("/some/url")
def read_url():
    return {"message": "Hello World"}

Sehen Sie sich die Ähnlichkeiten in requests.get(...) und @app.get(...) an.

Inspirierte FastAPI

  • Über eine einfache und intuitive API zu verfĂŒgen.
  • HTTP-Methodennamen (Operationen) direkt, auf einfache und intuitive Weise zu verwenden.
  • VernĂŒnftige Standardeinstellungen zu haben, aber auch mĂ€chtige Einstellungsmöglichkeiten.

Swagger / OpenAPI

Die Hauptfunktion, die ich vom Django REST Framework haben wollte, war die automatische API-Dokumentation.

Dann fand ich heraus, dass es einen Standard namens Swagger gab, zur Dokumentation von APIs unter Verwendung von JSON (oder YAML, einer Erweiterung von JSON).

Und es gab bereits eine Web-OberflĂ€che fĂŒr Swagger-APIs. Die Möglichkeit, Swagger-Dokumentation fĂŒr eine API zu generieren, wĂŒrde die automatische Nutzung dieser Web-OberflĂ€che ermöglichen.

Irgendwann wurde Swagger an die Linux Foundation ĂŒbergeben und in OpenAPI umbenannt.

Aus diesem Grund spricht man bei Version 2.0 hĂ€ufig von „Swagger“ und ab Version 3 von „OpenAPI“.

Inspirierte FastAPI

Einen offenen Standard fĂŒr API-Spezifikationen zu ĂŒbernehmen und zu verwenden, anstelle eines benutzerdefinierten Schemas.

Und Standard-basierte Tools fĂŒr die OberflĂ€che zu integrieren:

Diese beiden wurden ausgewĂ€hlt, weil sie ziemlich beliebt und stabil sind, aber bei einer schnellen Suche könnten Sie Dutzende alternativer BenutzeroberflĂ€chen fĂŒr OpenAPI finden (welche Sie mit FastAPI verwenden können).

Flask REST Frameworks

Es gibt mehrere Flask REST Frameworks, aber nachdem ich die Zeit und Arbeit investiert habe, sie zu untersuchen, habe ich festgestellt, dass viele nicht mehr unterstĂŒtzt werden oder abgebrochen wurden und dass mehrere fortbestehende Probleme sie unpassend machten.

Marshmallow

Eine der von API-Systemen benötigen Hauptfunktionen ist die Daten-„Serialisierung“, welche Daten aus dem Code (Python) entnimmt und in etwas umwandelt, was durch das Netzwerk gesendet werden kann. Beispielsweise das Konvertieren eines Objekts, welches Daten aus einer Datenbank enthĂ€lt, in ein JSON-Objekt. Konvertieren von datetime-Objekten in Strings, usw.

Eine weitere wichtige Funktion, benötigt von APIs, ist die Datenvalidierung, welche sicherstellt, dass die Daten unter gegebenen UmstĂ€nden gĂŒltig sind. Zum Beispiel, dass ein Feld ein int ist und kein zufĂ€lliger String. Das ist besonders nĂŒtzlich fĂŒr hereinkommende Daten.

Ohne ein Datenvalidierungssystem mĂŒssten Sie alle PrĂŒfungen manuell im Code durchfĂŒhren.

FĂŒr diese Funktionen wurde Marshmallow entwickelt. Es ist eine großartige Bibliothek und ich habe sie schon oft genutzt.

Aber sie wurde erstellt, bevor Typhinweise in Python existierten. Um also ein Schema zu definieren, mĂŒssen Sie bestimmte Werkzeuge und Klassen verwenden, die von Marshmallow bereitgestellt werden.

Inspirierte FastAPI

Code zu verwenden, um „Schemas“ zu definieren, welche Datentypen und Validierung automatisch bereitstellen.

Webargs

Eine weitere wichtige Funktion, die von APIs benötigt wird, ist das Parsen von Daten aus eingehenden Requests.

Webargs wurde entwickelt, um dieses fĂŒr mehrere Frameworks, einschließlich Flask, bereitzustellen.

Es verwendet unter der Haube Marshmallow, um die Datenvalidierung durchzufĂŒhren. Und es wurde von denselben Entwicklern erstellt.

Es ist ein großartiges Tool und ich habe es auch oft verwendet, bevor ich FastAPI hatte.

Info

Webargs wurde von denselben Marshmallow-Entwicklern erstellt.

Inspirierte FastAPI

Eingehende Requestdaten automatisch zu validieren.

APISpec

Marshmallow und Webargs bieten Validierung, Parsen und Serialisierung als Plugins.

Es fehlt jedoch noch die Dokumentation. Dann wurde APISpec erstellt.

Es ist ein Plugin fĂŒr viele Frameworks (und es gibt auch ein Plugin fĂŒr Starlette).

Die Funktionsweise besteht darin, dass Sie die Definition des Schemas im YAML-Format im Docstring jeder Funktion schreiben, die eine Route verarbeitet.

Und es generiert OpenAPI-Schemas.

So funktioniert es in Flask, Starlette, Responder, usw.

Aber dann haben wir wieder das Problem einer Mikrosyntax innerhalb eines Python-Strings (eines großen YAML).

Der Texteditor kann dabei nicht viel helfen. Und wenn wir Parameter oder Marshmallow-Schemas Àndern und vergessen, auch den YAML-Docstring zu Àndern, wÀre das generierte Schema veraltet.

Info

APISpec wurde von denselben Marshmallow-Entwicklern erstellt.

Inspirierte FastAPI

Den offenen Standard fĂŒr APIs, OpenAPI, zu unterstĂŒtzen.

Flask-apispec

Hierbei handelt es sich um ein Flask-Plugin, welches Webargs, Marshmallow und APISpec miteinander verbindet.

Es nutzt die Informationen von Webargs und Marshmallow, um mithilfe von APISpec automatisch OpenAPI-Schemas zu generieren.

Ein großartiges Tool, sehr unterbewertet. Es sollte weitaus populĂ€rer als viele andere Flask-Plugins sein. Möglicherweise liegt es daran, dass die Dokumentation zu kompakt und abstrakt ist.

Das löste das Problem, YAML (eine andere Syntax) in Python-Docstrings schreiben zu mĂŒssen.

Diese Kombination aus Flask, Flask-apispec mit Marshmallow und Webargs war bis zur Entwicklung von FastAPI mein Lieblings-Backend-Stack.

Die Verwendung fĂŒhrte zur Entwicklung mehrerer Flask-Full-Stack-Generatoren. Dies sind die Hauptstacks, die ich (und mehrere externe Teams) bisher verwendet haben:

Und dieselben Full-Stack-Generatoren bildeten die Basis der FastAPI-Projektgeneratoren.

Info

Flask-apispec wurde von denselben Marshmallow-Entwicklern erstellt.

Inspirierte FastAPI

Das OpenAPI-Schema automatisch zu generieren, aus demselben Code, welcher die Serialisierung und Validierung definiert.

NestJS (und Angular)

Dies ist nicht einmal Python, NestJS ist ein von Angular inspiriertes JavaScript (TypeScript) NodeJS Framework.

Es erreicht etwas Ähnliches wie Flask-apispec.

Es verfĂŒgt ĂŒber ein integriertes Dependency Injection System, welches von Angular 2 inspiriert ist. Erfordert ein Vorab-Registrieren der „Injectables“ (wie alle anderen Dependency Injection Systeme, welche ich kenne), sodass der Code ausschweifender wird und es mehr Codeverdoppelung gibt.

Da die Parameter mit TypeScript-Typen beschrieben werden (Ă€hnlich den Python-Typhinweisen), ist die EditorunterstĂŒtzung ziemlich gut.

Da TypeScript-Daten jedoch nach der Kompilierung nach JavaScript nicht erhalten bleiben, können die Typen nicht gleichzeitig die Validierung, Serialisierung und Dokumentation definieren. Aus diesem Grund und aufgrund einiger Designentscheidungen ist es fĂŒr die Validierung, Serialisierung und automatische Schemagenerierung erforderlich, an vielen Stellen Dekoratoren hinzuzufĂŒgen. Es wird also ziemlich ausfĂŒhrlich.

Es kann nicht sehr gut mit verschachtelten Modellen umgehen. Wenn es sich beim JSON-Body in der Anfrage also um ein JSON-Objekt mit inneren Feldern handelt, die wiederum verschachtelte JSON-Objekte sind, kann er nicht richtig dokumentiert und validiert werden.

Inspirierte FastAPI

Python-Typen zu verwenden, um eine hervorragende EditorunterstĂŒtzung zu erhalten.

Über ein leistungsstarkes Dependency Injection System zu verfĂŒgen. Eine Möglichkeit zu finden, Codeverdoppelung zu minimieren.

Sanic

Es war eines der ersten extrem schnellen Python-Frameworks, welches auf asyncio basierte. Es wurde so gestaltet, dass es Flask sehr Àhnlich ist.

Technische Details

Es verwendete uvloop anstelle der standardmĂ€ĂŸigen Python-asyncio-Schleife. Das hat es so schnell gemacht.

Hat eindeutig Uvicorn und Starlette inspiriert, welche derzeit in offenen Benchmarks schneller als Sanic sind.

Inspirierte FastAPI

Einen Weg zu finden, eine hervorragende Performanz zu haben.

Aus diesem Grund basiert FastAPI auf Starlette, da dieses das schnellste verfĂŒgbare Framework ist (getestet in Benchmarks von Dritten).

Falcon

Falcon ist ein weiteres leistungsstarkes Python-Framework. Es ist minimalistisch konzipiert und dient als Grundlage fĂŒr andere Frameworks wie Hug.

Es ist so konzipiert, dass es ĂŒber Funktionen verfĂŒgt, welche zwei Parameter empfangen, einen „Request“ und eine „Response“. Dann „lesen“ Sie Teile des Requests und „schreiben“ Teile der Response. Aufgrund dieses Designs ist es nicht möglich, Request-Parameter und -Bodys mit Standard-Python-Typhinweisen als Funktionsparameter zu deklarieren.

Daher mĂŒssen Datenvalidierung, Serialisierung und Dokumentation im Code und nicht automatisch erfolgen. Oder sie mĂŒssen als Framework oberhalb von Falcon implementiert werden, so wie Hug. Dieselbe Unterscheidung findet auch in anderen Frameworks statt, die vom Design von Falcon inspiriert sind und ein Requestobjekt und ein Responseobjekt als Parameter haben.

Inspirierte FastAPI

Wege zu finden, eine großartige Performanz zu erzielen.

Zusammen mit Hug (da Hug auf Falcon basiert), einen response-Parameter in Funktionen zu deklarieren.

Obwohl er in FastAPI optional ist und hauptsÀchlich zum Festlegen von Headern, Cookies und alternativen Statuscodes verwendet wird.

Molten

Ich habe Molten in den ersten Phasen der Entwicklung von FastAPI entdeckt. Und es hat ganz Àhnliche Ideen:

  • Basierend auf Python-Typhinweisen.
  • Validierung und Dokumentation aus diesen Typen.
  • Dependency Injection System.

Es verwendet keine Datenvalidierungs-, Serialisierungs- und Dokumentationsbibliothek eines Dritten wie Pydantic, sondern verfĂŒgt ĂŒber eine eigene. Daher wĂ€ren diese Datentyp-Definitionen nicht so einfach wiederverwendbar.

Es erfordert eine etwas ausfĂŒhrlichere Konfiguration. Und da es auf WSGI (anstelle von ASGI) basiert, ist es nicht darauf ausgelegt, die hohe Leistung von Tools wie Uvicorn, Starlette und Sanic zu nutzen.

Das Dependency Injection System erfordert eine Vorab-Registrierung der AbhĂ€ngigkeiten und die AbhĂ€ngigkeiten werden basierend auf den deklarierten Typen aufgelöst. Daher ist es nicht möglich, mehr als eine „Komponente“ zu deklarieren, welche einen bestimmten Typ bereitstellt.

Routen werden an einer einzigen Stelle deklariert, indem Funktionen verwendet werden, die an anderen Stellen deklariert wurden (anstatt Dekoratoren zu verwenden, welche direkt ĂŒber der Funktion platziert werden können, welche den Endpunkt verarbeitet). Dies Ă€hnelt eher der Vorgehensweise von Django als der Vorgehensweise von Flask (und Starlette). Es trennt im Code Dinge, die relativ eng miteinander gekoppelt sind.

Inspirierte FastAPI

ZusĂ€tzliche Validierungen fĂŒr Datentypen zu definieren, mithilfe des „Default“-Werts von Modellattributen. Dies verbessert die EditorunterstĂŒtzung und war zuvor in Pydantic nicht verfĂŒgbar.

Das hat tatsĂ€chlich dazu gefĂŒhrt, dass Teile von Pydantic aktualisiert wurden, um denselben Validierungsdeklarationsstil zu unterstĂŒtzen (diese gesamte FunktionalitĂ€t ist jetzt bereits in Pydantic verfĂŒgbar).

Hug

Hug war eines der ersten Frameworks, welches die Deklaration von API-Parametertypen mithilfe von Python-Typhinweisen implementierte. Das war eine großartige Idee, die andere Tools dazu inspirierte, dasselbe zu tun.

Es verwendete benutzerdefinierte Typen in seinen Deklarationen anstelle von Standard-Python-Typen, es war aber dennoch ein großer Fortschritt.

Außerdem war es eines der ersten Frameworks, welches ein benutzerdefiniertes Schema generierte, welches die gesamte API in JSON deklarierte.

Es basierte nicht auf einem Standard wie OpenAPI und JSON Schema. Daher wÀre es nicht einfach, es in andere Tools wie Swagger UI zu integrieren. Aber, nochmal, es war eine sehr innovative Idee.

Es verfĂŒgt ĂŒber eine interessante, ungewöhnliche Funktion: Mit demselben Framework ist es möglich, APIs und auch CLIs zu erstellen.

Da es auf dem bisherigen Standard fĂŒr synchrone Python-Webframeworks (WSGI) basiert, kann es nicht mit Websockets und anderen Dingen umgehen, verfĂŒgt aber dennoch ĂŒber eine hohe Performanz.

Info

Hug wurde von Timothy Crosley erstellt, dem gleichen Schöpfer von isort, einem großartigen Tool zum automatischen Sortieren von Importen in Python-Dateien.

Ideen, die FastAPI inspiriert haben

Hug inspirierte Teile von APIStar und war eines der Tools, die ich am vielversprechendsten fand, neben APIStar.

Hug hat dazu beigetragen, FastAPI dazu zu inspirieren, Python-Typhinweise zum Deklarieren von Parametern zu verwenden und ein Schema zu generieren, das die API automatisch definiert.

Hug inspirierte FastAPI dazu, einen response-Parameter in Funktionen zu deklarieren, um Header und Cookies zu setzen.

APIStar (≩ 0.5)

Kurz bevor ich mich entschied, FastAPI zu erstellen, fand ich den APIStar-Server. Er hatte fast alles, was ich suchte, und ein tolles Design.

Er war eine der ersten Implementierungen eines Frameworks, die ich je gesehen hatte (vor NestJS und Molten), welches Python-Typhinweise zur Deklaration von Parametern und Requests verwendeten. Ich habe ihn mehr oder weniger zeitgleich mit Hug gefunden. Aber APIStar nutzte den OpenAPI-Standard.

Er verfĂŒgte an mehreren Stellen ĂŒber automatische Datenvalidierung, Datenserialisierung und OpenAPI-Schemagenerierung, basierend auf denselben Typhinweisen.

Body-Schemadefinitionen verwendeten nicht die gleichen Python-Typhinweise wie Pydantic, er war Marshmallow etwas Ă€hnlicher, sodass die EditorunterstĂŒtzung nicht so gut war, aber dennoch war APIStar die beste verfĂŒgbare Option.

Er hatte zu dieser Zeit die besten Leistungsbenchmarks (nur ĂŒbertroffen von Starlette).

Anfangs gab es keine Web-OberflĂ€che fĂŒr die automatische API-Dokumentation, aber ich wusste, dass ich Swagger UI hinzufĂŒgen konnte.

Er verfĂŒgte ĂŒber ein Dependency Injection System. Es erforderte eine Vorab-Registrierung der Komponenten, wie auch bei anderen oben besprochenen Tools. Aber dennoch, es war ein tolles Feature.

Ich konnte ihn nie in einem vollstĂ€ndigen Projekt verwenden, da er keine Sicherheitsintegration hatte, sodass ich nicht alle Funktionen, die ich hatte, durch die auf Flask-apispec basierenden Full-Stack-Generatoren ersetzen konnte. Ich hatte in meinem Projekte-Backlog den Eintrag, einen Pull Request zu erstellen, welcher diese FunktionalitĂ€t hinzufĂŒgte.

Doch dann verlagerte sich der Schwerpunkt des Projekts.

Es handelte sich nicht lÀnger um ein API-Webframework, da sich der Entwickler auf Starlette konzentrieren musste.

Jetzt handelt es sich bei APIStar um eine Reihe von Tools zur Validierung von OpenAPI-Spezifikationen, nicht um ein Webframework.

Info

APIStar wurde von Tom Christie erstellt. Derselbe, welcher Folgendes erstellt hat:

  • Django REST Framework
  • Starlette (auf welchem FastAPI basiert)
  • Uvicorn (verwendet von Starlette und FastAPI)

Inspirierte FastAPI

Zu existieren.

Die Idee, mehrere Dinge (Datenvalidierung, Serialisierung und Dokumentation) mit denselben Python-Typen zu deklarieren, welche gleichzeitig eine hervorragende EditorunterstĂŒtzung bieten, hielt ich fĂŒr eine brillante Idee.

Und nach einer langen Suche nach einem Ă€hnlichen Framework und dem Testen vieler verschiedener Alternativen, war APIStar die beste verfĂŒgbare Option.

Dann hörte APIStar auf, als Server zu existieren, und Starlette wurde geschaffen, welches eine neue, bessere Grundlage fĂŒr ein solches System bildete. Das war die finale Inspiration fĂŒr die Entwicklung von FastAPI.

Ich betrachte FastAPI als einen „spirituellen Nachfolger“ von APIStar, welcher die Funktionen, das Typsystem und andere Teile verbessert und erweitert, basierend auf den Erkenntnissen aus all diesen frĂŒheren Tools.

Verwendet von FastAPI

Pydantic

Pydantic ist eine Bibliothek zum Definieren von Datenvalidierung, Serialisierung und Dokumentation (unter Verwendung von JSON Schema) basierend auf Python-Typhinweisen.

Das macht es Ă€ußerst intuitiv.

Es ist vergleichbar mit Marshmallow. Obwohl es in Benchmarks schneller als Marshmallow ist. Und da es auf den gleichen Python-Typhinweisen basiert, ist die EditorunterstĂŒtzung großartig.

FastAPI verwendet es, um

Die gesamte Datenvalidierung, Datenserialisierung und automatische Modelldokumentation (basierend auf JSON Schema) zu erledigen.

FastAPI nimmt dann, abgesehen von all den anderen Dingen, die es tut, dieses JSON-Schema und fĂŒgt es in OpenAPI ein.

Starlette

Starlette ist ein leichtgewichtiges ASGI-Framework/Toolkit, welches sich ideal fĂŒr die Erstellung hochperformanter asynchroner Dienste eignet.

Es ist sehr einfach und intuitiv. Es ist so konzipiert, dass es leicht erweiterbar ist und ĂŒber modulare Komponenten verfĂŒgt.

Es bietet:

  • Eine sehr beeindruckende Leistung.
  • WebSocket-UnterstĂŒtzung.
  • Hintergrundtasks im selben Prozess.
  • Events fĂŒr das Hoch- und Herunterfahren.
  • Testclient basierend auf HTTPX.
  • CORS, GZip, statische Dateien, Streamende Responses.
  • Session- und Cookie-UnterstĂŒtzung.
  • 100 % Testabdeckung.
  • 100 % Typannotierte Codebasis.
  • Wenige starke AbhĂ€ngigkeiten.

Starlette ist derzeit das schnellste getestete Python-Framework. Nur ĂŒbertroffen von Uvicorn, welches kein Framework, sondern ein Server ist.

Starlette bietet alle grundlegenden Funktionen eines Web-Microframeworks.

Es bietet jedoch keine automatische Datenvalidierung, Serialisierung oder Dokumentation.

Das ist eines der wichtigsten Dinge, welche FastAPI hinzufĂŒgt, alles basierend auf Python-Typhinweisen (mit Pydantic). Das, plus, das Dependency Injection System, Sicherheitswerkzeuge, OpenAPI-Schemagenerierung, usw.

Technische Details

ASGI ist ein neuer „Standard“, welcher von Mitgliedern des Django-Kernteams entwickelt wird. Es handelt sich immer noch nicht um einen „Python-Standard“ (ein PEP), obwohl sie gerade dabei sind, das zu tun.

Dennoch wird es bereits von mehreren Tools als „Standard“ verwendet. Das verbessert die InteroperabilitĂ€t erheblich, da Sie Uvicorn mit jeden anderen ASGI-Server (wie Daphne oder Hypercorn) tauschen oder ASGI-kompatible Tools wie python-socketio hinzufĂŒgen können.

FastAPI verwendet es, um

Alle Kern-Webaspekte zu handhaben. Und fĂŒgt Funktionen obenauf.

Die Klasse FastAPI selbst erbt direkt von der Klasse Starlette.

Alles, was Sie also mit Starlette machen können, können Sie direkt mit FastAPI machen, da es sich im Grunde um Starlette auf Steroiden handelt.

Uvicorn

Uvicorn ist ein blitzschneller ASGI-Server, der auf uvloop und httptools basiert.

Es handelt sich nicht um ein Webframework, sondern um einen Server. Beispielsweise werden keine Tools fĂŒr das Routing von Pfaden bereitgestellt. Das ist etwas, was ein Framework wie Starlette (oder FastAPI) zusĂ€tzlich bieten wĂŒrde.

Es ist der empfohlene Server fĂŒr Starlette und FastAPI.

FastAPI empfiehlt es als

Hauptwebserver zum AusfĂŒhren von FastAPI-Anwendungen.

Sie können ihn mit Gunicorn kombinieren, um einen asynchronen Multiprozess-Server zu erhalten.

Weitere Details finden Sie im Abschnitt Deployment.

Benchmarks und Geschwindigkeit

Um den Unterschied zwischen Uvicorn, Starlette und FastAPI zu verstehen, zu vergleichen und zu sehen, lesen Sie den Abschnitt ĂŒber Benchmarks.