Zum Inhalt

FastAPI

FastAPI

FastAPI-Framework, hohe Performanz, leicht zu lernen, schnell zu entwickeln, produktionsreif

Test Testabdeckung Package-Version UnterstĂŒtzte Python-Versionen

Dokumentation: https://fastapi.tiangolo.com/de

Quellcode: https://github.com/fastapi/fastapi

FastAPI ist ein modernes, schnelles (hoch performantes) Webframework zur Erstellung von APIs mit Python auf Basis von Standard-Python-Typhinweisen.

Seine SchlĂŒssel-Merkmale sind:

  • Schnell: Sehr hohe Performanz, auf Augenhöhe mit NodeJS und Go (dank Starlette und Pydantic). Eines der schnellsten verfĂŒgbaren Python-Frameworks.
  • Schnell zu entwickeln: Erhöhen Sie die Geschwindigkeit bei der Entwicklung von Features um etwa 200 % bis 300 %. *
  • Weniger Bugs: Verringern Sie die von Menschen (Entwicklern) verursachten Fehler um etwa 40 %. *
  • Intuitiv: Hervorragende Editor-UnterstĂŒtzung. Code-VervollstĂ€ndigung ĂŒberall. Weniger Zeit mit Debuggen verbringen.
  • Einfach: So konzipiert, dass es einfach zu benutzen und zu erlernen ist. Weniger Zeit mit dem Lesen von Dokumentation verbringen.
  • Kurz: Minimieren Sie die Verdoppelung von Code. Mehrere Features aus jeder Parameterdeklaration. Weniger Bugs.
  • Robust: Erhalten Sie produktionsreifen Code. Mit automatischer, interaktiver Dokumentation.
  • Standards-basiert: Basierend auf (und vollstĂ€ndig kompatibel mit) den offenen Standards fĂŒr APIs: OpenAPI (frĂŒher bekannt als Swagger) und JSON Schema.

* SchĂ€tzung basierend auf Tests, die von einem internen Entwicklungsteam durchgefĂŒhrt wurden, das Produktionsanwendungen erstellt.

Sponsoren

Keystone-Sponsor

Gold- und Silber-Sponsoren

Andere Sponsoren

Meinungen

„[...] Ich verwende FastAPI heutzutage sehr oft. [...] Ich habe tatsĂ€chlich vor, es fĂŒr alle ML-Services meines Teams bei Microsoft zu verwenden. Einige davon werden in das Kernprodukt Windows und einige Office-Produkte integriert.“

Kabir Khan – Microsoft (Ref.)

„Wir haben die FastAPI-Bibliothek ĂŒbernommen, um einen REST-Server zu erstellen, der fĂŒr Vorhersagen abgefragt werden kann. [fĂŒr Ludwig]“

Piero Molino, Yaroslav Dudin, und Sai Sumanth Miryala – Uber (Ref.)

„Netflix freut sich, die Open-Source-Veröffentlichung unseres Krisenmanagement-Orchestrierung-Frameworks bekannt zu geben: Dispatch! [erstellt mit FastAPI]“

Kevin Glisson, Marc Vilanova, Forest Monsen – Netflix (Ref.)

„Ich bin hellauf begeistert von FastAPI. Es macht so viel Spaß!“

Brian Okken – Python Bytes Podcast-Host (Ref.)

„Ehrlich, was Du gebaut hast, sieht super solide und poliert aus. In vielerlei Hinsicht ist es so, wie ich Hug haben wollte – es ist wirklich inspirierend, jemanden so etwas bauen zu sehen.“

Timothy Crosley – Hug-Autor (Ref.)

„Wenn Sie ein modernes Framework zum Erstellen von REST-APIs erlernen möchten, schauen Sie sich FastAPI an. [...] Es ist schnell, einfach zu verwenden und leicht zu lernen [...]“

„Wir haben zu FastAPI fĂŒr unsere APIs gewechselt [...] Ich denke, es wird Ihnen gefallen [...]“

Ines Montani – Matthew Honnibal – Explosion AI-GrĂŒnder – spaCy-Autoren (Ref.) – (Ref.)

„Falls irgendjemand eine Produktions-Python-API erstellen möchte, kann ich FastAPI wĂ€rmstens empfehlen. Es ist wunderschön konzipiert, einfach zu verwenden und hoch skalierbar; es ist zu einer SchlĂŒsselkomponente unserer API-First-Entwicklungsstrategie geworden und treibt viele Automatisierungen und Services an, wie etwa unseren Virtual TAC Engineer.“

Deon Pillsbury – Cisco (Ref.)

Typer, das FastAPI der CLIs

Wenn Sie eine CLI-Anwendung fĂŒr das Terminal erstellen, anstelle einer Web-API, schauen Sie sich Typer an.

