# FastAPI { #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](#performance).
* **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 { #sponsors }
### Keystone-Sponsor
{% 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 { #opinions }
„_[...] 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._“
---
„_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.)Kevin Glisson, Marc Vilanova, Forest Monsen –
Netflix (Ref.)
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 { #requirements }
FastAPI steht auf den Schultern von Giganten:
* Starlette für die Webanteile.
* Pydantic für die Datenanteile.
## Installation { #installation }
Erstellen und aktivieren Sie eine virtuelle Umgebung und installieren Sie dann FastAPI:
```console
$ pip install "fastapi[standard]"
---> 100%
```
**Hinweis**: Stellen Sie sicher, dass Sie `"fastapi[standard]"` in Anführungszeichen setzen, damit es in allen Terminals funktioniert.
## Beispiel { #example }
### Erstellung { #create-it }
Erstellen Sie eine Datei `main.py` mit:
```Python
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`:
```Python hl_lines="9 14"
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 { #run-it }
Starten Sie den Server mit:
```console
$ 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 { #check-it }
Öffnen Sie Ihren Browser unter http://127.0.0.1:8000/items/5?q=somequery.
Sie sehen die JSON-Response als:
```JSON
{"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 { #interactive-api-docs }
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 { #alternative-api-docs }
Und jetzt gehen Sie auf http://127.0.0.1:8000/redoc.
Sie sehen die alternative automatische Dokumentation (bereitgestellt von ReDoc):
## Beispiel Aktualisierung { #example-upgrade }
Ä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.
```Python hl_lines="4 9-12 25-27"
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 { #interactive-api-docs-upgrade }
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 { #alternative-api-docs-upgrade }
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 { #recap }
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`:
```Python
item_id: int
```
oder für ein komplexeres `Item`-Modell:
```Python
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:
```Python
return {"item_name": item.name, "item_id": item_id}
```
... von:
```Python
... "item_name": item.name ...
```
... zu:
```Python
... "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) { #deploy-your-app-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:
```console
$ fastapi login
You are logged in to FastAPI Cloud 🚀
```
Stellen Sie dann Ihre App bereit:
```console
$ 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 { #about-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 { #deploy-to-other-cloud-providers }
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 { #performance }
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 { #dependencies }
FastAPI hängt von Pydantic und Starlette ab.
### `standard`-Abhängigkeiten { #standard-dependencies }
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 { #without-standard-dependencies }
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` { #without-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 { #additional-optional-dependencies }
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 { #license }
Dieses Projekt ist unter den Bedingungen der MIT-Lizenz lizenziert.