# Erste Schritte
Die einfachste FastAPI-Datei könnte wie folgt aussehen:
{* ../../docs_src/first_steps/tutorial001.py *}
Kopieren Sie das in eine Datei `main.py`.
Starten Sie den Live-Server:
```console
$ fastapi dev main.py
FastAPI Starting development server 🚀
Searching for package file structure from directories
with __init__.py files
Importing from /home/user/code/awesomeapp
module 🐍 main.py
code Importing the FastAPI app object from the module with
the following code:
from main import app
app Using import string: main:app
server Server started at http://127.0.0.1:8000
server Documentation at http://127.0.0.1:8000/docs
tip Running in development mode, for production use:
fastapi run
Logs:
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 [383138] using WatchFiles
INFO Started server process [383153]
INFO Waiting for application startup.
INFO Application startup complete.
```
In der Konsolenausgabe sollte es eine Zeile geben, die ungefähr so aussieht:
```hl_lines="4"
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```
Diese Zeile zeigt die URL, unter der Ihre App auf Ihrem lokalen Computer bereitgestellt wird.
### Überprüfen
Öffnen Sie Ihren Browser unter http://127.0.0.1:8000.
Sie werden die JSON-Response sehen:
```JSON
{"message": "Hello World"}
```
### Interaktive API-Dokumentation
Gehen Sie als Nächstes auf http://127.0.0.1:8000/docs.
Sie werden die automatisch erzeugte, interaktive API-Dokumentation sehen (bereitgestellt durch Swagger UI):
### Alternative API-Dokumentation
Gehen Sie nun auf http://127.0.0.1:8000/redoc.
Dort sehen Sie die alternative, automatische Dokumentation (bereitgestellt durch ReDoc):
### OpenAPI
**FastAPI** generiert ein „Schema“ mit all Ihren APIs unter Verwendung des **OpenAPI**-Standards zur Definition von APIs.
#### „Schema“
Ein „Schema“ ist eine Definition oder Beschreibung von etwas. Nicht der eigentliche Code, der es implementiert, sondern lediglich eine abstrakte Beschreibung.
#### API-„Schema“
In diesem Fall ist OpenAPI eine Spezifikation, die vorschreibt, wie ein Schema für Ihre API zu definieren ist.
Diese Schemadefinition enthält Ihre API-Pfade, die möglichen Parameter, welche diese entgegennehmen, usw.
#### Daten-„Schema“
Der Begriff „Schema“ kann sich auch auf die Form von Daten beziehen, wie z. B. einen JSON-Inhalt.
In diesem Fall sind die JSON-Attribute und deren Datentypen, usw. gemeint.
#### OpenAPI und JSON Schema
OpenAPI definiert ein API-Schema für Ihre API. Dieses Schema enthält Definitionen (oder „Schemas“) der Daten, die von Ihrer API unter Verwendung von **JSON Schema**, dem Standard für JSON-Datenschemata, gesendet und empfangen werden.
#### Überprüfen Sie die `openapi.json`
Falls Sie wissen möchten, wie das rohe OpenAPI-Schema aussieht: FastAPI generiert automatisch ein JSON (Schema) mit den Beschreibungen Ihrer gesamten API.
Sie können es direkt einsehen unter: http://127.0.0.1:8000/openapi.json.
Es wird ein JSON angezeigt, welches ungefähr so aussieht:
```JSON
{
"openapi": "3.1.0",
"info": {
"title": "FastAPI",
"version": "0.1.0"
},
"paths": {
"/items/": {
"get": {
"responses": {
"200": {
"description": "Successful Response",
"content": {
"application/json": {
...
```
#### Wofür OpenAPI gedacht ist
Das OpenAPI-Schema ist die Grundlage für die beiden enthaltenen interaktiven Dokumentationssysteme.
Es gibt dutzende Alternativen, die alle auf OpenAPI basieren. Sie können jede dieser Alternativen problemlos zu Ihrer mit **FastAPI** erstellten Anwendung hinzufügen.
Ebenfalls können Sie es verwenden, um automatisch Code für Clients zu generieren, die mit Ihrer API kommunizieren. Zum Beispiel für Frontend-, Mobile- oder IoT-Anwendungen.
## Zusammenfassung, Schritt für Schritt
### Schritt 1: `FastAPI` importieren
{* ../../docs_src/first_steps/tutorial001.py hl[1] *}
`FastAPI` ist eine Python-Klasse, die die gesamte Funktionalität für Ihre API bereitstellt.
/// note | Technische Details
`FastAPI` ist eine Klasse, die direkt von `Starlette` erbt.
Sie können alle Starlette-Funktionalitäten auch mit `FastAPI` nutzen.
///
### Schritt 2: Erzeugen einer `FastAPI`-„Instanz“
{* ../../docs_src/first_steps/tutorial001.py hl[3] *}
In diesem Beispiel ist die Variable `app` eine „Instanz“ der Klasse `FastAPI`.
Dies wird der Hauptinteraktionspunkt für die Erstellung all Ihrer APIs sein.
### Schritt 3: Erstellen einer *Pfadoperation*
#### Pfad
„Pfad“ bezieht sich hier auf den letzten Teil der URL, beginnend mit dem ersten `/`.
In einer URL wie:
```
https://example.com/items/foo
```
... wäre der Pfad folglich:
```
/items/foo
```
/// info
Ein „Pfad“ wird häufig auch als „Endpunkt“ oder „Route“ bezeichnet.
///
Bei der Erstellung einer API ist der „Pfad“ die wichtigste Möglichkeit zur Trennung von „Anliegen“ und „Ressourcen“.
#### Operation
„Operation“ bezieht sich hier auf eine der HTTP-„Methoden“.
Eine von diesen:
* `POST`
* `GET`
* `PUT`
* `DELETE`
... und die etwas Exotischeren:
* `OPTIONS`
* `HEAD`
* `PATCH`
* `TRACE`
Im HTTP-Protokoll können Sie mit jedem Pfad über eine (oder mehrere) dieser „Methoden“ kommunizieren.
---
Bei der Erstellung von APIs verwenden Sie normalerweise diese spezifischen HTTP-Methoden, um eine bestimmte Aktion durchzuführen.
Normalerweise verwenden Sie:
* `POST`: um Daten zu erzeugen (create).
* `GET`: um Daten zu lesen (read).
* `PUT`: um Daten zu aktualisieren (update).
* `DELETE`: um Daten zu löschen (delete).
In OpenAPI wird folglich jede dieser HTTP-Methoden als „Operation“ bezeichnet.
Wir werden sie auch „**Operationen**“ nennen.
#### Definieren eines *Pfadoperation-Dekorators*
{* ../../docs_src/first_steps/tutorial001.py hl[6] *}
Das `@app.get("/")` sagt **FastAPI**, dass die Funktion direkt darunter für die Bearbeitung von Anfragen zuständig ist, die an:
* den Pfad `/`
* unter der Verwendung der get-Operation gehen
/// info | `@decorator` Information
Diese `@something`-Syntax wird in Python „Dekorator“ genannt.
Sie platzieren ihn über einer Funktion. Wie ein hübscher, dekorativer Hut (daher kommt wohl der Begriff).
Ein „Dekorator“ nimmt die darunter stehende Funktion und macht etwas damit.
In unserem Fall teilt dieser Dekorator **FastAPI** mit, dass die folgende Funktion mit dem **Pfad** `/` und der **Operation** `get` zusammenhängt.
Dies ist der „**Pfadoperation-Dekorator**“.
///
Sie können auch die anderen Operationen verwenden:
* `@app.post()`
* `@app.put()`
* `@app.delete()`
Und die exotischeren:
* `@app.options()`
* `@app.head()`
* `@app.patch()`
* `@app.trace()`
/// tip | Tipp
Es steht Ihnen frei, jede Operation (HTTP-Methode) so zu verwenden, wie Sie es möchten.
**FastAPI** erzwingt keine bestimmte Bedeutung.
Die hier aufgeführten Informationen dienen als Leitfaden und sind nicht verbindlich.
Wenn Sie beispielsweise GraphQL verwenden, führen Sie normalerweise alle Aktionen nur mit „POST“-Operationen durch.
///
### Schritt 4: Definieren der **Pfadoperation-Funktion**
Das ist unsere „**Pfadoperation-Funktion**“:
* **Pfad**: ist `/`.
* **Operation**: ist `get`.
* **Funktion**: ist die Funktion direkt unter dem „Dekorator“ (unter `@app.get("/")`).
{* ../../docs_src/first_steps/tutorial001.py hl[7] *}
Dies ist eine Python-Funktion.
Sie wird von **FastAPI** immer dann aufgerufen, wenn sie eine Anfrage an die URL "`/`" mittels einer `GET`-Operation erhält.
In diesem Fall handelt es sich um eine `async`-Funktion.
---
Sie könnten sie auch als normale Funktion anstelle von `async def` definieren:
{* ../../docs_src/first_steps/tutorial003.py hl[7] *}
/// note | Hinweis
Wenn Sie den Unterschied nicht kennen, lesen Sie [Async: *„In Eile?“*](../async.md#in-eile){.internal-link target=_blank}.
///
### Schritt 5: den Inhalt zurückgeben
{* ../../docs_src/first_steps/tutorial001.py hl[8] *}
Sie können ein `dict`, eine `list`, einzelne Werte wie `str`, `int`, usw. zurückgeben.
Sie können auch Pydantic-Modelle zurückgeben (dazu später mehr).
Es gibt viele andere Objekte und Modelle, die automatisch zu JSON konvertiert werden (einschließlich ORMs, usw.). Versuchen Sie, Ihre Lieblingsobjekte zu verwenden. Es ist sehr wahrscheinlich, dass sie bereits unterstützt werden.
## Zusammenfassung
* Importieren Sie `FastAPI`.
* Erstellen Sie eine `app` Instanz.
* Schreiben Sie einen **Pfadoperation-Dekorator** unter Verwendung von Dekoratoren wie `@app.get("/")`.
* Definieren Sie eine **Pfadoperation-Funktion**, zum Beispiel `def root(): ...`.
* Starten Sie den Entwicklungsserver mit dem Befehl `fastapi dev`.