Typer ist die kleine Schwester von FastAPI. Und es soll das FastAPI der CLIs sein. ⌚ 🚀

Anforderungen

FastAPI steht auf den Schultern von Giganten:

Installation

Erstellen und aktivieren Sie eine virtuelle Umgebung und installieren Sie dann FastAPI:

$ pip install "fastapi[standard]"

---> 100%

Hinweis: Stellen Sie sicher, dass Sie "fastapi[standard]" in AnfĂŒhrungszeichen setzen, damit es in allen Terminals funktioniert.

Beispiel

Erstellung

Erstellen Sie eine Datei main.py mit:

from typing import Union

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}
Oder verwenden Sie async def ...

Wenn Ihr Code async / await verwendet, benutzen Sie async def:

from typing import Union

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
async def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}

Hinweis:

Wenn Sie das nicht kennen, schauen Sie sich den Abschnitt „In Eile?“ ĂŒber async und await in der Dokumentation an.

Starten

Starten Sie den Server mit:

$ fastapi dev main.py

 ╭────────── FastAPI CLI - Development mode ───────────╼
 │                                                     │
 │  Serving at: http://127.0.0.1:8000                  │
 │                                                     │
 │  API docs: http://127.0.0.1:8000/docs               │
 │                                                     │
 │  Running in development mode, for production use:   │
 │                                                     │
 │  fastapi run                                        │
 │                                                     │
 ╰─────────────────────────────────────────────────────╯

INFO:     Will watch for changes in these directories: ['/home/user/code/awesomeapp']
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [2248755] using WatchFiles
INFO:     Started server process [2248757]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
Was der Befehl fastapi dev main.py macht ...

Der Befehl fastapi dev liest Ihre main.py-Datei, erkennt die FastAPI-App darin und startet einen Server mit Uvicorn.

StandardmĂ€ĂŸig wird fastapi dev mit aktiviertem Auto-Reload fĂŒr die lokale Entwicklung gestartet.

Sie können mehr darĂŒber in der FastAPI CLI Dokumentation lesen.

Es testen

Öffnen Sie Ihren Browser unter http://127.0.0.1:8000/items/5?q=somequery.

Sie sehen die JSON-Response als:

{"item_id": 5, "q": "somequery"}

Sie haben bereits eine API erstellt, welche:

  • HTTP-Requests auf den Pfaden / und /items/{item_id} entgegennimmt.
  • Beide Pfade nehmen GET Operationen (auch bekannt als HTTP-Methoden) entgegen.
  • Der Pfad /items/{item_id} hat einen Pfad-Parameter item_id, der ein int sein sollte.
  • Der Pfad /items/{item_id} hat einen optionalen str-Query-Parameter q.

Interaktive API-Dokumentation

Gehen Sie nun auf http://127.0.0.1:8000/docs.

Sie sehen die automatische interaktive API-Dokumentation (bereitgestellt von Swagger UI):

Swagger UI

Alternative API-Dokumentation

Und jetzt gehen Sie auf http://127.0.0.1:8000/redoc.

Sie sehen die alternative automatische Dokumentation (bereitgestellt von ReDoc):

ReDoc

Beispiel Aktualisierung

Ändern Sie jetzt die Datei main.py, um den Body eines PUT-Requests zu empfangen.

Deklarieren Sie den Body mit Standard-Python-Typen, dank Pydantic.

from typing import Union

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    price: float
    is_offer: Union[bool, None] = None


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}


@app.put("/items/{item_id}")
def update_item(item_id: int, item: Item):
    return {"item_name": item.name, "item_id": item_id}

Der fastapi dev-Server sollte automatisch neu laden.

Interaktive API-Dokumentation aktualisieren

Gehen Sie jetzt auf http://127.0.0.1:8000/docs.

  • Die interaktive API-Dokumentation wird automatisch aktualisiert, einschließlich des neuen Bodys:

Swagger UI

  • Klicken Sie auf den Button „Try it out“, damit können Sie die Parameter ausfĂŒllen und direkt mit der API interagieren:

Swagger UI Interaktion

  • Klicken Sie dann auf den Button „Execute“, die BenutzeroberflĂ€che wird mit Ihrer API kommunizieren, sendet die Parameter, holt die Ergebnisse und zeigt sie auf dem Bildschirm an:

Swagger UI Interaktion

Alternative API-Dokumentation aktualisieren

Und jetzt gehen Sie auf http://127.0.0.1:8000/redoc.

  • Die alternative Dokumentation wird ebenfalls den neuen Query-Parameter und Body widerspiegeln:

ReDoc

Zusammenfassung

Zusammengefasst deklarieren Sie einmal die Typen von Parametern, Body, usw. als Funktionsparameter.

