25 KiB

Raw Blame History

FastAPI

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

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

{% for sponsor in sponsors.keystone -%} {% endfor -%}

Gold- und Silber-Sponsoren

{% for sponsor in sponsors.gold -%} {% endfor -%} {%- for sponsor in sponsors.silver -%} {% endfor %}

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:

Starlette für die Webanteile.
Pydantic für die Datenanteile.

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):

Alternative API-Dokumentation

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

Sie sehen die alternative automatische Dokumentation (bereitgestellt von 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:

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

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:

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:

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:

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:

email-validator – für E-Mail-Validierung.

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:

pydantic-settings – für die Verwaltung von Einstellungen.
pydantic-extra-types – für zusätzliche Typen zur Verwendung mit Pydantic.

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.

25 KiB Raw Blame History Unescape Escape