Das machen Sie mit modernen Standard-Python-Typen.

Sie mĂŒssen keine neue Syntax, Methoden oder Klassen einer bestimmten Bibliothek usw. lernen.

Nur Standard-Python.

Zum Beispiel fĂŒr ein int:

item_id: int

oder fĂŒr ein komplexeres Item-Modell:

item: Item

... und mit dieser einen Deklaration erhalten Sie:

  • Editor-UnterstĂŒtzung, einschließlich:
    • Code-VervollstĂ€ndigung.
    • TypprĂŒfungen.
  • Validierung von Daten:
    • Automatische und eindeutige Fehler, wenn die Daten ungĂŒltig sind.
    • Validierung sogar fĂŒr tief verschachtelte JSON-Objekte.
  • Konvertierung von Eingabedaten: Aus dem Netzwerk kommend, zu Python-Daten und -Typen. Lesen von:
    • JSON.
    • Pfad-Parametern.
    • Query-Parametern.
    • Cookies.
    • Headern.
    • Formularen.
    • Dateien.
  • Konvertierung von Ausgabedaten: Konvertierung von Python-Daten und -Typen zu Netzwerkdaten (als JSON):
    • Konvertieren von Python-Typen (str, int, float, bool, list, usw.).
    • datetime-Objekte.
    • UUID-Objekte.
    • Datenbankmodelle.
    • ... und viele mehr.
  • Automatische interaktive API-Dokumentation, einschließlich zwei alternativer BenutzeroberflĂ€chen:
    • Swagger UI.
    • ReDoc.

Um auf das vorherige Codebeispiel zurĂŒckzukommen, FastAPI wird:

  • Validieren, dass es eine item_id im Pfad fĂŒr GET- und PUT-Requests gibt.
  • Validieren, ob die item_id vom Typ int fĂŒr GET- und PUT-Requests ist.
    • Falls nicht, sieht der Client einen hilfreichen, klaren Fehler.
  • PrĂŒfen, ob es einen optionalen Query-Parameter namens q (wie in http://127.0.0.1:8000/items/foo?q=somequery) fĂŒr GET-Requests gibt.
    • Da der q-Parameter mit = None deklariert ist, ist er optional.
    • Ohne das None wĂ€re er erforderlich (wie der Body im Fall von PUT).
  • Bei PUT-Requests an /items/{item_id} den Body als JSON lesen:
    • PrĂŒfen, ob er ein erforderliches Attribut name hat, das ein str sein muss.
    • PrĂŒfen, ob er ein erforderliches Attribut price hat, das ein float sein muss.
    • PrĂŒfen, ob er ein optionales Attribut is_offer hat, das ein bool sein muss, falls vorhanden.
    • All dies wĂŒrde auch fĂŒr tief verschachtelte JSON-Objekte funktionieren.
  • Automatisch von und nach JSON konvertieren.
  • Alles mit OpenAPI dokumentieren, welches verwendet werden kann von:
    • Interaktiven Dokumentationssystemen.
    • Automatisch Client-Code generierenden Systemen fĂŒr viele Sprachen.
  • Zwei interaktive Dokumentations-WeboberflĂ€chen direkt bereitstellen.

Wir haben nur an der OberflÀche gekratzt, aber Sie bekommen schon eine Vorstellung davon, wie das Ganze funktioniert.

Versuchen Sie, diese Zeile zu Àndern:

    return {"item_name": item.name, "item_id": item_id}

... von:

        ... "item_name": item.name ...

... zu:

        ... "item_price": item.price ...

... und sehen Sie, wie Ihr Editor die Attribute automatisch vervollstÀndigt und ihre Typen kennt:

Editor UnterstĂŒtzung

FĂŒr ein vollstĂ€ndigeres Beispiel, mit weiteren Funktionen, siehe das Tutorial – Benutzerhandbuch.

Spoiler-Alarm: Das Tutorial – Benutzerhandbuch enthĂ€lt:

  • Deklaration von Parametern von anderen verschiedenen Stellen wie: Header, Cookies, Formularfelder und Dateien.
  • Wie man Validierungs-Constraints wie maximum_length oder regex setzt.
  • Ein sehr leistungsfĂ€higes und einfach zu bedienendes System fĂŒr Dependency Injection.
  • Sicherheit und Authentifizierung, einschließlich UnterstĂŒtzung fĂŒr OAuth2 mit JWT-Tokens und HTTP Basic Authentifizierung.
  • Fortgeschrittenere (aber ebenso einfache) Techniken zur Deklaration tief verschachtelter JSON-Modelle (dank Pydantic).
  • GraphQL-Integration mit Strawberry und anderen Bibliotheken.
  • Viele zusĂ€tzliche Features (dank Starlette) wie:
    • WebSockets
    • extrem einfache Tests auf Basis von HTTPX und pytest
    • CORS
    • Cookie-Sessions
    • ... und mehr.

Ihre App deployen (optional)

Optional können Sie Ihre FastAPI-App in die FastAPI Cloud deployen, treten Sie der Warteliste bei, falls noch nicht geschehen. 🚀

Wenn Sie bereits ein FastAPI Cloud-Konto haben (wir haben Sie von der Warteliste eingeladen 😉), können Sie Ihre Anwendung mit einem einzigen Befehl deployen.

Stellen Sie vor dem Deployen sicher, dass Sie eingeloggt sind:

$ fastapi login

You are logged in to FastAPI Cloud 🚀

Stellen Sie dann Ihre App bereit:

$ fastapi deploy

Deploying to FastAPI Cloud...

✅ Deployment successful!

🐔 Ready the chicken! Your app is ready at https://myapp.fastapicloud.dev

Das war’s! Jetzt können Sie unter dieser URL auf Ihre App zugreifen. ✹

Über FastAPI Cloud

FastAPI Cloud wird vom selben Autor und Team hinter FastAPI entwickelt.

Es vereinfacht den Prozess des Erstellens, Deployens und Zugreifens auf eine API mit minimalem Aufwand.

Es bringt die gleiche Developer-Experience beim Erstellen von Apps mit FastAPI auch zum Deployment in der Cloud. 🎉

FastAPI Cloud ist der Hauptsponsor und Finanzierer der „FastAPI and friends“ Open-Source-Projekte. ✹

Bei anderen Cloudanbietern deployen

FastAPI ist Open Source und basiert auf Standards. Sie können FastAPI-Apps bei jedem Cloudanbieter Ihrer Wahl deployen.

Folgen Sie den Anleitungen Ihres Cloudanbieters, um FastAPI-Apps dort bereitzustellen. đŸ€“

Performanz

UnabhĂ€ngige TechEmpower-Benchmarks zeigen FastAPI-Anwendungen, die unter Uvicorn laufen, als eines der schnellsten verfĂŒgbaren Python-Frameworks, nur hinter Starlette und Uvicorn selbst (intern von FastAPI verwendet). (*)

Um mehr darĂŒber zu erfahren, siehe den Abschnitt Benchmarks.

AbhÀngigkeiten

FastAPI hÀngt von Pydantic und Starlette ab.

standard-AbhÀngigkeiten

Wenn Sie FastAPI mit pip install "fastapi[standard]" installieren, kommt es mit der standard-Gruppe optionaler AbhÀngigkeiten:

Verwendet von Pydantic:

Verwendet von Starlette:

  • httpx – erforderlich, wenn Sie den TestClient verwenden möchten.
  • jinja2 – erforderlich, wenn Sie die Default-Template-Konfiguration verwenden möchten.
  • python-multipart – erforderlich, wenn Sie Formulare mittels request.form() „parsen“ möchten.

Verwendet von FastAPI:

  • uvicorn – fĂŒr den Server, der Ihre Anwendung lĂ€dt und bereitstellt. Dies umfasst uvicorn[standard], das einige AbhĂ€ngigkeiten (z. B. uvloop) beinhaltet, die fĂŒr eine Bereitstellung mit hoher Performanz benötigt werden.
  • fastapi-cli[standard] – um den fastapi-Befehl bereitzustellen.
    • Dies beinhaltet fastapi-cloud-cli, das es Ihnen ermöglicht, Ihre FastAPI-Anwendung auf FastAPI Cloud bereitzustellen.

Ohne standard-AbhÀngigkeiten

Wenn Sie die standard optionalen AbhĂ€ngigkeiten nicht einschließen möchten, können Sie mit pip install fastapi statt pip install "fastapi[standard]" installieren.

Ohne fastapi-cloud-cli

Wenn Sie FastAPI mit den StandardabhÀngigkeiten, aber ohne das fastapi-cloud-cli installieren möchten, können Sie mit pip install "fastapi[standard-no-fastapi-cloud-cli]" installieren.

ZusÀtzliche optionale AbhÀngigkeiten

Es gibt einige zusÀtzliche AbhÀngigkeiten, die Sie installieren möchten.

ZusÀtzliche optionale Pydantic-AbhÀngigkeiten:

ZusÀtzliche optionale FastAPI-AbhÀngigkeiten:

  • orjson – erforderlich, wenn Sie ORJSONResponse verwenden möchten.
  • ujson – erforderlich, wenn Sie UJSONResponse verwenden möchten.

Lizenz

Dieses Projekt ist unter den Bedingungen der MIT-Lizenz lizenziert.