Merge 7ade1cef74 into 6db05770f6

README.md

@@ -42,7 +42,7 @@ The key features are:
 
 <small>* estimation based on tests on an internal development team, building production applications.</small>
 
-## Sponsors
+## Sponsors { #sponsors }
 
 <!-- sponsors -->
 
@@ -69,7 +69,7 @@ The key features are:
 
 <a href="https://fastapi.tiangolo.com/fastapi-people/#sponsors" class="external-link" target="_blank">Other sponsors</a>
 
-## Opinions
+## Opinions { #opinions }
 
 "_[...] I'm using **FastAPI** a ton these days. [...] I'm actually planning to use it for all of my team's **ML services at Microsoft**. Some of them are getting integrated into the core **Windows** product and some **Office** products._"
 
@@ -115,7 +115,7 @@ The key features are:
 
 ---
 
-## **Typer**, the FastAPI of CLIs
+## **Typer**, the FastAPI of CLIs { #typer-the-fastapi-of-clis }
 
 <a href="https://typer.tiangolo.com" target="_blank"><img src="https://typer.tiangolo.com/img/logo-margin/logo-margin-vector.svg" style="width: 20%;"></a>
 
@@ -123,14 +123,14 @@ If you are building a <abbr title="Command Line Interface">CLI</abbr> app to be
 
 **Typer** is FastAPI's little sibling. And it's intended to be the **FastAPI of CLIs**. ⌨️ 🚀
 
-## Requirements
+## Requirements { #requirements }
 
 FastAPI stands on the shoulders of giants:
 
 * <a href="https://www.starlette.io/" class="external-link" target="_blank">Starlette</a> for the web parts.
 * <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> for the data parts.
 
-## Installation
+## Installation { #installation }
 
 Create and activate a <a href="https://fastapi.tiangolo.com/virtual-environments/" class="external-link" target="_blank">virtual environment</a> and then install FastAPI:
 
@@ -146,9 +146,9 @@ $ pip install "fastapi[standard]"
 
 **Note**: Make sure you put `"fastapi[standard]"` in quotes to ensure it works in all terminals.
 
-## Example
+## Example { #example }
 
-### Create it
+### Create it { #create-it }
 
 Create a file `main.py` with:
 
@@ -199,7 +199,7 @@ If you don't know, check the _"In a hurry?"_ section about <a href="https://fast
 
 </details>
 
-### Run it
+### Run it { #run-it }
 
 Run the server with:
 
@@ -241,7 +241,7 @@ You can read more about it in the <a href="https://fastapi.tiangolo.com/fastapi-
 
 </details>
 
-### Check it
+### Check it { #check-it }
 
 Open your browser at <a href="http://127.0.0.1:8000/items/5?q=somequery" class="external-link" target="_blank">http://127.0.0.1:8000/items/5?q=somequery</a>.
 
@@ -258,7 +258,7 @@ You already created an API that:
 * The _path_ `/items/{item_id}` has a _path parameter_ `item_id` that should be an `int`.
 * The _path_ `/items/{item_id}` has an optional `str` _query parameter_ `q`.
 
-### Interactive API docs
+### Interactive API docs { #interactive-api-docs }
 
 Now go to <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 
@@ -266,7 +266,7 @@ You will see the automatic interactive API documentation (provided by <a href="h
 
 ![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)
 
-### Alternative API docs
+### Alternative API docs { #alternative-api-docs }
 
 And now, go to <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
 
@@ -274,7 +274,7 @@ You will see the alternative automatic documentation (provided by <a href="https
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
 
-## Example upgrade
+## Example upgrade { #example-upgrade }
 
 Now modify the file `main.py` to receive a body from a `PUT` request.
 
@@ -312,7 +312,7 @@ def update_item(item_id: int, item: Item):
 
 The `fastapi dev` server should reload automatically.
 
-### Interactive API docs upgrade
+### Interactive API docs upgrade { #interactive-api-docs-upgrade }
 
 Now go to <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 
@@ -328,7 +328,7 @@ Now go to <a href="http://127.0.0.1:8000/docs" class="external-link" target="_bl
 
 ![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-05-swagger-04.png)
 
-### Alternative API docs upgrade
+### Alternative API docs upgrade { #alternative-api-docs-upgrade }
 
 And now, go to <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
 
@@ -336,7 +336,7 @@ And now, go to <a href="http://127.0.0.1:8000/redoc" class="external-link" targe
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)
 
-### Recap
+### Recap { #recap }
 
 In summary, you declare **once** the types of parameters, body, etc. as function parameters.
 
@@ -448,17 +448,17 @@ For a more complete example including more features, see the <a href="https://fa
     * **Cookie Sessions**
     * ...and more.
 
-## Performance
+## Performance { #performance }
 
 Independent TechEmpower benchmarks show **FastAPI** applications running under Uvicorn as <a href="https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7" class="external-link" target="_blank">one of the fastest Python frameworks available</a>, only below Starlette and Uvicorn themselves (used internally by FastAPI). (*)
 
 To understand more about it, see the section <a href="https://fastapi.tiangolo.com/benchmarks/" class="internal-link" target="_blank">Benchmarks</a>.
 
-## Dependencies
+## Dependencies { #dependencies }
 
 FastAPI depends on Pydantic and Starlette.
 
-### `standard` Dependencies
+### `standard` Dependencies { #standard-dependencies }
 
 When you install FastAPI with `pip install "fastapi[standard]"` it comes with the `standard` group of optional dependencies:
 
@@ -478,15 +478,15 @@ Used by FastAPI:
 * `fastapi-cli[standard]` - to provide the `fastapi` command.
     * This includes `fastapi-cloud-cli`, which allows you to deploy your FastAPI application to <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>.
 
-### Without `standard` Dependencies
+### Without `standard` Dependencies { #without-standard-dependencies }
 
 If you don't want to include the `standard` optional dependencies, you can install with `pip install fastapi` instead of `pip install "fastapi[standard]"`.
 
-### Without `fastapi-cloud-cli`
+### Without `fastapi-cloud-cli` { #without-fastapi-cloud-cli }
 
 If you want to install FastAPI with the standard dependencies but without the `fastapi-cloud-cli`, you can install with `pip install "fastapi[standard-no-fastapi-cloud-cli]"`.
 
-### Additional Optional Dependencies
+### Additional Optional Dependencies { #additional-optional-dependencies }
 
 There are some additional dependencies you might want to install.
 
@@ -500,6 +500,6 @@ Additional optional FastAPI dependencies:
 * <a href="https://github.com/ijl/orjson" target="_blank"><code>orjson</code></a> - Required if you want to use `ORJSONResponse`.
 * <a href="https://github.com/esnme/ultrajson" target="_blank"><code>ujson</code></a> - Required if you want to use `UJSONResponse`.
 
-## License
+## License { #license }
 
 This project is licensed under the terms of the MIT license.

docs/de/docs/_llm-test.md

@@ -0,0 +1,218 @@
+# LLM-Test { #llm-test }
+
+Dieses Dokument testet, ob das <abbr title="Large Language Model – Großes Sprachmodell">LLM</abbr> die Anweisungen im allgemeinen Prompt in `scripts/translate.py` und diejenigen im sprachspezifischen Prompt `docs/{language code}/llm-prompt.md` versteht (die an die Anweisungen im allgemeinen Prompt angehängt werden).
+
+Wie folgt verwenden:
+
+* Eine frische Übersetzung dieses Dokuments in die gewünschte Zielsprache erstellen.
+* Prüfen, ob alles größtenteils in Ordnung ist.
+* Wenn manches nicht in Ordnung ist, sich aber durch Verbesserungen am allgemeinen Prompt oder am sprachspezifischen Prompt beheben lässt, das tun.
+* Dann die verbleibenden Probleme in der Übersetzung manuell beheben, sodass es eine gute Übersetzung ist.
+* Erneut übersetzen, wobei die existierende, gute Übersetzung verwendet wird. Das ideale Ergebnis wäre, dass das LLM gar keine Änderungen vornimmt. Das würde bedeuten, dass der allgemeine Prompt und der Sprach-Prompt so gut wie möglich sind. (Plot Twist: Es wird normalerweise ein paar scheinbar zufällige Änderungen machen, der Grund ist vermutlich, dass <a href="https://doublespeak.chat/#/handbook#deterministic-output" class="external-link" target="_blank">LLMs keine deterministischen Algorithmen sind</a>).
+
+Die Idee ist, dass Sie, wenn Sie an einer Übersetzung für eine Sprache arbeiten (unter der Annahme, dass Sie `scripts/translate.py` ausführen können), hier Beispiele gefundener Sonderfälle aufnehmen (keine detaillierte Liste, nur Beispiele für solche Sonderfälle) und mit diesem Dokument testen, statt jedes andere einzelne Dokument mehrfach zu testen und zu übersetzen, was pro Übersetzung ein paar Cent kostet. Außerdem werden durch das Hinzufügen solcher Sonderfälle hier auch andere Übersetzungsprojekte auf solche Sonderfälle aufmerksam.
+
+## Codeschnipsel { #codesnippets}
+
+Dies ist ein Codeschnipsel: `foo`. Und dies ist ein weiteres Codeschnipsel: `bar`. Und noch eins: `baz quux`.
+
+## Anführungszeichen { #quotes }
+
+Gestern schrieb mein Freund: „Wenn man falsch richtig buchstabiert, hat man es falsch buchstabiert“. Worauf ich antwortete: „Richtig, aber ‚falsch‘ ist fälschlich nicht ‚„falsch“‘“.
+
+## Anführungszeichen in Codeschnipseln { #quotes-in-codesnippets}
+
+`pip install "foo[bar]"`
+
+Beispiele für Stringliterale in Codeschnipseln: `"this"`, `'that'`.
+
+Ein schwieriges Beispiel für Stringliterale in Codeschnipseln: `f"I like {'oranges' if orange else "apples"}"`
+
+Hardcore: `Yesterday my friend wrote: "If you spell incorrectly correctly you have spelled it incorrectly". To which I answered: "Correct, but 'incorrectly' is incorrectly not '"incorrectly"'!"`
+
+## Codeblöcke { #code-blocks }
+
+Ein Bash-Codebeispiel ...
+
+```bash
+# Gruß an das Universum ausgeben
+echo "Hello universe"
+```
+
+... und ein Konsolen-Codebeispiel ...
+
+```console
+$ <font color="#4E9A06">fastapi</font> run <u style="text-decoration-style:solid">main.py</u>
+<span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting server
+        Searching for package file structure
+```
+
+... und noch ein Konsolen-Codebeispiel ...
+
+```console
+// Erstellen Sie ein Verzeichnis "Code"
+$ mkdir code
+// Wechseln Sie in dieses Verzeichnis
+$ cd code
+```
+
+... und ein Python-Codebeispiel ...
+
+```Python
+wont_work()  # Das wird nicht funktionieren 😱
+works(foo="bar")  # Das funktioniert 🎉
+```
+
+... und das war’s.
+
+## Tabs und farbige Kästen { #tabs-and-colored-boxes }
+
+//// tab | Dies ist ein Tab
+
+/// info | Info
+Etwas Text
+///
+
+/// note | Hinweis
+Etwas Text
+///
+
+/// note | Technische Details
+Etwas Text
+///
+
+/// check | Testen
+Etwas Text
+///
+
+/// tip | Tipp
+Etwas Text
+///
+
+/// warning | Achtung
+Etwas Text
+///
+
+/// danger | Gefahr
+Etwas Text
+///
+
+////
+
+## Web- und interne Links { #links }
+
+[Link zur Überschrift oben](#codesnippets)
+
+<a href="https://sqlmodel.tiangolo.com/" class="external-link" target="_blank">Externer Link</a>
+
+<a href="https://fastapi.tiangolo.com/de/the/link/#target" class="external-link" target="_blank">FastAPI-Link</a>
+
+<a href="https://fastapi.tiangolo.com/css/styles.css" class="external-link" target="_blank">Link zu einem Stil</a>
+<a href="https://fastapi.tiangolo.com/js/logic.js" class="external-link" target="_blank">Link zu einem Skript</a>
+<a href="https://fastapi.tiangolo.com/img/foo.jpg" class="external-link" target="_blank">Link zu einem Bild</a>
+
+[Interner Link](foo.md#bar){.internal-link target=_blank}
+
+## Abbr-Elemente { #abbr-elements }
+
+Hier einige Dinge, die in `abbr`-Elemente gehüllt sind (einige sind erfunden): <abbr title="Getting Things Done – Dinge erledigt bekommen">GTD</abbr>, <abbr title="XML-Web-Token">XWT</abbr>, <abbr title="Paralleles Server-Gateway-Interface">PSGI</abbr>, <abbr title="Eine Gruppe von Maschinen, die so konfiguriert sind, dass sie verbunden sind und in irgendeiner Weise zusammenarbeiten.">Cluster</abbr>, <abbr title="Eine Methode des maschinellen Lernens, die künstliche neuronale Netze mit zahlreichen verdeckten Schichten zwischen Eingabe- und Ausgabeschichten verwendet und dabei eine umfassende interne Struktur entwickelt">Deep Learning</abbr>, <abbr title="Mozilla Developer Network – Mozilla-Entwicklernetzwerk: Dokumentation für Entwickler, geschrieben von den Firefox-Leuten">MDN</abbr>.
+
+## Überschriften { #headings }
+
+### Eine Webapp entwickeln – ein Tutorial { #develop-a-webapp-a-tutorial }
+
+Hallo.
+
+### Typhinweise und -annotationen { #type-hints-and-annotations }
+
+Hallo nochmal.
+
+### Super- und Subklassen { #super-and-subclasses }
+
+Hallo nochmal.
+
+## Sätze mit bevorzugten Übersetzungen (vielleicht) im Sprach-Prompt definiert { #sentences-with-preferred-translations-maybe-defined-in-the-language-prompt }
+
+Ich heiße Sie willkommen.
+Ich bewundere Ihren Pullover.
+Sie mag Obst, z. B. Äpfel
+Er mag Orangen, Bananen, usw.
+Lesen Sie die `PATH`-Umgebungsvariable.
+Was dasselbe ist wie der `PATH`.
+Installieren Sie aus der `requirements.txt`.
+Verwenden Sie den API-Router.
+Starten Sie die App.
+Erstellen Sie die Anwendung.
+Lesen Sie das Tutorial – Benutzerhandbuch.
+Lesen Sie dann das Handbuch für fortgeschrittene Benutzer.
+Dies ist der Autorisierungsheader.
+Dies ist der `Authorization`-Header.
+Warten auf den Hintergrundtask.
+Probieren Sie diesen Cloudanbieter.
+Verwenden Sie das CLI.
+Was das Kommandozeileninterface ist.
+Lesen Sie die Dokumentation.
+Der Defaultwert ist „foo“.
+Die Default-Deklaration ist „bar“.
+Die Engine wird das tun.
+Wenn die Umgebungsvariable existiert, tun Sie etwas.
+Eine Error-Response zurückgeben.
+Auf das Event warten.
+Die Exception auslösen.
+Der Exceptionhandler behandelt sie.
+Das Formularmodell definieren.
+Den Formularbody senden.
+Auf den Header zugreifen.
+Die Header ändern.
+Schreibweise in Headern.
+Auf das Lifespan-Event lauschen.
+Locking bedeutet, dass wir ein Lock setzen, um etwas sicher zu ändern.
+Eine Mobile-Anwendung entwickeln.
+Das Modellobjekt definieren.
+Etwas wartet auf das Mounten.
+Es ist jetzt gemountet.
+Ein weiteres Origin.
+Dafür haben wir eine Überschreibung.
+Die Funktion hat einen Parameter.
+Der Funktionsparameter ist ein int.
+Die Funktion hat viele Parameter.
+Der Defaultparameter ist ein bool.
+Der Body-Parameter enthält den Body des Requests.
+Auch der Requestbody-Parameter genannt.
+Der Pfad-Parameter enthält eine Variable im Requestpfad.
+Der Query-Parameter enthält die Query-Parameter im Requestpfad.
+Der Cookie-Parameter enthält die Request-Cookies.
+Der Header-Parameter enthält die Request-Header.
+Der Formular-Parameter enthält die Formularfelder des Requests.
+Die Payload ist der Request/die Response ohne Metadaten.
+Diese Query fragt nach Items, die älter als eine Woche sind.
+Zusammenfassung: Es ist smooth.
+Der Request wurde empfangen.
+Den Requestbody empfangen.
+Die Requestbodys empfangen.
+Die Response zurückgeben.
+Was eine Funktion zurückgibt, hat einen Rückgabewert.
+Und einen Rückgabetyp.
+Details sind in der SQLModel-Dokumentation beschrieben.
+Verwenden Sie das SDK.
+Der Tag `Horst` bedeutet, Horst muss es tun.
+Dieser Parameter hat eine Typannotation.
+Was ein Typhinweis ist.
+Die Wildcard ist `*`.
+Die Workerklasse macht dies und das.
+Der Workerprozess macht auch Dinge.
+Ich werde das morgen committen.
+Gestern habe ich den Code geändert.
+Lassen Sie uns unsere App bereitstellen.
+Lassen Sie uns diese Seite ausliefern.
+Aktualisieren Sie FastAPI, bevor Sie das tun.
+Dies ist in ein HTML-Tag gewrappt.
+`foo` vom Typ `int`.
+`bar` vom Typ `str`.
+`baz` vom Typ `list`.
+FastAPIs Dokumentation.
+Starlettes Performance.
+Groß-/Klein­schrei­bung ist relevant in `foo`.
+Groß-/Klein­schrei­bung ist nicht relevant in „Bar“.
+Standard-Python-Klassen.
+Dies ist deprecatet.

docs/de/docs/about/index.md

@@ -1,3 +1,3 @@
-# Über
+# Über { #about }
 
 Über FastAPI, sein Design, seine Inspiration und mehr. 🤓

docs/de/docs/advanced/additional-responses.md

@@ -1,4 +1,4 @@
-# Zusätzliche Responses in OpenAPI
+# Zusätzliche Responses in OpenAPI { #additional-responses-in-openapi }
 
 /// warning | Achtung
 
@@ -8,17 +8,17 @@ Wenn Sie mit **FastAPI** beginnen, benötigen Sie dies möglicherweise nicht.
 
 ///
 
-Sie können zusätzliche Responses mit zusätzlichen Statuscodes, Medientypen, Beschreibungen, usw. deklarieren.
+Sie können zusätzliche <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Responses</abbr> mit zusätzlichen Statuscodes, Medientypen, Beschreibungen, usw. deklarieren.
 
 Diese zusätzlichen Responses werden in das OpenAPI-Schema aufgenommen, sodass sie auch in der API-Dokumentation erscheinen.
 
 Für diese zusätzlichen Responses müssen Sie jedoch sicherstellen, dass Sie eine `Response`, wie etwa `JSONResponse`, direkt zurückgeben, mit Ihrem Statuscode und Inhalt.
 
-## Zusätzliche Response mit `model`
+## Zusätzliche Response mit `model` { #additional-response-with-model }
 
 Sie können Ihren *Pfadoperation-Dekoratoren* einen Parameter `responses` übergeben.
 
-Der nimmt ein `dict` entgegen, die Schlüssel sind Statuscodes für jede Response, wie etwa `200`, und die Werte sind andere `dict`s mit den Informationen für jede Response.
+Der nimmt ein <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">`dict`</abbr> entgegen, die Schlüssel sind Statuscodes für jede Response, wie etwa `200`, und die Werte sind andere `dict`s mit den Informationen für jede Response.
 
 Jedes dieser Response-`dict`s kann einen Schlüssel `model` haben, welcher ein Pydantic-Modell enthält, genau wie `response_model`.
 
@@ -34,7 +34,7 @@ Beachten Sie, dass Sie die `JSONResponse` direkt zurückgeben müssen.
 
 ///
 
-/// info
+/// info | Info
 
 Der `model`-Schlüssel ist nicht Teil von OpenAPI.
 
@@ -169,7 +169,7 @@ Die Schemas werden von einer anderen Stelle innerhalb des OpenAPI-Schemas refere
 }
 ```
 
-## Zusätzliche Medientypen für die Haupt-Response
+## Zusätzliche Medientypen für die Haupt-Response { #additional-media-types-for-the-main-response }
 
 Sie können denselben `responses`-Parameter verwenden, um verschiedene Medientypen für dieselbe Haupt-Response hinzuzufügen.
 
@@ -183,7 +183,7 @@ Beachten Sie, dass Sie das Bild direkt mit einer `FileResponse` zurückgeben mü
 
 ///
 
-/// info
+/// info | Info
 
 Sofern Sie in Ihrem Parameter `responses` nicht explizit einen anderen Medientyp angeben, geht FastAPI davon aus, dass die Response denselben Medientyp wie die Haupt-Response-Klasse hat (Standardmäßig `application/json`).
 
@@ -191,7 +191,7 @@ Wenn Sie jedoch eine benutzerdefinierte Response-Klasse mit `None` als Medientyp
 
 ///
 
-## Informationen kombinieren
+## Informationen kombinieren { #combining-information }
 
 Sie können auch Response-Informationen von mehreren Stellen kombinieren, einschließlich der Parameter `response_model`, `status_code` und `responses`.
 
@@ -209,7 +209,7 @@ Es wird alles kombiniert und in Ihre OpenAPI eingebunden und in der API-Dokument
 
 <img src="/img/tutorial/additional-responses/image01.png">
 
-## Vordefinierte und benutzerdefinierte Responses kombinieren
+## Vordefinierte und benutzerdefinierte Responses kombinieren { #combine-predefined-responses-and-custom-ones }
 
 Möglicherweise möchten Sie einige vordefinierte Responses haben, die für viele *Pfadoperationen* gelten, Sie möchten diese jedoch mit benutzerdefinierten Responses kombinieren, die für jede *Pfadoperation* erforderlich sind.
 
@@ -239,9 +239,9 @@ Zum Beispiel:
 
 {* ../../docs_src/additional_responses/tutorial004.py hl[13:17,26] *}
 
-## Weitere Informationen zu OpenAPI-Responses
+## Weitere Informationen zu OpenAPI-Responses { #more-information-about-openapi-responses }
 
 Um zu sehen, was genau Sie in die Responses aufnehmen können, können Sie die folgenden Abschnitte in der OpenAPI-Spezifikation überprüfen:
 
-* <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responsesObject" class="external-link" target="_blank">OpenAPI Responses Object</a>, enthält das `Response Object`.
-* <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responseObject" class="external-link" target="_blank">OpenAPI Response Object</a>, Sie können alles davon direkt in jede Response innerhalb Ihres `responses`-Parameter einfügen. Einschließlich `description`, `headers`, `content` (darin deklarieren Sie verschiedene Medientypen und JSON-Schemas) und `links`.
+* <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responses-object" class="external-link" target="_blank">OpenAPI Responses Object</a>, enthält das `Response Object`.
+* <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#response-object" class="external-link" target="_blank">OpenAPI Response Object</a>, Sie können alles davon direkt in jede Response innerhalb Ihres `responses`-Parameter einfügen. Einschließlich `description`, `headers`, `content` (darin deklarieren Sie verschiedene Medientypen und JSON-Schemas) und `links`.

docs/de/docs/advanced/additional-status-codes.md

@@ -1,16 +1,16 @@
-# Zusätzliche Statuscodes
+# Zusätzliche Statuscodes { #additional-status-codes }
 
-Standardmäßig liefert **FastAPI** die Rückgabewerte (Responses) als `JSONResponse` zurück und fügt den Inhalt der jeweiligen *Pfadoperation* in das `JSONResponse` Objekt ein.
+Standardmäßig liefert **FastAPI** die <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Responses</abbr> als `JSONResponse` zurück und fügt den Inhalt, den Sie aus Ihrer *Pfadoperation* zurückgeben, in diese `JSONResponse` ein.
 
 Es wird der Default-Statuscode oder derjenige verwendet, den Sie in Ihrer *Pfadoperation* festgelegt haben.
 
-## Zusätzliche Statuscodes
+## Zusätzliche Statuscodes { #additional-status-codes_1 }
 
 Wenn Sie neben dem Hauptstatuscode weitere Statuscodes zurückgeben möchten, können Sie dies tun, indem Sie direkt eine `Response` zurückgeben, wie etwa eine `JSONResponse`, und den zusätzlichen Statuscode direkt festlegen.
 
 Angenommen, Sie möchten eine *Pfadoperation* haben, die das Aktualisieren von Artikeln ermöglicht und bei Erfolg den HTTP-Statuscode 200 „OK“ zurückgibt.
 
-Sie möchten aber auch, dass sie neue Artikel akzeptiert. Und wenn die Elemente vorher nicht vorhanden waren, werden diese Elemente erstellt und der HTTP-Statuscode 201 „Created“ zurückgegeben.
+Sie möchten aber auch, dass sie neue Artikel akzeptiert. Und wenn die Artikel vorher nicht vorhanden waren, werden diese Artikel erstellt und der HTTP-Statuscode 201 „Created“ zurückgegeben.
 
 Um dies zu erreichen, importieren Sie `JSONResponse`, und geben Sie Ihren Inhalt direkt zurück, indem Sie den gewünschten `status_code` setzen:
 
@@ -30,11 +30,11 @@ Stellen Sie sicher, dass sie die gewünschten Daten enthält und dass die Werte
 
 Sie können auch `from starlette.responses import JSONResponse` verwenden.
 
-**FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, als Annehmlichkeit für Sie, den Entwickler. Die meisten verfügbaren Responses kommen aber direkt von Starlette. Das Gleiche gilt für `status`.
+**FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, als Annehmlichkeit für Sie, den Entwickler. Die meisten verfügbaren Responses kommen aber direkt von Starlette. Dasselbe gilt für `status`.
 
 ///
 
-## OpenAPI- und API-Dokumentation
+## OpenAPI- und API-Dokumentation { #openapi-and-api-docs }
 
 Wenn Sie zusätzliche Statuscodes und Responses direkt zurückgeben, werden diese nicht in das OpenAPI-Schema (die API-Dokumentation) aufgenommen, da FastAPI keine Möglichkeit hat, im Voraus zu wissen, was Sie zurückgeben werden.
 

docs/de/docs/advanced/advanced-dependencies.md

@@ -1,6 +1,6 @@
-# Fortgeschrittene Abhängigkeiten
+# Fortgeschrittene Abhängigkeiten { #advanced-dependencies }
 
-## Parametrisierte Abhängigkeiten
+## Parametrisierte Abhängigkeiten { #parameterized-dependencies }
 
 Alle Abhängigkeiten, die wir bisher gesehen haben, waren festgelegte Funktionen oder Klassen.
 
@@ -10,7 +10,7 @@ Stellen wir uns vor, wir möchten eine Abhängigkeit haben, die prüft, ob ein Q
 
 Aber wir wollen diesen vordefinierten Inhalt per Parameter festlegen können.
 
-## Eine „aufrufbare“ Instanz
+## Eine „aufrufbare“ Instanz { #a-callable-instance }
 
 In Python gibt es eine Möglichkeit, eine Instanz einer Klasse „aufrufbar“ („callable“) zu machen.
 
@@ -22,7 +22,7 @@ Dazu deklarieren wir eine Methode `__call__`:
 
 In diesem Fall ist dieses `__call__` das, was **FastAPI** verwendet, um nach zusätzlichen Parametern und Unterabhängigkeiten zu suchen, und das ist es auch, was später aufgerufen wird, um einen Wert an den Parameter in Ihrer *Pfadoperation-Funktion* zu übergeben.
 
-## Die Instanz parametrisieren
+## Die Instanz parametrisieren { #parameterize-the-instance }
 
 Und jetzt können wir `__init__` verwenden, um die Parameter der Instanz zu deklarieren, die wir zum `Parametrisieren` der Abhängigkeit verwenden können:
 
@@ -30,7 +30,7 @@ Und jetzt können wir `__init__` verwenden, um die Parameter der Instanz zu dekl
 
 In diesem Fall wird **FastAPI** `__init__` nie berühren oder sich darum kümmern, wir werden es direkt in unserem Code verwenden.
 
-## Eine Instanz erstellen
+## Eine Instanz erstellen { #create-an-instance }
 
 Wir könnten eine Instanz dieser Klasse erstellen mit:
 
@@ -38,7 +38,7 @@ Wir könnten eine Instanz dieser Klasse erstellen mit:
 
 Und auf diese Weise können wir unsere Abhängigkeit „parametrisieren“, die jetzt `"bar"` enthält, als das Attribut `checker.fixed_content`.
 
-## Die Instanz als Abhängigkeit verwenden
+## Die Instanz als Abhängigkeit verwenden { #use-the-instance-as-a-dependency }
 
 Dann könnten wir diesen `checker` in einem `Depends(checker)` anstelle von `Depends(FixedContentQueryChecker)` verwenden, da die Abhängigkeit die Instanz `checker` und nicht die Klasse selbst ist.
 

docs/de/docs/advanced/async-tests.md

@@ -1,24 +1,24 @@
-# Asynchrone Tests
+# Asynchrone Tests { #async-tests }
 
-Sie haben bereits gesehen, wie Sie Ihre **FastAPI**-Anwendungen mit dem bereitgestellten `TestClient` testen. Bisher haben Sie nur gesehen, wie man synchrone Tests schreibt, ohne `async`hrone Funktionen zu verwenden.
+Sie haben bereits gesehen, wie Sie Ihre **FastAPI**-Anwendungen mit dem bereitgestellten `TestClient` testen. Bisher haben Sie nur gesehen, wie man synchrone Tests schreibt, ohne `async`-Funktionen zu verwenden.
 
-Die Möglichkeit, in Ihren Tests asynchrone Funktionen zu verwenden, könnte beispielsweise nützlich sein, wenn Sie Ihre Datenbank asynchron abfragen. Stellen Sie sich vor, Sie möchten das Senden von Requests an Ihre FastAPI-Anwendung testen und dann überprüfen, ob Ihr Backend die richtigen Daten erfolgreich in die Datenbank geschrieben hat, während Sie eine asynchrone Datenbankbibliothek verwenden.
+Die Möglichkeit, in Ihren Tests asynchrone Funktionen zu verwenden, könnte beispielsweise nützlich sein, wenn Sie Ihre Datenbank asynchron abfragen. Stellen Sie sich vor, Sie möchten das Senden von <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Requests</abbr> an Ihre FastAPI-Anwendung testen und dann überprüfen, ob Ihr Backend die richtigen Daten erfolgreich in die Datenbank geschrieben hat, während Sie eine asynchrone Datenbankbibliothek verwenden.
 
 Schauen wir uns an, wie wir das machen können.
 
-## pytest.mark.anyio
+## pytest.mark.anyio { #pytest-mark-anyio }
 
 Wenn wir in unseren Tests asynchrone Funktionen aufrufen möchten, müssen unsere Testfunktionen asynchron sein. AnyIO stellt hierfür ein nettes Plugin zur Verfügung, mit dem wir festlegen können, dass einige Testfunktionen asynchron aufgerufen werden sollen.
 
-## HTTPX
+## HTTPX { #httpx }
 
-Auch wenn Ihre **FastAPI**-Anwendung normale `def`-Funktionen anstelle von `async def` verwendet, handelt es sich darunter immer noch um eine `async`hrone Anwendung.
+Auch wenn Ihre **FastAPI**-Anwendung normale `def`-Funktionen anstelle von `async def` verwendet, handelt es sich darunter immer noch um eine `async`-Anwendung.
 
-Der `TestClient` macht unter der Haube magisches, um die asynchrone FastAPI-Anwendung in Ihren normalen `def`-Testfunktionen, mithilfe von Standard-Pytest aufzurufen. Aber diese Magie funktioniert nicht mehr, wenn wir sie in asynchronen Funktionen verwenden. Durch die asynchrone Ausführung unserer Tests können wir den `TestClient` nicht mehr in unseren Testfunktionen verwenden.
+Der `TestClient` betreibt unter der Haube etwas Magie, um die asynchrone FastAPI-Anwendung in Ihren normalen `def`-Testfunktionen, mithilfe von Standard-Pytest aufzurufen. Aber diese Magie funktioniert nicht mehr, wenn wir sie in asynchronen Funktionen verwenden. Durch die asynchrone Ausführung unserer Tests können wir den `TestClient` nicht mehr in unseren Testfunktionen verwenden.
 
-Der `TestClient` basiert auf <a href="https://www.python-httpx.org" class="external-link" target="_blank">HTTPX</a> und glücklicherweise können wir ihn direkt verwenden, um die API zu testen.
+Der `TestClient` basiert auf <a href="https://www.python-httpx.org" class="external-link" target="_blank">HTTPX</a> und glücklicherweise können wir es direkt verwenden, um die API zu testen.
 
-## Beispiel
+## Beispiel { #example }
 
 Betrachten wir als einfaches Beispiel eine Dateistruktur ähnlich der in [Größere Anwendungen](../tutorial/bigger-applications.md){.internal-link target=_blank} und [Testen](../tutorial/testing.md){.internal-link target=_blank}:
 
@@ -38,7 +38,7 @@ Die Datei `test_main.py` hätte die Tests für `main.py`, das könnte jetzt so a
 
 {* ../../docs_src/async_tests/test_main.py *}
 
-## Es ausführen
+## Es ausführen { #run-it }
 
 Sie können Ihre Tests wie gewohnt ausführen mit:
 
@@ -52,7 +52,7 @@ $ pytest
 
 </div>
 
-## Details
+## Im Detail { #in-detail }
 
 Der Marker `@pytest.mark.anyio` teilt pytest mit, dass diese Testfunktion asynchron aufgerufen werden soll:
 
@@ -88,9 +88,9 @@ Falls Ihre Anwendung auf Lifespan-Events angewiesen ist, der `AsyncClient` löst
 
 ///
 
-## Andere asynchrone Funktionsaufrufe
+## Andere asynchrone Funktionsaufrufe { #other-asynchronous-function-calls }
 
-Da die Testfunktion jetzt asynchron ist, können Sie in Ihren Tests neben dem Senden von Requests an Ihre FastAPI-Anwendung jetzt auch andere `async`hrone Funktionen aufrufen (und `await`en), genau so, wie Sie diese an anderer Stelle in Ihrem Code aufrufen würden.
+Da die Testfunktion jetzt asynchron ist, können Sie in Ihren Tests neben dem Senden von Requests an Ihre FastAPI-Anwendung jetzt auch andere `async`-Funktionen aufrufen (und `await`en), genau so, wie Sie diese an anderer Stelle in Ihrem Code aufrufen würden.
 
 /// tip | Tipp
 

docs/de/docs/advanced/behind-a-proxy.md

@@ -1,16 +1,16 @@
-# Hinter einem Proxy
+# Hinter einem Proxy { #behind-a-proxy }
 
 In manchen Situationen müssen Sie möglicherweise einen **Proxy**-Server wie Traefik oder Nginx verwenden, mit einer Konfiguration, die ein zusätzliches Pfadpräfix hinzufügt, das von Ihrer Anwendung nicht gesehen wird.
 
-In diesen Fällen können Sie `root_path` verwenden, um Ihre Anwendung zu konfigurieren.
+In diesen Fällen können Sie <abbr title="Wurzelpfad">`root_path`</abbr> verwenden, um Ihre Anwendung zu konfigurieren.
 
-Der `root_path` („Wurzelpfad“) ist ein Mechanismus, der von der ASGI-Spezifikation bereitgestellt wird (auf der FastAPI via Starlette aufbaut).
+Der `root_path` ist ein Mechanismus, der von der ASGI-Spezifikation bereitgestellt wird (auf der FastAPI via Starlette aufbaut).
 
 Der `root_path` wird verwendet, um diese speziellen Fälle zu handhaben.
 
 Und er wird auch intern beim Mounten von Unteranwendungen verwendet.
 
-## Proxy mit einem abgetrennten Pfadpräfix
+## Proxy mit einem abgetrennten Pfadpräfix { #proxy-with-a-stripped-path-prefix }
 
 Ein Proxy mit einem abgetrennten Pfadpräfix bedeutet in diesem Fall, dass Sie einen Pfad unter `/app` in Ihrem Code deklarieren könnten, dann aber, eine Ebene darüber, den Proxy hinzufügen, der Ihre **FastAPI**-Anwendung unter einem Pfad wie `/api/v1` platziert.
 
@@ -20,13 +20,13 @@ Auch wenn Ihr gesamter Code unter der Annahme geschrieben ist, dass es nur `/app
 
 {* ../../docs_src/behind_a_proxy/tutorial001.py hl[6] *}
 
-Und der Proxy würde das **Pfadpräfix** on-the-fly **"entfernen**", bevor er die Anfrage an Uvicorn übermittelt, dafür sorgend, dass Ihre Anwendung davon überzeugt ist, dass sie unter `/app` bereitgestellt wird, sodass Sie nicht Ihren gesamten Code dahingehend aktualisieren müssen, das Präfix `/api/v1` zu verwenden.
+Und der Proxy würde das **Pfadpräfix** on-the-fly **„entfernen“**, bevor er den <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> an den Anwendungsserver (wahrscheinlich Uvicorn via FastAPI CLI) übermittelt, dafür sorgend, dass Ihre Anwendung davon überzeugt ist, dass sie unter `/app` bereitgestellt wird, sodass Sie nicht Ihren gesamten Code dahingehend aktualisieren müssen, das Präfix `/api/v1` zu verwenden.
 
 Bis hierher würde alles wie gewohnt funktionieren.
 
 Wenn Sie dann jedoch die Benutzeroberfläche der integrierten Dokumentation (das Frontend) öffnen, wird angenommen, dass sich das OpenAPI-Schema unter `/openapi.json` anstelle von `/api/v1/openapi.json` befindet.
 
-Das Frontend (das im Browser läuft) würde also versuchen, `/openapi.json` zu erreichen und wäre nicht in der Lage, das OpenAPI-Schema abzurufen.
+Also würde das Frontend (das im Browser läuft) versuchen, `/openapi.json` zu erreichen und wäre nicht in der Lage, das OpenAPI-Schema abzurufen.
 
 Da wir für unsere Anwendung einen Proxy mit dem Pfadpräfix `/api/v1` haben, muss das Frontend das OpenAPI-Schema unter `/api/v1/openapi.json` abrufen.
 
@@ -64,16 +64,16 @@ Die Benutzeroberfläche der Dokumentation würde benötigen, dass das OpenAPI-Sc
 }
 ```
 
-In diesem Beispiel könnte der „Proxy“ etwa **Traefik** sein. Und der Server wäre so etwas wie **Uvicorn**, auf dem Ihre FastAPI-Anwendung ausgeführt wird.
+In diesem Beispiel könnte der „Proxy“ etwa **Traefik** sein. Und der Server wäre etwas wie FastAPI CLI mit **Uvicorn**, auf dem Ihre FastAPI-Anwendung ausgeführt wird.
 
-### Bereitstellung des `root_path`
+### Bereitstellung des `root_path` { #providing-the-root-path }
 
 Um dies zu erreichen, können Sie die Kommandozeilenoption `--root-path` wie folgt verwenden:
 
 <div class="termy">
 
 ```console
-$ uvicorn main:app --root-path /api/v1
+$ fastapi run main.py --root-path /api/v1
 
 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -90,9 +90,9 @@ Und die Kommandozeilenoption `--root-path` stellt diesen `root_path` bereit.
 
 ///
 
-### Überprüfen des aktuellen `root_path`
+### Testen des aktuellen `root_path` { #checking-the-current-root-path }
 
-Sie können den aktuellen `root_path` abrufen, der von Ihrer Anwendung für jede Anfrage verwendet wird. Er ist Teil des `scope`-Dictionarys (das ist Teil der ASGI-Spezifikation).
+Sie können den aktuellen `root_path` abrufen, der von Ihrer Anwendung für jeden Request verwendet wird. Er ist Teil des `scope`-<abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">Dictionarys</abbr> (das ist Teil der ASGI-Spezifikation).
 
 Hier fügen wir ihn, nur zu Demonstrationszwecken, in die Nachricht ein.
 
@@ -103,14 +103,14 @@ Wenn Sie Uvicorn dann starten mit:
 <div class="termy">
 
 ```console
-$ uvicorn main:app --root-path /api/v1
+$ fastapi run main.py --root-path /api/v1
 
 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
 
 </div>
 
-wäre die Response etwa:
+wäre die <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> etwa:
 
 ```JSON
 {
@@ -119,19 +119,19 @@ wäre die Response etwa:
 }
 ```
 
-### Festlegen des `root_path` in der FastAPI-Anwendung
+### Festlegen des `root_path` in der FastAPI-Anwendung { #setting-the-root-path-in-the-fastapi-app }
 
-Falls Sie keine Möglichkeit haben, eine Kommandozeilenoption wie `--root-path` oder ähnlich zu übergeben, können Sie als Alternative beim Erstellen Ihrer FastAPI-Anwendung den Parameter `root_path` setzen:
+Falls Sie keine Möglichkeit haben, eine Kommandozeilenoption wie `--root-path` oder ähnlich zu übergeben, können Sie, alternativ dazu, beim Erstellen Ihrer FastAPI-Anwendung den Parameter `root_path` setzen:
 
 {* ../../docs_src/behind_a_proxy/tutorial002.py hl[3] *}
 
 Die Übergabe des `root_path` an `FastAPI` wäre das Äquivalent zur Übergabe der `--root-path`-Kommandozeilenoption an Uvicorn oder Hypercorn.
 
-### Über `root_path`
+### Über `root_path` { #about-root-path }
 
-Beachten Sie, dass der Server (Uvicorn) diesen `root_path` für nichts anderes außer die Weitergabe an die Anwendung verwendet.
+Beachten Sie, dass der Server (Uvicorn) diesen `root_path` für nichts anderes verwendet als für die Weitergabe an die Anwendung.
 
-Aber wenn Sie mit Ihrem Browser auf <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000/app</a> gehen, sehen Sie die normale Antwort:
+Aber wenn Sie mit Ihrem Browser auf <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000/app</a> gehen, sehen Sie die normale Response:
 
 ```JSON
 {
@@ -144,17 +144,17 @@ Es wird also nicht erwartet, dass unter `http://127.0.0.1:8000/api/v1/app` darau
 
 Uvicorn erwartet, dass der Proxy unter `http://127.0.0.1:8000/app` auf Uvicorn zugreift, und dann liegt es in der Verantwortung des Proxys, das zusätzliche `/api/v1`-Präfix darüber hinzuzufügen.
 
-## Über Proxys mit einem abgetrennten Pfadpräfix
+## Über Proxys mit einem abgetrennten Pfadpräfix { #about-proxies-with-a-stripped-path-prefix }
 
-Bedenken Sie, dass ein Proxy mit abgetrennten Pfadpräfix nur eine von vielen Konfigurationsmöglichkeiten ist.
+Bedenken Sie, dass ein Proxy mit abgetrenntem Pfadpräfix nur eine von vielen Konfigurationsmöglichkeiten ist.
 
 Wahrscheinlich wird in vielen Fällen die Standardeinstellung sein, dass der Proxy kein abgetrenntes Pfadpräfix hat.
 
-In einem solchen Fall (ohne ein abgetrenntes Pfadpräfix) würde der Proxy auf etwas wie `https://myawesomeapp.com` lauschen, und wenn der Browser dann zu `https://myawesomeapp.com/api/v1/` wechselt, und Ihr Server (z. B. Uvicorn) auf `http://127.0.0.1:8000` lauscht, würde der Proxy (ohne ein abgetrenntes Pfadpräfix) über denselben Pfad auf Uvicorn zugreifen: `http://127.0.0.1:8000/api/v1/app`.
+In einem solchen Fall (ohne ein abgetrenntes Pfadpräfix) würde der Proxy auf etwas wie `https://myawesomeapp.com` lauschen, und wenn der Browser dann zu `https://myawesomeapp.com/api/v1/app` wechselt, und Ihr Server (z. B. Uvicorn) auf `http://127.0.0.1:8000` lauscht, würde der Proxy (ohne ein abgetrenntes Pfadpräfix) über denselben Pfad auf Uvicorn zugreifen: `http://127.0.0.1:8000/api/v1/app`.
 
-## Lokal testen mit Traefik
+## Lokal testen mit Traefik { #testing-locally-with-traefik }
 
-Sie können das Experiment mit einem abgetrennten Pfadpräfix ganz einfach lokal ausführen, indem Sie <a href="https://docs.traefik.io/" class="external-link" target="_blank">Traefik</a> verwenden.
+Sie können das Experiment mit einem abgetrennten Pfadpräfix einfach lokal ausführen, indem Sie <a href="https://docs.traefik.io/" class="external-link" target="_blank">Traefik</a> verwenden.
 
 <a href="https://github.com/containous/traefik/releases" class="external-link" target="_blank">Laden Sie Traefik herunter</a>, es ist eine einzelne Binärdatei, Sie können die komprimierte Datei extrahieren und sie direkt vom Terminal aus ausführen.
 
@@ -205,7 +205,7 @@ Erstellen Sie nun die andere Datei `routes.toml`:
 
 Diese Datei konfiguriert Traefik, das Pfadpräfix `/api/v1` zu verwenden.
 
-Und dann leitet Traefik seine Anfragen an Ihren Uvicorn weiter, der unter `http://127.0.0.1:8000` läuft.
+Und dann leitet Traefik seine Requests an Ihren Uvicorn weiter, der unter `http://127.0.0.1:8000` läuft.
 
 Starten Sie nun Traefik:
 
@@ -224,14 +224,14 @@ Und jetzt starten Sie Ihre Anwendung mit Uvicorn, indem Sie die Option `--root-p
 <div class="termy">
 
 ```console
-$ uvicorn main:app --root-path /api/v1
+$ fastapi run main.py --root-path /api/v1
 
 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
 
 </div>
 
-### Die Responses betrachten
+### Die Responses testen { #check-the-responses }
 
 Wenn Sie nun zur URL mit dem Port für Uvicorn gehen: <a href="http://127.0.0.1:8000/app" class="external-link" target="_blank">http://127.0.0.1:8000/app</a>, sehen Sie die normale Response:
 
@@ -267,7 +267,7 @@ Und die von Uvicorn direkt bereitgestellte Version ohne Pfadpräfix (`http://127
 
 Dies demonstriert, wie der Proxy (Traefik) das Pfadpräfix verwendet und wie der Server (Uvicorn) den `root_path` aus der Option `--root-path` verwendet.
 
-### Es in der Dokumentationsoberfläche betrachten
+### Es in der Dokumentationsoberfläche testen { #check-the-docs-ui }
 
 Jetzt folgt der spaßige Teil. ✨
 
@@ -287,7 +287,7 @@ Genau so, wie wir es wollten. ✔️
 
 Dies liegt daran, dass FastAPI diesen `root_path` verwendet, um den Default-`server` in OpenAPI mit der von `root_path` bereitgestellten URL zu erstellen.
 
-## Zusätzliche Server
+## Zusätzliche Server { #additional-servers }
 
 /// warning | Achtung
 
@@ -297,7 +297,7 @@ Dies ist ein fortgeschrittener Anwendungsfall. Überspringen Sie das gerne.
 
 Standardmäßig erstellt **FastAPI** einen `server` im OpenAPI-Schema mit der URL für den `root_path`.
 
-Sie können aber auch andere alternative `server` bereitstellen, beispielsweise wenn Sie möchten, dass *dieselbe* Dokumentationsoberfläche mit einer Staging- und Produktionsumgebung interagiert.
+Sie können aber auch andere alternative `servers` bereitstellen, beispielsweise wenn Sie möchten, dass *dieselbe* Dokumentationsoberfläche mit einer Staging- und Produktionsumgebung interagiert.
 
 Wenn Sie eine benutzerdefinierte Liste von Servern (`servers`) übergeben und es einen `root_path` gibt (da Ihre API hinter einem Proxy läuft), fügt **FastAPI** einen „Server“ mit diesem `root_path` am Anfang der Liste ein.
 
@@ -346,7 +346,7 @@ Die Dokumentationsoberfläche interagiert mit dem von Ihnen ausgewählten Server
 
 ///
 
-### Den automatischen Server von `root_path` deaktivieren
+### Den automatischen Server von `root_path` deaktivieren { #disable-automatic-server-from-root-path }
 
 Wenn Sie nicht möchten, dass **FastAPI** einen automatischen Server inkludiert, welcher `root_path` verwendet, können Sie den Parameter `root_path_in_servers=False` verwenden:
 
@@ -354,7 +354,7 @@ Wenn Sie nicht möchten, dass **FastAPI** einen automatischen Server inkludiert,
 
 Dann wird er nicht in das OpenAPI-Schema aufgenommen.
 
-## Mounten einer Unteranwendung
+## Mounten einer Unteranwendung { #mounting-a-sub-application }
 
 Wenn Sie gleichzeitig eine Unteranwendung mounten (wie beschrieben in [Unteranwendungen – Mounts](sub-applications.md){.internal-link target=_blank}) und einen Proxy mit `root_path` verwenden wollen, können Sie das normal tun, wie Sie es erwarten würden.
 

docs/de/docs/advanced/custom-response.md

@@ -1,12 +1,12 @@
-# Benutzerdefinierte Response – HTML, Stream, Datei, andere
+# Benutzerdefinierte Response – HTML, Stream, Datei, andere { #custom-response-html-stream-file-others }
 
-Standardmäßig gibt **FastAPI** die Responses mittels `JSONResponse` zurück.
+Standardmäßig gibt **FastAPI** die <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Responses</abbr> mittels `JSONResponse` zurück.
 
-Sie können das überschreiben, indem Sie direkt eine `Response` zurückgeben, wie in [Eine Response direkt zurückgeben](response-directly.md){.internal-link target=_blank} gezeigt.
+Sie können dies überschreiben, indem Sie direkt eine `Response` zurückgeben, wie in [Eine Response direkt zurückgeben](response-directly.md){.internal-link target=_blank} gezeigt.
 
-Wenn Sie jedoch direkt eine `Response` zurückgeben, werden die Daten nicht automatisch konvertiert und die Dokumentation wird nicht automatisch generiert (zum Beispiel wird der spezifische „Medientyp“, der im HTTP-Header `Content-Type` angegeben ist, nicht Teil der generierten OpenAPI).
+Wenn Sie jedoch direkt eine `Response` (oder eine Unterklasse wie `JSONResponse`) zurückgeben, werden die Daten nicht automatisch konvertiert (selbst wenn Sie ein `response_model` deklariert haben), und die Dokumentation wird nicht automatisch generiert (zum Beispiel wird der spezifische „Medientyp“, der im HTTP-Header `Content-Type` angegeben ist, nicht Teil der generierten OpenAPI).
 
-Sie können aber auch die `Response`, die Sie verwenden möchten, im *Pfadoperation-Dekorator* deklarieren.
+Sie können jedoch auch die `Response`, die Sie verwenden möchten (z. B. jede `Response`-Unterklasse), im *Pfadoperation-Dekorator* mit dem `response_class`-Parameter deklarieren.
 
 Der Inhalt, den Sie von Ihrer *Pfadoperation-Funktion* zurückgeben, wird in diese `Response` eingefügt.
 
@@ -18,13 +18,13 @@ Wenn Sie eine Response-Klasse ohne Medientyp verwenden, erwartet FastAPI, dass I
 
 ///
 
-## `ORJSONResponse` verwenden
+## `ORJSONResponse` verwenden { #use-orjsonresponse }
 
-Um beispielsweise noch etwas Leistung herauszuholen, können Sie <a href="https://github.com/ijl/orjson" class="external-link" target="_blank">`orjson`</a> installieren und verwenden, und die Response als `ORJSONResponse` deklarieren.
+Um beispielsweise noch etwas Leistung herauszuholen, können Sie <a href="https://github.com/ijl/orjson" class="external-link" target="_blank">`orjson`</a> installieren und die Response als `ORJSONResponse` setzen.
 
-Importieren Sie die `Response`-Klasse (-Unterklasse), die Sie verwenden möchten, und deklarieren Sie sie im *Pfadoperation-Dekorator*.
+Importieren Sie die `Response`-Klasse (Unterklasse), die Sie verwenden möchten, und deklarieren Sie sie im *Pfadoperation-Dekorator*.
 
-Bei umfangreichen Responses ist die direkte Rückgabe einer `Response` viel schneller als ein Dictionary zurückzugeben.
+Bei umfangreichen Responses ist die direkte Rückgabe einer `Response` wesentlich schneller als ein <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">Dictionary</abbr> zurückzugeben.
 
 Das liegt daran, dass FastAPI standardmäßig jedes enthaltene Element überprüft und sicherstellt, dass es als JSON serialisierbar ist, und zwar unter Verwendung desselben [JSON-kompatiblen Encoders](../tutorial/encoder.md){.internal-link target=_blank}, der im Tutorial erläutert wurde. Dadurch können Sie **beliebige Objekte** zurückgeben, zum Beispiel Datenbankmodelle.
 
@@ -32,7 +32,7 @@ Wenn Sie jedoch sicher sind, dass der von Ihnen zurückgegebene Inhalt **mit JSO
 
 {* ../../docs_src/custom_response/tutorial001b.py hl[2,7] *}
 
-/// info
+/// info | Info
 
 Der Parameter `response_class` wird auch verwendet, um den „Medientyp“ der Response zu definieren.
 
@@ -44,11 +44,11 @@ Und er wird als solcher in OpenAPI dokumentiert.
 
 /// tip | Tipp
 
-Die `ORJSONResponse` ist derzeit nur in FastAPI verfügbar, nicht in Starlette.
+Die `ORJSONResponse` ist nur in FastAPI verfügbar, nicht in Starlette.
 
 ///
 
-## HTML-Response
+## HTML-Response { #html-response }
 
 Um eine Response mit HTML direkt von **FastAPI** zurückzugeben, verwenden Sie `HTMLResponse`.
 
@@ -57,7 +57,7 @@ Um eine Response mit HTML direkt von **FastAPI** zurückzugeben, verwenden Sie `
 
 {* ../../docs_src/custom_response/tutorial002.py hl[2,7] *}
 
-/// info
+/// info | Info
 
 Der Parameter `response_class` wird auch verwendet, um den „Medientyp“ der Response zu definieren.
 
@@ -67,7 +67,7 @@ Und er wird als solcher in OpenAPI dokumentiert.
 
 ///
 
-### Eine `Response` zurückgeben
+### Eine `Response` zurückgeben { #return-a-response }
 
 Wie in [Eine Response direkt zurückgeben](response-directly.md){.internal-link target=_blank} gezeigt, können Sie die Response auch direkt in Ihrer *Pfadoperation* überschreiben, indem Sie diese zurückgeben.
 
@@ -81,19 +81,19 @@ Eine `Response`, die direkt von Ihrer *Pfadoperation-Funktion* zurückgegeben wi
 
 ///
 
-/// info
+/// info | Info
 
 Natürlich stammen der eigentliche `Content-Type`-Header, der Statuscode, usw., aus dem `Response`-Objekt, das Sie zurückgegeben haben.
 
 ///
 
-### In OpenAPI dokumentieren und `Response` überschreiben
+### In OpenAPI dokumentieren und `Response` überschreiben { #document-in-openapi-and-override-response }
 
 Wenn Sie die Response innerhalb der Funktion überschreiben und gleichzeitig den „Medientyp“ in OpenAPI dokumentieren möchten, können Sie den `response_class`-Parameter verwenden UND ein `Response`-Objekt zurückgeben.
 
-Die `response_class` wird dann nur zur Dokumentation der OpenAPI-Pfadoperation* verwendet, Ihre `Response` wird jedoch unverändert verwendet.
+Die `response_class` wird dann nur zur Dokumentation der OpenAPI-*Pfadoperation* verwendet, Ihre `Response` wird jedoch unverändert verwendet.
 
-#### Eine `HTMLResponse` direkt zurückgeben
+#### Eine `HTMLResponse` direkt zurückgeben { #return-an-htmlresponse-directly }
 
 Es könnte zum Beispiel so etwas sein:
 
@@ -107,7 +107,7 @@ Aber da Sie die `HTMLResponse` auch in der `response_class` übergeben haben, we
 
 <img src="/img/tutorial/custom-response/image01.png">
 
-## Verfügbare Responses
+## Verfügbare Responses { #available-responses }
 
 Hier sind einige der verfügbaren Responses.
 
@@ -121,7 +121,7 @@ Sie können auch `from starlette.responses import HTMLResponse` verwenden.
 
 ///
 
-### `Response`
+### `Response` { #response }
 
 Die Hauptklasse `Response`, alle anderen Responses erben von ihr.
 
@@ -138,30 +138,42 @@ FastAPI (eigentlich Starlette) fügt automatisch einen Content-Length-Header ein
 
 {* ../../docs_src/response_directly/tutorial002.py hl[1,18] *}
 
-### `HTMLResponse`
+### `HTMLResponse` { #htmlresponse }
 
 Nimmt Text oder Bytes entgegen und gibt eine HTML-Response zurück, wie Sie oben gelesen haben.
 
-### `PlainTextResponse`
+### `PlainTextResponse` { #plaintextresponse }
 
 Nimmt Text oder Bytes entgegen und gibt eine Plain-Text-Response zurück.
 
 {* ../../docs_src/custom_response/tutorial005.py hl[2,7,9] *}
 
-### `JSONResponse`
+### `JSONResponse` { #jsonresponse }
 
 Nimmt einige Daten entgegen und gibt eine `application/json`-codierte Response zurück.
 
 Dies ist die Standard-Response, die in **FastAPI** verwendet wird, wie Sie oben gelesen haben.
 
-### `ORJSONResponse`
+### `ORJSONResponse` { #orjsonresponse }
 
 Eine schnelle alternative JSON-Response mit <a href="https://github.com/ijl/orjson" class="external-link" target="_blank">`orjson`</a>, wie Sie oben gelesen haben.
 
-### `UJSONResponse`
+/// info | Info
+
+Dazu muss `orjson` installiert werden, z. B. mit `pip install orjson`.
+
+///
+
+### `UJSONResponse` { #ujsonresponse }
 
 Eine alternative JSON-Response mit <a href="https://github.com/ultrajson/ultrajson" class="external-link" target="_blank">`ujson`</a>.
 
+/// info | Info
+
+Dazu muss `ujson` installiert werden, z. B. mit `pip install ujson`.
+
+///
+
 /// warning | Achtung
 
 `ujson` ist bei der Behandlung einiger Sonderfälle weniger sorgfältig als Pythons eingebaute Implementierung.
@@ -176,7 +188,7 @@ Möglicherweise ist `ORJSONResponse` eine schnellere Alternative.
 
 ///
 
-### `RedirectResponse`
+### `RedirectResponse` { #redirectresponse }
 
 Gibt eine HTTP-Weiterleitung (HTTP-Redirect) zurück. Verwendet standardmäßig den Statuscode 307 – Temporäre Weiterleitung (Temporary Redirect).
 
@@ -188,7 +200,6 @@ Sie können eine `RedirectResponse` direkt zurückgeben:
 
 Oder Sie können sie im Parameter `response_class` verwenden:
 
-
 {* ../../docs_src/custom_response/tutorial006b.py hl[2,7,9] *}
 
 Wenn Sie das tun, können Sie die URL direkt von Ihrer *Pfadoperation*-Funktion zurückgeben.
@@ -201,26 +212,24 @@ Sie können den Parameter `status_code` auch in Kombination mit dem Parameter `r
 
 {* ../../docs_src/custom_response/tutorial006c.py hl[2,7,9] *}
 
-### `StreamingResponse`
+### `StreamingResponse` { #streamingresponse }
 
 Nimmt einen asynchronen Generator oder einen normalen Generator/Iterator und streamt den Responsebody.
 
 {* ../../docs_src/custom_response/tutorial007.py hl[2,14] *}
 
-#### Verwendung von `StreamingResponse` mit dateiähnlichen Objekten
+#### Verwendung von `StreamingResponse` mit dateiartigen Objekten { #using-streamingresponse-with-file-like-objects }
 
-Wenn Sie ein dateiähnliches (file-like) Objekt haben (z. B. das von `open()` zurückgegebene Objekt), können Sie eine Generatorfunktion erstellen, um über dieses dateiähnliche Objekt zu iterieren.
+Wenn Sie ein dateiartiges (<a href="https://docs.python.org/3/glossary.html#term-file-like-object" class="external-link" target="_blank">file-like</a>) Objekt haben (z. B. das von `open()` zurückgegebene Objekt), können Sie eine Generatorfunktion erstellen, um über dieses dateiartige Objekt zu iterieren.
 
 Auf diese Weise müssen Sie nicht alles zuerst in den Arbeitsspeicher lesen und können diese Generatorfunktion an `StreamingResponse` übergeben und zurückgeben.
 
 Das umfasst viele Bibliotheken zur Interaktion mit Cloud-Speicher, Videoverarbeitung und anderen.
 
-```{ .python .annotate hl_lines="2  10-12  14" }
-{!../../docs_src/custom_response/tutorial008.py!}
-```
+{* ../../docs_src/custom_response/tutorial008.py hl[2,10:12,14] *}
 
 1. Das ist die Generatorfunktion. Es handelt sich um eine „Generatorfunktion“, da sie `yield`-Anweisungen enthält.
-2. Durch die Verwendung eines `with`-Blocks stellen wir sicher, dass das dateiähnliche Objekt geschlossen wird, nachdem die Generatorfunktion fertig ist. Also, nachdem sie mit dem Senden der Response fertig ist.
+2. Durch die Verwendung eines `with`-Blocks stellen wir sicher, dass das dateiartige Objekt geschlossen wird, nachdem die Generatorfunktion fertig ist. Also, nachdem sie mit dem Senden der Response fertig ist.
 3. Dieses `yield from` weist die Funktion an, über das Ding namens `file_like` zu iterieren. Und dann für jeden iterierten Teil, diesen Teil so zurückzugeben, als wenn er aus dieser Generatorfunktion (`iterfile`) stammen würde.
 
     Es handelt sich also hier um eine Generatorfunktion, die die „generierende“ Arbeit intern auf etwas anderes überträgt.
@@ -233,7 +242,7 @@ Beachten Sie, dass wir, da wir Standard-`open()` verwenden, welches `async` und
 
 ///
 
-### `FileResponse`
+### `FileResponse` { #fileresponse }
 
 Streamt eine Datei asynchron als Response.
 
@@ -254,7 +263,7 @@ Sie können auch den Parameter `response_class` verwenden:
 
 In diesem Fall können Sie den Dateipfad direkt von Ihrer *Pfadoperation*-Funktion zurückgeben.
 
-## Benutzerdefinierte Response-Klasse
+## Benutzerdefinierte Response-Klasse { #custom-response-class }
 
 Sie können Ihre eigene benutzerdefinierte Response-Klasse erstellen, die von `Response` erbt und diese verwendet.
 
@@ -282,7 +291,7 @@ Statt:
 
 Natürlich werden Sie wahrscheinlich viel bessere Möglichkeiten finden, Vorteil daraus zu ziehen, als JSON zu formatieren. 😉
 
-## Standard-Response-Klasse
+## Standard-Response-Klasse { #default-response-class }
 
 Beim Erstellen einer **FastAPI**-Klasseninstanz oder eines `APIRouter`s können Sie angeben, welche Response-Klasse standardmäßig verwendet werden soll.
 
@@ -298,6 +307,6 @@ Sie können dennoch weiterhin `response_class` in *Pfadoperationen* überschreib
 
 ///
 
-## Zusätzliche Dokumentation
+## Zusätzliche Dokumentation { #additional-documentation }
 
 Sie können auch den Medientyp und viele andere Details in OpenAPI mit `responses` deklarieren: [Zusätzliche Responses in OpenAPI](additional-responses.md){.internal-link target=_blank}.

docs/de/docs/advanced/dataclasses.md

@@ -1,24 +1,24 @@
-# Verwendung von Datenklassen
+# Verwendung von Datenklassen { #using-dataclasses }
 
-FastAPI basiert auf **Pydantic** und ich habe Ihnen gezeigt, wie Sie Pydantic-Modelle verwenden können, um Requests und Responses zu deklarieren.
+FastAPI basiert auf **Pydantic**, und ich habe Ihnen gezeigt, wie Sie Pydantic-Modelle verwenden können, um <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Requests</abbr> und <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Responses</abbr> zu deklarieren.
 
 Aber FastAPI unterstützt auf die gleiche Weise auch die Verwendung von <a href="https://docs.python.org/3/library/dataclasses.html" class="external-link" target="_blank">`dataclasses`</a>:
 
 {* ../../docs_src/dataclasses/tutorial001.py hl[1,7:12,19:20] *}
 
-Das ist dank **Pydantic** ebenfalls möglich, da es <a href="https://pydantic-docs.helpmanual.io/usage/dataclasses/#use-of-stdlib-dataclasses-with-basemodel" class="external-link" target="_blank">`dataclasses` intern unterstützt</a>.
+Das ist dank **Pydantic** ebenfalls möglich, da es <a href="https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel" class="external-link" target="_blank">`dataclasses` intern unterstützt</a>.
 
-Auch wenn im obige Code Pydantic nicht explizit vorkommt, verwendet FastAPI Pydantic, um diese Standard-Datenklassen in Pydantics eigene Variante von Datenklassen zu konvertieren.
+Auch wenn im obigen Code Pydantic nicht explizit vorkommt, verwendet FastAPI Pydantic, um diese Standard-Datenklassen in Pydantics eigene Variante von Datenklassen zu konvertieren.
 
 Und natürlich wird das gleiche unterstützt:
 
-* Validierung der Daten
-* Serialisierung der Daten
-* Dokumentation der Daten, usw.
+* Datenvalidierung
+* Datenserialisierung
+* Datendokumentation, usw.
 
 Das funktioniert genauso wie mit Pydantic-Modellen. Und tatsächlich wird es unter der Haube mittels Pydantic auf die gleiche Weise bewerkstelligt.
 
-/// info
+/// info | Info
 
 Bedenken Sie, dass Datenklassen nicht alles können, was Pydantic-Modelle können.
 
@@ -28,7 +28,7 @@ Wenn Sie jedoch eine Menge Datenklassen herumliegen haben, ist dies ein guter Tr
 
 ///
 
-## Datenklassen als `response_model`
+## Datenklassen in `response_model` { #dataclasses-in-response-model }
 
 Sie können `dataclasses` auch im Parameter `response_model` verwenden:
 
@@ -40,7 +40,7 @@ Auf diese Weise wird deren Schema in der Benutzeroberfläche der API-Dokumentati
 
 <img src="/img/tutorial/dataclasses/image01.png">
 
-## Datenklassen in verschachtelten Datenstrukturen
+## Datenklassen in verschachtelten Datenstrukturen { #dataclasses-in-nested-data-structures }
 
 Sie können `dataclasses` auch mit anderen Typannotationen kombinieren, um verschachtelte Datenstrukturen zu erstellen.
 
@@ -62,7 +62,7 @@ In diesem Fall können Sie einfach die Standard-`dataclasses` durch `pydantic.da
 
     In diesem Fall handelt es sich um eine Liste von `Item`-Datenklassen.
 
-6. Hier geben wir ein Dictionary zurück, das `items` enthält, welches eine Liste von Datenklassen ist.
+6. Hier geben wir ein <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">Dictionary</abbr> zurück, das `items` enthält, welches eine Liste von Datenklassen ist.
 
     FastAPI ist weiterhin in der Lage, die Daten nach JSON zu <abbr title="Konvertieren der Daten in ein übertragbares Format">serialisieren</abbr>.
 
@@ -74,7 +74,7 @@ In diesem Fall können Sie einfach die Standard-`dataclasses` durch `pydantic.da
 
     Wie immer können Sie in FastAPI `def` und `async def` beliebig kombinieren.
 
-    Wenn Sie eine Auffrischung darüber benötigen, wann welche Anwendung sinnvoll ist, lesen Sie den Abschnitt „In Eile?“ in der Dokumentation zu [`async` und `await`](../async.md#in-eile){.internal-link target=_blank}.
+    Wenn Sie eine Auffrischung darüber benötigen, wann welche Anwendung sinnvoll ist, lesen Sie den Abschnitt „In Eile?“ in der Dokumentation zu [`async` und `await`](../async.md#in-a-hurry){.internal-link target=_blank}.
 
 9. Diese *Pfadoperation-Funktion* gibt keine Datenklassen zurück (obwohl dies möglich wäre), sondern eine Liste von Dictionarys mit internen Daten.
 
@@ -84,12 +84,12 @@ Sie können `dataclasses` mit anderen Typannotationen auf vielfältige Weise kom
 
 Weitere Einzelheiten finden Sie in den Bemerkungen im Quellcode oben.
 
-## Mehr erfahren
+## Mehr erfahren { #learn-more }
 
 Sie können `dataclasses` auch mit anderen Pydantic-Modellen kombinieren, von ihnen erben, sie in Ihre eigenen Modelle einbinden, usw.
 
-Weitere Informationen finden Sie in der <a href="https://pydantic-docs.helpmanual.io/usage/dataclasses/" class="external-link" target="_blank">Pydantic-Dokumentation zu Datenklassen</a>.
+Weitere Informationen finden Sie in der <a href="https://docs.pydantic.dev/latest/concepts/dataclasses/" class="external-link" target="_blank">Pydantic-Dokumentation zu Datenklassen</a>.
 
-## Version
+## Version { #version }
 
 Dies ist verfügbar seit FastAPI-Version `0.67.0`. 🔖

docs/de/docs/advanced/events.md

@@ -1,14 +1,14 @@
-# Lifespan-Events
+# Lifespan-Events { #lifespan-events }
 
-Sie können Logik (Code) definieren, die ausgeführt werden soll, bevor die Anwendung **hochfährt**. Dies bedeutet, dass dieser Code **einmal** ausgeführt wird, **bevor** die Anwendung **beginnt, Requests entgegenzunehmen**.
+Sie können Logik (Code) definieren, die ausgeführt werden soll, bevor die Anwendung **hochfährt**. Dies bedeutet, dass dieser Code **einmal** ausgeführt wird, **bevor** die Anwendung **beginnt, <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Requests</abbr> entgegenzunehmen**.
 
 Auf die gleiche Weise können Sie Logik (Code) definieren, die ausgeführt werden soll, wenn die Anwendung **heruntergefahren** wird. In diesem Fall wird dieser Code **einmal** ausgeführt, **nachdem** möglicherweise **viele Requests** bearbeitet wurden.
 
-Da dieser Code ausgeführt wird, bevor die Anwendung **beginnt**, Requests entgegenzunehmen, und unmittelbar, nachdem sie die Bearbeitung von Requests **abgeschlossen hat**, deckt er die gesamte **Lebensdauer – „Lifespan“** – der Anwendung ab (das Wort „Lifespan“ wird gleich wichtig sein 😉).
+Da dieser Code ausgeführt wird, bevor die Anwendung **beginnt**, Requests entgegenzunehmen, und unmittelbar, nachdem sie die Bearbeitung von Requests **abgeschlossen hat**, deckt er den gesamten Anwendungs-<abbr title="Lebensdauer">**Lifespan**</abbr> ab (das Wort „Lifespan“ wird gleich wichtig sein 😉).
 
-Dies kann sehr nützlich sein, um **Ressourcen** einzurichten, die Sie in der gesamten Anwendung verwenden wollen und die von Requests **gemeinsam genutzt** werden und/oder die Sie anschließend **aufräumen** müssen. Zum Beispiel ein Pool von Datenbankverbindungen oder das Laden eines gemeinsam genutzten Modells für maschinelles Lernen.
+Dies kann sehr nützlich sein, um **Ressourcen** einzurichten, die Sie in der gesamten App verwenden wollen und die von Requests **gemeinsam genutzt** werden und/oder die Sie anschließend **aufräumen** müssen. Zum Beispiel ein Pool von Datenbankverbindungen oder das Laden eines gemeinsam genutzten Modells für maschinelles Lernen.
 
-## Anwendungsfall
+## Anwendungsfall { #use-case }
 
 Beginnen wir mit einem Beispiel-**Anwendungsfall** und schauen uns dann an, wie wir ihn mit dieser Methode implementieren können.
 
@@ -22,7 +22,7 @@ Sie könnten das auf der obersten Ebene des Moduls/der Datei machen, aber das w
 
 Das wollen wir besser machen: Laden wir das Modell, bevor die Requests bearbeitet werden, aber unmittelbar bevor die Anwendung beginnt, Requests zu empfangen, und nicht, während der Code geladen wird.
 
-## Lifespan
+## Lifespan { #lifespan }
 
 Sie können diese Logik beim *Hochfahren* und *Herunterfahren* mithilfe des `lifespan`-Parameters der `FastAPI`-App und eines „Kontextmanagers“ definieren (ich zeige Ihnen gleich, was das ist).
 
@@ -32,19 +32,19 @@ Wir erstellen eine asynchrone Funktion `lifespan()` mit `yield` wie folgt:
 
 {* ../../docs_src/events/tutorial003.py hl[16,19] *}
 
-Hier simulieren wir das langsame *Hochfahren*, das Laden des Modells, indem wir die (Fake-)Modellfunktion vor dem `yield` in das Dictionary mit Modellen für maschinelles Lernen einfügen. Dieser Code wird ausgeführt, **bevor** die Anwendung **beginnt, Requests entgegenzunehmen**, während des *Hochfahrens*.
+Hier simulieren wir das langsame *Hochfahren*, das Laden des Modells, indem wir die (Fake-)Modellfunktion vor dem `yield` in das <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">Dictionary</abbr> mit Modellen für maschinelles Lernen einfügen. Dieser Code wird ausgeführt, **bevor** die Anwendung **beginnt, Requests entgegenzunehmen**, während des *Hochfahrens*.
 
-Und dann, direkt nach dem `yield`, entladen wir das Modell. Dieser Code wird unmittelbar vor dem *Herunterfahren* ausgeführt, **nachdem** die Anwendung **die Bearbeitung von Requests abgeschlossen hat**. Dadurch könnten beispielsweise Ressourcen wie Arbeitsspeicher oder eine GPU freigegeben werden.
+Und dann, direkt nach dem `yield`, entladen wir das Modell. Dieser Code wird ausgeführt, **nachdem** die Anwendung **die Bearbeitung von Requests abgeschlossen hat**, direkt vor dem *Herunterfahren*. Dadurch könnten beispielsweise Ressourcen wie Arbeitsspeicher oder eine GPU freigegeben werden.
 
 /// tip | Tipp
 
-Das *Herunterfahren* würde erfolgen, wenn Sie die Anwendung **stoppen**.
+Das `shutdown` würde erfolgen, wenn Sie die Anwendung **stoppen**.
 
 Möglicherweise müssen Sie eine neue Version starten, oder Sie haben es einfach satt, sie auszuführen. 🤷
 
 ///
 
-### Lifespan-Funktion
+### Lifespan-Funktion { #lifespan-function }
 
 Das Erste, was auffällt, ist, dass wir eine asynchrone Funktion mit `yield` definieren. Das ist sehr ähnlich zu Abhängigkeiten mit `yield`.
 
@@ -54,7 +54,7 @@ Der erste Teil der Funktion, vor dem `yield`, wird ausgeführt **bevor** die Anw
 
 Und der Teil nach `yield` wird ausgeführt, **nachdem** die Anwendung beendet ist.
 
-### Asynchroner Kontextmanager
+### Asynchroner Kontextmanager { #async-context-manager }
 
 Wie Sie sehen, ist die Funktion mit einem `@asynccontextmanager` versehen.
 
@@ -84,7 +84,7 @@ Der Parameter `lifespan` der `FastAPI`-App benötigt einen **asynchronen Kontext
 
 {* ../../docs_src/events/tutorial003.py hl[22] *}
 
-## Alternative Events (deprecated)
+## Alternative Events (<abbr title="veraltet, obsolet: Es soll nicht mehr verwendet werden">deprecatet</abbr>) { #alternative-events-deprecated }
 
 /// warning | Achtung
 
@@ -96,11 +96,11 @@ Sie können diesen Teil wahrscheinlich überspringen.
 
 Es gibt eine alternative Möglichkeit, diese Logik zu definieren, sodass sie beim *Hochfahren* und beim *Herunterfahren* ausgeführt wird.
 
-Sie können <abbr title="Eventhandler – Ereignisbehandler: Funktion, die bei jedem Eintreten eines bestimmten Ereignisses ausgeführt wird">Eventhandler</abbr> (Funktionen) definieren, die ausgeführt werden sollen, bevor die Anwendung hochgefahren wird oder wenn die Anwendung heruntergefahren wird.
+Sie können <abbr title="Eventhandler – Ereignisbehandler: Funktion, die beim Eintreten eines bestimmten Ereignisses ausgeführt wird">Eventhandler</abbr> (Funktionen) definieren, die ausgeführt werden sollen, bevor die Anwendung hochgefahren wird oder wenn die Anwendung heruntergefahren wird.
 
 Diese Funktionen können mit `async def` oder normalem `def` deklariert werden.
 
-### `startup`-Event
+### `startup`-Event { #startup-event }
 
 Um eine Funktion hinzuzufügen, die vor dem Start der Anwendung ausgeführt werden soll, deklarieren Sie diese mit dem Event `startup`:
 
@@ -110,9 +110,9 @@ In diesem Fall initialisiert die Eventhandler-Funktion `startup` die „Datenban
 
 Sie können mehr als eine Eventhandler-Funktion hinzufügen.
 
-Und Ihre Anwendung empfängt erst dann Anfragen, wenn alle `startup`-Eventhandler abgeschlossen sind.
+Und Ihre Anwendung empfängt erst dann Requests, wenn alle `startup`-Eventhandler abgeschlossen sind.
 
-### `shutdown`-Event
+### `shutdown`-Event { #shutdown-event }
 
 Um eine Funktion hinzuzufügen, die beim Herunterfahren der Anwendung ausgeführt werden soll, deklarieren Sie sie mit dem Event `shutdown`:
 
@@ -120,7 +120,7 @@ Um eine Funktion hinzuzufügen, die beim Herunterfahren der Anwendung ausgeführ
 
 Hier schreibt die `shutdown`-Eventhandler-Funktion eine Textzeile `"Application shutdown"` in eine Datei `log.txt`.
 
-/// info
+/// info | Info
 
 In der Funktion `open()` bedeutet `mode="a"` „append“ („anhängen“), sodass die Zeile nach dem, was sich in dieser Datei befindet, hinzugefügt wird, ohne den vorherigen Inhalt zu überschreiben.
 
@@ -138,7 +138,7 @@ Daher deklarieren wir die Eventhandler-Funktion mit Standard-`def` statt mit `as
 
 ///
 
-### `startup` und `shutdown` zusammen
+### `startup` und `shutdown` zusammen { #startup-and-shutdown-together }
 
 Es besteht eine hohe Wahrscheinlichkeit, dass die Logik für Ihr *Hochfahren* und *Herunterfahren* miteinander verknüpft ist. Vielleicht möchten Sie etwas beginnen und es dann beenden, eine Ressource laden und sie dann freigeben usw.
 
@@ -146,13 +146,13 @@ Bei getrennten Funktionen, die keine gemeinsame Logik oder Variablen haben, ist
 
 Aus diesem Grund wird jetzt empfohlen, stattdessen `lifespan` wie oben erläutert zu verwenden.
 
-## Technische Details
+## Technische Details { #technical-details }
 
 Nur ein technisches Detail für die neugierigen Nerds. 🤓
 
 In der technischen ASGI-Spezifikation ist dies Teil des <a href="https://asgi.readthedocs.io/en/latest/specs/lifespan.html" class="external-link" target="_blank">Lifespan Protokolls</a> und definiert Events namens `startup` und `shutdown`.
 
-/// info
+/// info | Info
 
 Weitere Informationen zu Starlettes `lifespan`-Handlern finden Sie in <a href="https://www.starlette.io/lifespan/" class="external-link" target="_blank">Starlettes Lifespan-Dokumentation</a>.
 
@@ -160,6 +160,6 @@ Einschließlich, wie man Lifespan-Zustand handhabt, der in anderen Bereichen Ihr
 
 ///
 
-## Unteranwendungen
+## Unteranwendungen { #sub-applications }
 
 🚨 Beachten Sie, dass diese Lifespan-Events (Hochfahren und Herunterfahren) nur für die Hauptanwendung ausgeführt werden, nicht für [Unteranwendungen – Mounts](sub-applications.md){.internal-link target=_blank}.

docs/de/docs/advanced/generate-clients.md

@@ -1,121 +1,86 @@
-# Clients generieren
+# SDKs generieren { #generating-sdks }
 
-Da **FastAPI** auf der OpenAPI-Spezifikation basiert, erhalten Sie automatische Kompatibilität mit vielen Tools, einschließlich der automatischen API-Dokumentation (bereitgestellt von Swagger UI).
+Da **FastAPI** auf der **OpenAPI**-Spezifikation basiert, können dessen APIs in einem standardisierten Format beschrieben werden, das viele Tools verstehen.
 
-Ein besonderer Vorteil, der nicht unbedingt offensichtlich ist, besteht darin, dass Sie für Ihre API **Clients generieren** können (manchmal auch <abbr title="Software Development Kits">**SDKs**</abbr> genannt), für viele verschiedene **Programmiersprachen**.
+Dies vereinfacht es, aktuelle **Dokumentation** und Client-Bibliotheken (<abbr title="Software Development Kit – Software-Entwicklungspaket">**SDKs**</abbr>) in verschiedenen Sprachen zu generieren sowie **Test-** oder **Automatisierungs-Workflows**, die mit Ihrem Code synchron bleiben.
 
-## OpenAPI-Client-Generatoren
+In diesem Leitfaden erfahren Sie, wie Sie ein **TypeScript-SDK** für Ihr FastAPI-Backend generieren.
 
-Es gibt viele Tools zum Generieren von Clients aus **OpenAPI**.
+## Open Source SDK-Generatoren { #open-source-sdk-generators }
 
-Ein gängiges Tool ist <a href="https://openapi-generator.tech/" class="external-link" target="_blank">OpenAPI Generator</a>.
+Eine vielseitige Möglichkeit ist der <a href="https://openapi-generator.tech/" class="external-link" target="_blank">OpenAPI Generator</a>, der **viele Programmiersprachen** unterstützt und SDKs aus Ihrer OpenAPI-Spezifikation generieren kann.
 
-Wenn Sie ein **Frontend** erstellen, ist <a href="https://github.com/hey-api/openapi-ts" class="external-link" target="_blank">openapi-ts</a> eine sehr interessante Alternative.
+Für **TypeScript-Clients** ist <a href="https://heyapi.dev/" class="external-link" target="_blank">Hey API</a> eine speziell entwickelte Lösung, die ein optimiertes Erlebnis für das TypeScript-Ökosystem bietet.
 
-## Client- und SDK-Generatoren – Sponsor
+Weitere SDK-Generatoren finden Sie auf <a href="https://openapi.tools/#sdk" class="external-link" target="_blank">OpenAPI.Tools</a>.
 
-Es gibt auch einige **vom Unternehmen entwickelte** Client- und SDK-Generatoren, die auf OpenAPI (FastAPI) basieren. In einigen Fällen können diese Ihnen **weitere Funktionalität** zusätzlich zu qualitativ hochwertigen generierten SDKs/Clients bieten.
-
-Einige von diesen ✨ [**sponsern FastAPI**](../help-fastapi.md#den-autor-sponsern){.internal-link target=_blank} ✨, das gewährleistet die kontinuierliche und gesunde **Entwicklung** von FastAPI und seinem **Ökosystem**.
-
-Und es zeigt deren wahres Engagement für FastAPI und seine **Community** (Sie), da diese Ihnen nicht nur einen **guten Service** bieten möchten, sondern auch sicherstellen möchten, dass Sie über ein **gutes und gesundes Framework** verfügen, FastAPI. 🙇
-
-Beispielsweise könnten Sie <a href="https://speakeasy.com/editor?utm_source=fastapi+repo&utm_medium=github+sponsorship" class="external-link" target="_blank">Speakeasy</a> ausprobieren.
-
-Es gibt auch mehrere andere Unternehmen, welche ähnliche Dienste anbieten und die Sie online suchen und finden können. 🤓
-
-## Einen TypeScript-Frontend-Client generieren
-
-Beginnen wir mit einer einfachen FastAPI-Anwendung:
-
-{* ../../docs_src/generate_clients/tutorial001_py39.py hl[7:9,12:13,16:17,21] *}
-
-Beachten Sie, dass die *Pfadoperationen* die Modelle definieren, welche diese für die Request- und Response-<abbr title="Die eigentlichen Nutzdaten, abzüglich der Metadaten">Payload</abbr> verwenden, indem sie die Modelle `Item` und `ResponseMessage` verwenden.
-
-### API-Dokumentation
+/// tip | Tipp
 
-Wenn Sie zur API-Dokumentation gehen, werden Sie sehen, dass diese die **Schemas** für die Daten enthält, welche in Requests gesendet und in Responses empfangen werden:
+FastAPI generiert automatisch **OpenAPI 3.1**-Spezifikationen, daher muss jedes von Ihnen verwendete Tool diese Version unterstützen.
 
-<img src="/img/tutorial/generate-clients/image01.png">
+///
 
-Sie können diese Schemas sehen, da sie mit den Modellen in der Anwendung deklariert wurden.
+## SDK-Generatoren von FastAPI-Sponsoren { #sdk-generators-from-fastapi-sponsors }
 
-Diese Informationen sind im **OpenAPI-Schema** der Anwendung verfügbar und werden dann in der API-Dokumentation angezeigt (von Swagger UI).
+Dieser Abschnitt hebt **venture-unterstützte** und **firmengestützte** Lösungen hervor, die von Unternehmen entwickelt werden, welche FastAPI sponsern. Diese Produkte bieten **zusätzliche Funktionen** und **Integrationen** zusätzlich zu hochwertig generierten SDKs.
 
-Und dieselben Informationen aus den Modellen, die in OpenAPI enthalten sind, können zum **Generieren des Client-Codes** verwendet werden.
+Durch das ✨ [**Sponsoring von FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨ helfen diese Unternehmen sicherzustellen, dass das Framework und sein **Ökosystem** gesund und **nachhaltig** bleiben.
 
-### Einen TypeScript-Client generieren
+Ihr Sponsoring zeigt auch ein starkes Engagement für die FastAPI-**Community** (Sie), was bedeutet, dass sie nicht nur einen **großartigen Service** bieten möchten, sondern auch ein **robustes und florierendes Framework**, FastAPI, unterstützen möchten. 🙇
 
-Nachdem wir nun die Anwendung mit den Modellen haben, können wir den Client-Code für das Frontend generieren.
+Zum Beispiel könnten Sie ausprobieren:
 
-#### `openapi-ts` installieren
+* <a href="https://speakeasy.com/editor?utm_source=fastapi+repo&utm_medium=github+sponsorship" class="external-link" target="_blank">Speakeasy</a>
+* <a href="https://www.stainless.com/?utm_source=fastapi&utm_medium=referral" class="external-link" target="_blank">Stainless</a>
+* <a href="https://developers.liblab.com/tutorials/sdk-for-fastapi?utm_source=fastapi" class="external-link" target="_blank">liblab</a>
 
-Sie können `openapi-ts` in Ihrem Frontend-Code installieren mit:
+Einige dieser Lösungen sind möglicherweise auch Open Source oder bieten kostenlose Tarife an, sodass Sie diese ohne finanzielle Verpflichtung ausprobieren können. Andere kommerzielle SDK-Generatoren sind online verfügbar und können dort gefunden werden. 🤓
 
-<div class="termy">
+## Ein TypeScript-SDK erstellen { #create-a-typescript-sdk }
 
-```console
-$ npm install @hey-api/openapi-ts --save-dev
+Beginnen wir mit einer einfachen FastAPI-Anwendung:
 
----> 100%
-```
+{* ../../docs_src/generate_clients/tutorial001_py39.py hl[7:9,12:13,16:17,21] *}
 
-</div>
+Beachten Sie, dass die *Pfadoperationen* die Modelle definieren, die sie für die <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr>- und <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr>-<abbr title="Die eigentlichen Nutzdaten, abzüglich der Metadaten">Payload</abbr> verwenden, indem sie die Modelle `Item` und `ResponseMessage` verwenden.
 
-#### Client-Code generieren
+### API-Dokumentation { #api-docs }
 
-Um den Client-Code zu generieren, können Sie das Kommandozeilentool `openapi-ts` verwenden, das soeben installiert wurde.
+Wenn Sie zu `/docs` gehen, sehen Sie, dass es die **Schemas** für die Daten enthält, die in Requests gesendet und in Responses empfangen werden:
 
-Da es im lokalen Projekt installiert ist, könnten Sie diesen Befehl wahrscheinlich nicht direkt aufrufen, sondern würden ihn in Ihre Datei `package.json` einfügen.
+<img src="/img/tutorial/generate-clients/image01.png">
 
-Diese könnte so aussehen:
+Sie können diese Schemas sehen, da sie mit den Modellen in der App deklariert wurden.
 
-```JSON  hl_lines="7"
-{
-  "name": "frontend-app",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "generate-client": "openapi-ts --input http://localhost:8000/openapi.json --output ./src/client --client axios"
-  },
-  "author": "",
-  "license": "",
-  "devDependencies": {
-    "@hey-api/openapi-ts": "^0.27.38",
-    "typescript": "^4.6.2"
-  }
-}
-```
+Diese Informationen sind im **OpenAPI-Schema** der Anwendung verfügbar und werden in der API-Dokumentation angezeigt.
 
-Nachdem Sie das NPM-Skript `generate-client` dort stehen haben, können Sie es ausführen mit:
+Diese Informationen aus den Modellen, die in OpenAPI enthalten sind, können verwendet werden, um **den Client-Code zu generieren**.
 
-<div class="termy">
+### Hey API { #hey-api }
 
-```console
-$ npm run generate-client
+Sobald wir eine FastAPI-App mit den Modellen haben, können wir Hey API verwenden, um einen TypeScript-Client zu generieren. Der schnellste Weg das zu tun, ist über npx.
 
-frontend-app@1.0.0 generate-client /home/user/code/frontend-app
-> openapi-ts --input http://localhost:8000/openapi.json --output ./src/client --client axios
+```sh
+npx @hey-api/openapi-ts -i http://localhost:8000/openapi.json -o src/client
 ```
 
-</div>
+Dies generiert ein TypeScript-SDK in `./src/client`.
 
-Dieser Befehl generiert Code in `./src/client` und verwendet intern `axios` (die Frontend-HTTP-Bibliothek).
+Sie können lernen, wie man <a href="https://heyapi.dev/openapi-ts/get-started" class="external-link" target="_blank">`@hey-api/openapi-ts` installiert</a> und über die <a href="https://heyapi.dev/openapi-ts/output" class="external-link" target="_blank">erzeugte Ausgabe</a> auf deren Website lesen.
 
-### Den Client-Code ausprobieren
+### Das SDK verwenden { #using-the-sdk }
 
-Jetzt können Sie den Client-Code importieren und verwenden. Er könnte wie folgt aussehen, beachten Sie, dass Sie automatische Codevervollständigung für die Methoden erhalten:
+Jetzt können Sie den Client-Code importieren und verwenden. Er könnte wie folgt aussehen, beachten Sie, dass Sie eine automatische Vervollständigung für die Methoden erhalten:
 
 <img src="/img/tutorial/generate-clients/image02.png">
 
-Sie erhalten außerdem automatische Vervollständigung für die zu sendende Payload:
+Sie werden auch eine automatische Vervollständigung für die zu sendende Payload erhalten:
 
 <img src="/img/tutorial/generate-clients/image03.png">
 
 /// tip | Tipp
 
-Beachten Sie die automatische Vervollständigung für `name` und `price`, welche in der FastAPI-Anwendung im `Item`-Modell definiert wurden.
+Beachten Sie die automatische Vervollständigung für `name` und `price`, die in der FastAPI-Anwendung im `Item`-Modell definiert wurden.
 
 ///
 
@@ -127,17 +92,17 @@ Das Response-Objekt hat auch automatische Vervollständigung:
 
 <img src="/img/tutorial/generate-clients/image05.png">
 
-## FastAPI-Anwendung mit Tags
+## FastAPI-Anwendung mit Tags { #fastapi-app-with-tags }
 
-In vielen Fällen wird Ihre FastAPI-Anwendung größer sein und Sie werden wahrscheinlich Tags verwenden, um verschiedene Gruppen von *Pfadoperationen* zu separieren.
+In vielen Fällen wird Ihre FastAPI-App größer sein und Sie werden wahrscheinlich Tags verwenden, um verschiedene Gruppen von *Pfadoperationen* zu separieren.
 
-Beispielsweise könnten Sie einen Abschnitt für **Items (Artikel)** und einen weiteren Abschnitt für **Users (Benutzer)** haben, und diese könnten durch Tags getrennt sein:
+Zum Beispiel könnten Sie einen Abschnitt für **Items (Artikel)** und einen weiteren Abschnitt für **Users (Benutzer)** haben, und diese könnten durch Tags getrennt sein:
 
 {* ../../docs_src/generate_clients/tutorial002_py39.py hl[21,26,34] *}
 
-### Einen TypeScript-Client mit Tags generieren
+### Einen TypeScript-Client mit Tags generieren { #generate-a-typescript-client-with-tags }
 
-Wenn Sie unter Verwendung von Tags einen Client für eine FastAPI-Anwendung generieren, wird normalerweise auch der Client-Code anhand der Tags getrennt.
+Wenn Sie einen Client für eine FastAPI-App generieren, die Tags verwendet, wird normalerweise der Client-Code auch anhand der Tags getrennt.
 
 Auf diese Weise können Sie die Dinge für den Client-Code richtig ordnen und gruppieren:
 
@@ -148,7 +113,7 @@ In diesem Fall haben Sie:
 * `ItemsService`
 * `UsersService`
 
-### Client-Methodennamen
+### Client-Methodennamen { #client-method-names }
 
 Im Moment sehen die generierten Methodennamen wie `createItemItemsPost` nicht sehr sauber aus:
 
@@ -158,31 +123,31 @@ ItemsService.createItemItemsPost({name: "Plumbus", price: 5})
 
 ... das liegt daran, dass der Client-Generator für jede *Pfadoperation* die OpenAPI-interne **Operation-ID** verwendet.
 
-OpenAPI erfordert, dass jede Operation-ID innerhalb aller *Pfadoperationen* eindeutig ist. Daher verwendet FastAPI den **Funktionsnamen**, den **Pfad** und die **HTTP-Methode/-Operation**, um diese Operation-ID zu generieren. Denn so kann sichergestellt werden, dass die Operation-IDs eindeutig sind.
+OpenAPI erfordert, dass jede Operation-ID innerhalb aller *Pfadoperationen* einzigartig ist. Daher verwendet FastAPI den **Funktionsnamen**, den **Pfad** und die **HTTP-Methode/-Operation**, um diese Operation-ID zu generieren. Denn so kann sichergestellt werden, dass die Operation-IDs einzigartig sind.
 
-Aber ich zeige Ihnen als nächstes, wie Sie das verbessern können. 🤓
+Aber ich zeige Ihnen als Nächstes, wie Sie das verbessern können. 🤓
 
-## Benutzerdefinierte Operation-IDs und bessere Methodennamen
+## Benutzerdefinierte Operation-IDs und bessere Methodennamen { #custom-operation-ids-and-better-method-names }
 
 Sie können die Art und Weise, wie diese Operation-IDs **generiert** werden, **ändern**, um sie einfacher zu machen und **einfachere Methodennamen** in den Clients zu haben.
 
-In diesem Fall müssen Sie auf andere Weise sicherstellen, dass jede Operation-ID **eindeutig** ist.
+In diesem Fall müssen Sie auf andere Weise sicherstellen, dass jede Operation-ID **einzigartig** ist.
 
-Sie könnten beispielsweise sicherstellen, dass jede *Pfadoperation* einen Tag hat, und dann die Operation-ID basierend auf dem **Tag** und dem **Namen** der *Pfadoperation* (dem Funktionsnamen) generieren.
+Zum Beispiel könnten Sie sicherstellen, dass jede *Pfadoperation* einen Tag hat, und dann die Operation-ID basierend auf dem **Tag** und dem *Pfadoperation*-**Namen** (dem Funktionsnamen) generieren.
 
-### Funktion zum Generieren einer eindeutigen ID erstellen
+### Eine benutzerdefinierte Funktion zur Erzeugung einer eindeutigen ID erstellen { #custom-generate-unique-id-function }
 
-FastAPI verwendet eine **eindeutige ID** für jede *Pfadoperation*, diese wird für die **Operation-ID** und auch für die Namen aller benötigten benutzerdefinierten Modelle für Requests oder Responses verwendet.
+FastAPI verwendet eine **eindeutige ID** für jede *Pfadoperation*, die für die **Operation-ID** und auch für die Namen aller benötigten benutzerdefinierten Modelle für Requests oder Responses verwendet wird.
 
-Sie können diese Funktion anpassen. Sie nimmt eine `APIRoute` und gibt einen String zurück.
+Sie können diese Funktion anpassen. Sie nimmt ein `APIRoute` und gibt einen String zurück.
 
-Hier verwendet sie beispielsweise den ersten Tag (Sie werden wahrscheinlich nur einen Tag haben) und den Namen der *Pfadoperation* (den Funktionsnamen).
+Hier verwendet sie beispielsweise den ersten Tag (Sie werden wahrscheinlich nur einen Tag haben) und den *Pfadoperation*-Namen (den Funktionsnamen).
 
-Anschließend können Sie diese benutzerdefinierte Funktion als Parameter `generate_unique_id_function` an **FastAPI** übergeben:
+Anschließend können Sie diese benutzerdefinierte Funktion als `generate_unique_id_function`-Parameter an **FastAPI** übergeben:
 
 {* ../../docs_src/generate_clients/tutorial003_py39.py hl[6:7,10] *}
 
-### Einen TypeScript-Client mit benutzerdefinierten Operation-IDs generieren
+### Einen TypeScript-Client mit benutzerdefinierten Operation-IDs generieren { #generate-a-typescript-client-with-custom-operation-ids }
 
 Wenn Sie nun den Client erneut generieren, werden Sie feststellen, dass er über die verbesserten Methodennamen verfügt:
 
@@ -190,17 +155,17 @@ Wenn Sie nun den Client erneut generieren, werden Sie feststellen, dass er über
 
 Wie Sie sehen, haben die Methodennamen jetzt den Tag und dann den Funktionsnamen, aber keine Informationen aus dem URL-Pfad und der HTTP-Operation.
 
-### Vorab-Modifikation der OpenAPI-Spezifikation für den Client-Generator
+### Die OpenAPI-Spezifikation für den Client-Generator vorab modifizieren { #preprocess-the-openapi-specification-for-the-client-generator }
 
-Der generierte Code enthält immer noch etwas **verdoppelte Information**.
+Der generierte Code enthält immer noch einige **verdoppelte Informationen**.
 
-Wir wissen bereits, dass diese Methode mit den **Items** zusammenhängt, da sich dieses Wort in `ItemsService` befindet (vom Tag übernommen), aber wir haben auch immer noch den Tagnamen im Methodennamen vorangestellt. 😕
+Wir wissen bereits, dass diese Methode mit den **Items** zusammenhängt, weil dieses Wort in `ItemsService` enthalten ist (vom Tag übernommen), aber wir haben den Tag-Namen dennoch im Methodennamen vorangestellt. 😕
 
-Wir werden das wahrscheinlich weiterhin für OpenAPI im Allgemeinen beibehalten wollen, da dadurch sichergestellt wird, dass die Operation-IDs **eindeutig** sind.
+Wir werden das wahrscheinlich weiterhin für OpenAPI allgemein beibehalten wollen, da dadurch sichergestellt wird, dass die Operation-IDs **einzigartig** sind.
 
 Aber für den generierten Client könnten wir die OpenAPI-Operation-IDs direkt vor der Generierung der Clients **modifizieren**, um diese Methodennamen schöner und **sauberer** zu machen.
 
-Wir könnten das OpenAPI-JSON in eine Datei `openapi.json` herunterladen und dann mit einem Skript wie dem folgenden **den vorangestellten Tag entfernen**:
+Wir könnten das OpenAPI-JSON in eine Datei `openapi.json` herunterladen und dann mit einem Skript wie dem folgenden **den präfixierten Tag entfernen**:
 
 {* ../../docs_src/generate_clients/tutorial004.py *}
 
@@ -214,44 +179,30 @@ Wir könnten das OpenAPI-JSON in eine Datei `openapi.json` herunterladen und dan
 
 Damit würden die Operation-IDs von Dingen wie `items-get_items` in `get_items` umbenannt, sodass der Client-Generator einfachere Methodennamen generieren kann.
 
-### Einen TypeScript-Client mit der modifizierten OpenAPI generieren
-
-Da das Endergebnis nun in einer Datei `openapi.json` vorliegt, würden Sie die `package.json` ändern, um diese lokale Datei zu verwenden, zum Beispiel:
-
-```JSON  hl_lines="7"
-{
-  "name": "frontend-app",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "generate-client": "openapi-ts --input ./openapi.json --output ./src/client --client axios"
-  },
-  "author": "",
-  "license": "",
-  "devDependencies": {
-    "@hey-api/openapi-ts": "^0.27.38",
-    "typescript": "^4.6.2"
-  }
-}
+### Einen TypeScript-Client mit der modifizierten OpenAPI generieren { #generate-a-typescript-client-with-the-preprocessed-openapi }
+
+Da das Endergebnis nun in einer `openapi.json`-Datei vorliegt, müssen Sie Ihren Eingabeort aktualisieren:
+
+```sh
+npx @hey-api/openapi-ts -i ./openapi.json -o src/client
 ```
 
-Nach der Generierung des neuen Clients hätten Sie nun **saubere Methodennamen** mit allen **Autovervollständigungen**, **Inline-Fehlerberichten**, usw.:
+Nach der Generierung des neuen Clients haben Sie jetzt **saubere Methodennamen**, mit allen **Autovervollständigungen**, **Inline-Fehlerberichten**, usw.:
 
 <img src="/img/tutorial/generate-clients/image08.png">
 
-## Vorteile
+## Vorteile { #benefits }
 
-Wenn Sie die automatisch generierten Clients verwenden, erhalten Sie **automatische Codevervollständigung** für:
+Wenn Sie die automatisch generierten Clients verwenden, erhalten Sie **Autovervollständigung** für:
 
 * Methoden.
 * Request-Payloads im Body, Query-Parameter, usw.
 * Response-Payloads.
 
-Außerdem erhalten Sie für alles **Inline-Fehlerberichte**.
+Sie erhalten auch **Inline-Fehlerberichte** für alles.
 
-Und wann immer Sie den Backend-Code aktualisieren und das Frontend **neu generieren**, stehen alle neuen *Pfadoperationen* als Methoden zur Verfügung, die alten werden entfernt und alle anderen Änderungen werden im generierten Code reflektiert. 🤓
+Und wann immer Sie den Backend-Code aktualisieren und **das Frontend neu generieren**, stehen alle neuen *Pfadoperationen* als Methoden zur Verfügung, die alten werden entfernt und alle anderen Änderungen werden im generierten Code reflektiert. 🤓
 
-Das bedeutet auch, dass, wenn sich etwas ändert, dies automatisch im Client-Code **reflektiert** wird. Und wenn Sie den Client **erstellen**, kommt es zu einer Fehlermeldung, wenn die verwendeten Daten **nicht übereinstimmen**.
+Das bedeutet auch, dass, wenn sich etwas ändert, dies automatisch im Client-Code **reflektiert** wird. Und wenn Sie den Client **erstellen**, wird eine Fehlermeldung ausgegeben, wenn die verwendeten Daten **nicht übereinstimmen**.
 
-Sie würden also sehr früh im Entwicklungszyklus **viele Fehler erkennen**, anstatt darauf warten zu müssen, dass die Fehler Ihren Endbenutzern in der Produktion angezeigt werden, und dann zu versuchen, zu debuggen, wo das Problem liegt. ✨
+Sie würden also **viele Fehler sehr früh** im Entwicklungszyklus erkennen, anstatt darauf warten zu müssen, dass die Fehler Ihren Endbenutzern in der Produktion angezeigt werden, und dann zu versuchen, zu debuggen, wo das Problem liegt. ✨

docs/de/docs/advanced/index.md

@@ -1,6 +1,6 @@
-# Handbuch für fortgeschrittene Benutzer
+# Handbuch für fortgeschrittene Benutzer { #advanced-user-guide }
 
-## Zusatzfunktionen
+## Zusatzfunktionen { #additional-features }
 
 Das Haupt-[Tutorial – Benutzerhandbuch](../tutorial/index.md){.internal-link target=_blank} sollte ausreichen, um Ihnen einen Überblick über alle Hauptfunktionen von **FastAPI** zu geben.
 
@@ -14,23 +14,8 @@ Und es ist möglich, dass für Ihren Anwendungsfall die Lösung in einem davon l
 
 ///
 
-## Lesen Sie zuerst das Tutorial
+## Das Tutorial zuerst lesen { #read-the-tutorial-first }
 
 Sie können immer noch die meisten Funktionen in **FastAPI** mit den Kenntnissen aus dem Haupt-[Tutorial – Benutzerhandbuch](../tutorial/index.md){.internal-link target=_blank} nutzen.
 
-Und in den nächsten Abschnitten wird davon ausgegangen, dass Sie es bereits gelesen haben und dass Sie diese Haupt-Ideen kennen.
-
-## Externe Kurse
-
-Obwohl das [Tutorial – Benutzerhandbuch](../tutorial/index.md){.internal-link target=_blank} und dieses **Handbuch für fortgeschrittene Benutzer** als geführtes Tutorial (wie ein Buch) geschrieben sind und für Sie ausreichen sollten, um **FastAPI zu lernen**, möchten Sie sie vielleicht durch zusätzliche Kurse ergänzen.
-
-Oder Sie belegen einfach lieber andere Kurse, weil diese besser zu Ihrem Lernstil passen.
-
-Einige Kursanbieter ✨ [**sponsern FastAPI**](../help-fastapi.md#den-autor-sponsern){.internal-link target=_blank} ✨, dies gewährleistet die kontinuierliche und gesunde **Entwicklung** von FastAPI und seinem **Ökosystem**.
-
-Und es zeigt deren wahres Engagement für FastAPI und seine **Gemeinschaft** (Sie), da diese Ihnen nicht nur eine **gute Lernerfahrung** bieten möchten, sondern auch sicherstellen möchten, dass Sie über ein **gutes und gesundes Framework verfügen **, FastAPI. 🙇
-
-Vielleicht möchten Sie ihre Kurse ausprobieren:
-
-* <a href="https://training.talkpython.fm/fastapi-courses" class="external-link" target="_blank">Talk Python Training</a>
-* <a href="https://testdriven.io/courses/tdd-fastapi/" class="external-link" target="_blank">Test-Driven Development</a>
+Und die nächsten Abschnitte setzen voraus, dass Sie es bereits gelesen haben und dass Sie diese Hauptideen kennen.

docs/de/docs/advanced/middleware.md

@@ -1,4 +1,4 @@
-# Fortgeschrittene Middleware
+# Fortgeschrittene Middleware { #advanced-middleware }
 
 Im Haupttutorial haben Sie gelesen, wie Sie Ihrer Anwendung [benutzerdefinierte Middleware](../tutorial/middleware.md){.internal-link target=_blank} hinzufügen können.
 
@@ -6,15 +6,15 @@ Und dann auch, wie man [CORS mittels der `CORSMiddleware`](../tutorial/cors.md){
 
 In diesem Abschnitt werden wir sehen, wie man andere Middlewares verwendet.
 
-## ASGI-Middleware hinzufügen
+## ASGI-Middleware hinzufügen { #adding-asgi-middlewares }
 
-Da **FastAPI** auf Starlette basiert und die <abbr title="Asynchronous Server Gateway Interface">ASGI</abbr>-Spezifikation implementiert, können Sie jede ASGI-Middleware verwenden.
+Da **FastAPI** auf Starlette basiert und die <abbr title="Asynchrones Server-Gateway-Interface">ASGI</abbr>-Spezifikation implementiert, können Sie jede ASGI-Middleware verwenden.
 
 Eine Middleware muss nicht speziell für FastAPI oder Starlette gemacht sein, um zu funktionieren, solange sie der ASGI-Spezifikation genügt.
 
 Im Allgemeinen handelt es sich bei ASGI-Middleware um Klassen, die als erstes Argument eine ASGI-Anwendung erwarten.
 
-In der Dokumentation für ASGI-Middlewares von Drittanbietern wird Ihnen wahrscheinlich gesagt, etwa Folgendes zu tun:
+In der Dokumentation für ASGI-Middlewares von Drittanbietern wird Ihnen wahrscheinlich gesagt, dass Sie etwa Folgendes tun sollen:
 
 ```Python
 from unicorn import UnicornMiddleware
@@ -39,7 +39,7 @@ app.add_middleware(UnicornMiddleware, some_config="rainbow")
 
 `app.add_middleware()` empfängt eine Middleware-Klasse als erstes Argument und dann alle weiteren Argumente, die an die Middleware übergeben werden sollen.
 
-## Integrierte Middleware
+## Integrierte Middleware { #integrated-middlewares }
 
 **FastAPI** enthält mehrere Middlewares für gängige Anwendungsfälle. Wir werden als Nächstes sehen, wie man sie verwendet.
 
@@ -51,15 +51,15 @@ Für die nächsten Beispiele könnten Sie auch `from starlette.middleware.someth
 
 ///
 
-## `HTTPSRedirectMiddleware`
+## `HTTPSRedirectMiddleware` { #httpsredirectmiddleware }
 
-Erzwingt, dass alle eingehenden Requests entweder `https` oder `wss` sein müssen.
+Erzwingt, dass alle eingehenden <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Requests</abbr> entweder `https` oder `wss` sein müssen.
 
 Alle eingehenden Requests an `http` oder `ws` werden stattdessen an das sichere Schema umgeleitet.
 
 {* ../../docs_src/advanced_middleware/tutorial001.py hl[2,6] *}
 
-## `TrustedHostMiddleware`
+## `TrustedHostMiddleware` { #trustedhostmiddleware }
 
 Erzwingt, dass alle eingehenden Requests einen korrekt gesetzten `Host`-Header haben, um sich vor HTTP-Host-Header-Angriffen zu schützen.
 
@@ -69,9 +69,9 @@ Die folgenden Argumente werden unterstützt:
 
 * `allowed_hosts` – Eine Liste von Domain-Namen, die als Hostnamen zulässig sein sollten. Wildcard-Domains wie `*.example.com` werden unterstützt, um Subdomains zu matchen. Um jeden Hostnamen zu erlauben, verwenden Sie entweder `allowed_hosts=["*"]` oder lassen Sie diese Middleware weg.
 
-Wenn ein eingehender Request nicht korrekt validiert wird, wird eine „400“-Response gesendet.
+Wenn ein eingehender Request nicht korrekt validiert wird, wird eine `400`-<abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> gesendet.
 
-## `GZipMiddleware`
+## `GZipMiddleware` { #gzipmiddleware }
 
 Verarbeitet GZip-Responses für alle Requests, die `"gzip"` im `Accept-Encoding`-Header enthalten.
 
@@ -81,9 +81,10 @@ Diese Middleware verarbeitet sowohl Standard- als auch Streaming-Responses.
 
 Die folgenden Argumente werden unterstützt:
 
-* `minimum_size` – Antworten, die kleiner als diese Mindestgröße in Bytes sind, nicht per GZip komprimieren. Der Defaultwert ist `500`.
+* `minimum_size` – Responsen, die kleiner als diese Mindestgröße in Bytes sind, nicht per GZip komprimieren. Der Defaultwert ist `500`.
+* `compresslevel` – Wird während der GZip-Kompression verwendet. Es ist ein Ganzzahlwert zwischen 1 und 9. Der Defaultwert ist `9`. Ein niedrigerer Wert resultiert in schnellerer Kompression, aber größeren Dateigrößen, während ein höherer Wert langsamere Kompression, aber kleinere Dateigrößen zur Folge hat.
 
-## Andere Middlewares
+## Andere Middlewares { #other-middlewares }
 
 Es gibt viele andere ASGI-Middlewares.
 

docs/de/docs/advanced/openapi-callbacks.md

@@ -1,12 +1,12 @@
-# OpenAPI-Callbacks
+# OpenAPI Callbacks { #openapi-callbacks }
 
-Sie könnten eine API mit einer *Pfadoperation* erstellen, die einen Request an eine *externe API* auslösen könnte, welche von jemand anderem erstellt wurde (wahrscheinlich derselbe Entwickler, der Ihre API *verwenden* würde).
+Sie könnten eine API mit einer *Pfadoperation* erstellen, die einen <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> an eine *externe API* auslösen könnte, welche von jemand anderem erstellt wurde (wahrscheinlich derselbe Entwickler, der Ihre API *verwenden* würde).
 
 Der Vorgang, der stattfindet, wenn Ihre API-Anwendung die *externe API* aufruft, wird als „Callback“ („Rückruf“) bezeichnet. Denn die Software, die der externe Entwickler geschrieben hat, sendet einen Request an Ihre API und dann *ruft Ihre API zurück* (*calls back*) und sendet einen Request an eine *externe API* (die wahrscheinlich vom selben Entwickler erstellt wurde).
 
-In diesem Fall möchten Sie möglicherweise dokumentieren, wie diese externe API aussehen *sollte*. Welche *Pfadoperation* sie haben sollte, welchen Body sie erwarten sollte, welche Response sie zurückgeben sollte, usw.
+In diesem Fall möchten Sie möglicherweise dokumentieren, wie diese externe API aussehen *sollte*. Welche *Pfadoperation* sie haben sollte, welchen Body sie erwarten sollte, welche <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> sie zurückgeben sollte, usw.
 
-## Eine Anwendung mit Callbacks
+## Eine Anwendung mit Callbacks { #an-app-with-callbacks }
 
 Sehen wir uns das alles anhand eines Beispiels an.
 
@@ -16,14 +16,14 @@ Diese Rechnungen haben eine `id`, einen optionalen `title`, einen `customer` (Ku
 
 Der Benutzer Ihrer API (ein externer Entwickler) erstellt mit einem POST-Request eine Rechnung in Ihrer API.
 
-Dann wird Ihre API (beispielsweise):
+Dann wird Ihre API (stellen wir uns vor):
 
 * die Rechnung an einen Kunden des externen Entwicklers senden.
 * das Geld einsammeln.
 * eine Benachrichtigung an den API-Benutzer (den externen Entwickler) zurücksenden.
     * Dies erfolgt durch Senden eines POST-Requests (von *Ihrer API*) an eine *externe API*, die von diesem externen Entwickler bereitgestellt wird (das ist der „Callback“).
 
-## Die normale **FastAPI**-Anwendung
+## Die normale **FastAPI**-Anwendung { #the-normal-fastapi-app }
 
 Sehen wir uns zunächst an, wie die normale API-Anwendung aussehen würde, bevor wir den Callback hinzufügen.
 
@@ -41,7 +41,7 @@ Der Query-Parameter `callback_url` verwendet einen Pydantic-<a href="https://doc
 
 Das einzig Neue ist `callbacks=invoices_callback_router.routes` als Argument für den *Pfadoperation-Dekorator*. Wir werden als Nächstes sehen, was das ist.
 
-## Dokumentation des Callbacks
+## Dokumentation des Callbacks { #documenting-the-callback }
 
 Der tatsächliche Callback-Code hängt stark von Ihrer eigenen API-Anwendung ab.
 
@@ -70,7 +70,7 @@ Wenn Sie den Callback selbst implementieren, können Sie beispielsweise <a href=
 
 ///
 
-## Schreiben des Codes, der den Callback dokumentiert
+## Schreiben des Codes, der den Callback dokumentiert { #write-the-callback-documentation-code }
 
 Dieser Code wird nicht in Ihrer Anwendung ausgeführt, wir benötigen ihn nur, um zu *dokumentieren*, wie diese *externe API* aussehen soll.
 
@@ -86,13 +86,13 @@ Wenn Sie diese Sichtweise (des *externen Entwicklers*) vorübergehend übernehme
 
 ///
 
-### Einen Callback-`APIRouter` erstellen
+### Einen Callback-`APIRouter` erstellen { #create-a-callback-apirouter }
 
 Erstellen Sie zunächst einen neuen `APIRouter`, der einen oder mehrere Callbacks enthält.
 
 {* ../../docs_src/openapi_callbacks/tutorial001.py hl[3,25] *}
 
-### Die Callback-*Pfadoperation* erstellen
+### Die Callback-*Pfadoperation* erstellen { #create-the-callback-path-operation }
 
 Um die Callback-*Pfadoperation* zu erstellen, verwenden Sie denselben `APIRouter`, den Sie oben erstellt haben.
 
@@ -108,7 +108,7 @@ Es gibt zwei Hauptunterschiede zu einer normalen *Pfadoperation*:
 * Es muss kein tatsächlicher Code vorhanden sein, da Ihre Anwendung diesen Code niemals aufruft. Sie wird nur zur Dokumentation der *externen API* verwendet. Die Funktion könnte also einfach `pass` enthalten.
 * Der *Pfad* kann einen <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression" class="external-link" target="_blank">OpenAPI-3-Ausdruck</a> enthalten (mehr dazu weiter unten), wo er Variablen mit Parametern und Teilen des ursprünglichen Requests verwenden kann, der an *Ihre API* gesendet wurde.
 
-### Der Callback-Pfadausdruck
+### Der Callback-Pfadausdruck { #the-callback-path-expression }
 
 Der Callback-*Pfad* kann einen <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression" class="external-link" target="_blank">OpenAPI-3-Ausdruck</a> enthalten, welcher Teile des ursprünglichen Requests enthalten kann, der an *Ihre API* gesendet wurde.
 
@@ -163,7 +163,7 @@ Beachten Sie, dass die verwendete Callback-URL die URL enthält, die als Query-P
 
 ///
 
-### Den Callback-Router hinzufügen
+### Den Callback-Router hinzufügen { #add-the-callback-router }
 
 An diesem Punkt haben Sie die benötigte(n) *Callback-Pfadoperation(en)* (diejenige(n), die der *externe Entwickler* in der *externen API* implementieren sollte) im Callback-Router, den Sie oben erstellt haben.
 
@@ -177,9 +177,9 @@ Beachten Sie, dass Sie nicht den Router selbst (`invoices_callback_router`) an `
 
 ///
 
-### Es in der Dokumentation ansehen
+### Es in der Dokumentation testen { #check-the-docs }
 
-Jetzt können Sie Ihre Anwendung mit Uvicorn starten und auf <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> gehen.
+Jetzt können Sie Ihre Anwendung starten und zu <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> gehen.
 
 Sie sehen Ihre Dokumentation, einschließlich eines Abschnitts „Callbacks“ für Ihre *Pfadoperation*, der zeigt, wie die *externe API* aussehen sollte:
 

docs/de/docs/advanced/openapi-webhooks.md

@@ -1,54 +1,54 @@
-# OpenAPI-Webhooks
+# OpenAPI Webhooks { #openapi-webhooks }
 
-Es gibt Fälle, in denen Sie Ihren API-Benutzern mitteilen möchten, dass Ihre Anwendung mit einigen Daten *deren* Anwendung aufrufen (ein Request senden) könnte, normalerweise um über ein bestimmtes **Event** zu **benachrichtigen**.
+Es gibt Fälle, in denen Sie Ihren API-**Benutzern** mitteilen möchten, dass Ihre App *deren* App mit einigen Daten aufrufen (einen <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> senden) könnte, normalerweise um über ein bestimmtes **Event** zu **benachrichtigen**.
 
-Das bedeutet, dass anstelle des normalen Prozesses, bei dem Benutzer Requests an Ihre API senden, **Ihre API** (oder Ihre Anwendung) **Requests an deren System** (an deren API, deren Anwendung) senden könnte.
+Das bedeutet, dass anstelle des normalen Prozesses, bei dem Ihre Benutzer Requests an Ihre API senden, **Ihre API** (oder Ihre App) **Requests an deren System** (an deren API, deren App) senden könnte.
 
-Das wird normalerweise als **Webhook** bezeichnet.
+Das wird normalerweise als **Web<abbr title="Haken, Einhängepunkt">hook</abbr>** bezeichnet.
 
-## Webhooks-Schritte
+## Webhooks-Schritte { #webhooks-steps }
 
 Der Prozess besteht normalerweise darin, dass **Sie in Ihrem Code definieren**, welche Nachricht Sie senden möchten, den **Body des Requests**.
 
-Sie definieren auch auf irgendeine Weise, zu welchen **Momenten** Ihre Anwendung diese Requests oder Events sendet.
+Sie definieren auch auf irgendeine Weise, in welchen **Momenten** Ihre App diese Requests oder Events senden wird.
 
-Und **Ihre Benutzer** definieren auf irgendeine Weise (zum Beispiel irgendwo in einem Web-Dashboard) die **URL**, an die Ihre Anwendung diese Requests senden soll.
+Und **Ihre Benutzer** definieren auf irgendeine Weise (zum Beispiel irgendwo in einem Web-<abbr title="Benutzeroberfläche für das Visualisieren und Managen von Daten">Dashboard</abbr>) die **URL**, an die Ihre App diese Requests senden soll.
 
 Die gesamte **Logik** zur Registrierung der URLs für Webhooks und der Code zum tatsächlichen Senden dieser Requests liegt bei Ihnen. Sie schreiben es so, wie Sie möchten, in **Ihrem eigenen Code**.
 
-## Webhooks mit **FastAPI** und OpenAPI dokumentieren
+## Webhooks mit **FastAPI** und OpenAPI dokumentieren { #documenting-webhooks-with-fastapi-and-openapi }
 
-Mit **FastAPI** können Sie mithilfe von OpenAPI die Namen dieser Webhooks, die Arten von HTTP-Operationen, die Ihre Anwendung senden kann (z. B. `POST`, `PUT`, usw.) und die Request**bodys** definieren, die Ihre Anwendung senden würde.
+Mit **FastAPI**, mithilfe von OpenAPI, können Sie die Namen dieser Webhooks, die Arten von HTTP-Operationen, die Ihre App senden kann (z. B. `POST`, `PUT`, usw.) und die Request**bodys** definieren, die Ihre App senden würde.
 
-Dies kann es Ihren Benutzern viel einfacher machen, **deren APIs zu implementieren**, um Ihre **Webhook**-Requests zu empfangen. Möglicherweise können diese sogar einen Teil des eigenem API-Codes automatisch generieren.
+Dies kann es Ihren Benutzern viel einfacher machen, **deren APIs zu implementieren**, um Ihre **Webhook**-Requests zu empfangen. Möglicherweise können diese sogar einen Teil ihres eigenen API-Codes automatisch generieren.
 
-/// info
+/// info | Info
 
 Webhooks sind in OpenAPI 3.1.0 und höher verfügbar und werden von FastAPI `0.99.0` und höher unterstützt.
 
 ///
 
-## Eine Anwendung mit Webhooks
+## Eine App mit Webhooks { #an-app-with-webhooks }
 
-Wenn Sie eine **FastAPI**-Anwendung erstellen, gibt es ein `webhooks`-Attribut, mit dem Sie *Webhooks* definieren können, genauso wie Sie *Pfadoperationen* definieren würden, zum Beispiel mit `@app.webhooks.post()`.
+Wenn Sie eine **FastAPI**-Anwendung erstellen, gibt es ein `webhooks`-Attribut, das Sie verwenden können, um *Webhooks* zu definieren, genauso wie Sie *Pfadoperationen* definieren würden, zum Beispiel mit `@app.webhooks.post()`.
 
 {* ../../docs_src/openapi_webhooks/tutorial001.py hl[9:13,36:53] *}
 
 Die von Ihnen definierten Webhooks landen im **OpenAPI**-Schema und der automatischen **Dokumentations-Oberfläche**.
 
-/// info
+/// info | Info
 
-Das `app.webhooks`-Objekt ist eigentlich nur ein `APIRouter`, derselbe Typ, den Sie verwenden würden, wenn Sie Ihre Anwendung mit mehreren Dateien strukturieren.
+Das `app.webhooks`-Objekt ist eigentlich nur ein `APIRouter`, derselbe Typ, den Sie verwenden würden, wenn Sie Ihre App mit mehreren Dateien strukturieren.
 
 ///
 
-Beachten Sie, dass Sie bei Webhooks tatsächlich keinen *Pfad* (wie `/items/`) deklarieren, sondern dass der Text, den Sie dort übergeben, lediglich eine **Kennzeichnung** des Webhooks (der Name des Events) ist. Zum Beispiel ist in `@app.webhooks.post("new-subscription")` der Webhook-Name `new-subscription`.
+Beachten Sie, dass Sie bei Webhooks tatsächlich keinen *Pfad* (wie `/items/`) deklarieren, der Text, den Sie dort übergeben, ist lediglich eine **Kennzeichnung** des Webhooks (der Name des Events). Zum Beispiel ist in `@app.webhooks.post("new-subscription")` der Webhook-Name `new-subscription`.
 
-Das liegt daran, dass erwartet wird, dass **Ihre Benutzer** den tatsächlichen **URL-Pfad**, an dem diese den Webhook-Request empfangen möchten, auf andere Weise definieren (z. B. über ein Web-Dashboard).
+Das liegt daran, dass erwartet wird, dass **Ihre Benutzer** den tatsächlichen **URL-Pfad**, an dem sie den Webhook-Request empfangen möchten, auf andere Weise definieren (z. B. über ein Web-Dashboard).
 
-### Es in der Dokumentation ansehen
+### Die Dokumentation testen { #check-the-docs }
 
-Jetzt können Sie Ihre Anwendung mit Uvicorn starten und auf <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> gehen.
+Jetzt können Sie Ihre App starten und zu <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> gehen.
 
 Sie werden sehen, dass Ihre Dokumentation die normalen *Pfadoperationen* und jetzt auch einige **Webhooks** enthält:
 

docs/de/docs/advanced/path-operation-advanced-configuration.md

@@ -1,6 +1,6 @@
-# Fortgeschrittene Konfiguration der Pfadoperation
+# Fortgeschrittene Konfiguration der Pfadoperation { #path-operation-advanced-configuration }
 
-## OpenAPI operationId
+## OpenAPI operationId { #openapi-operationid }
 
 /// warning | Achtung
 
@@ -14,13 +14,13 @@ Sie müssten sicherstellen, dass sie für jede Operation eindeutig ist.
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial001.py hl[6] *}
 
-### Verwendung des Namens der *Pfadoperation-Funktion* als operationId
+### Verwendung des Namens der *Pfadoperation-Funktion* als operationId { #using-the-path-operation-function-name-as-the-operationid }
 
 Wenn Sie die Funktionsnamen Ihrer API als `operationId`s verwenden möchten, können Sie über alle iterieren und die `operation_id` jeder *Pfadoperation* mit deren `APIRoute.name` überschreiben.
 
 Sie sollten dies tun, nachdem Sie alle Ihre *Pfadoperationen* hinzugefügt haben.
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial002.py hl[2,12:21,24] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial002.py hl[2, 12:21, 24] *}
 
 /// tip | Tipp
 
@@ -36,13 +36,13 @@ Auch wenn diese sich in unterschiedlichen Modulen (Python-Dateien) befinden.
 
 ///
 
-## Von OpenAPI ausschließen
+## Von OpenAPI ausschließen { #exclude-from-openapi }
 
 Um eine *Pfadoperation* aus dem generierten OpenAPI-Schema (und damit aus den automatischen Dokumentationssystemen) auszuschließen, verwenden Sie den Parameter `include_in_schema` und setzen Sie ihn auf `False`:
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial003.py hl[6] *}
 
-## Fortgeschrittene Beschreibung mittels Docstring
+## Fortgeschrittene Beschreibung mittels Docstring { #advanced-description-from-docstring }
 
 Sie können die verwendeten Zeilen aus dem Docstring einer *Pfadoperation-Funktion* einschränken, die für OpenAPI verwendet werden.
 
@@ -52,17 +52,17 @@ Sie wird nicht in der Dokumentation angezeigt, aber andere Tools (z. B. Sphinx)
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial004.py hl[19:29] *}
 
-## Zusätzliche Responses
+## Zusätzliche Responses { #additional-responses }
 
 Sie haben wahrscheinlich gesehen, wie man das `response_model` und den `status_code` für eine *Pfadoperation* deklariert.
 
-Das definiert die Metadaten der Haupt-Response einer *Pfadoperation*.
+Das definiert die Metadaten der Haupt-<abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> einer *Pfadoperation*.
 
 Sie können auch zusätzliche Responses mit deren Modellen, Statuscodes usw. deklarieren.
 
 Es gibt hier in der Dokumentation ein ganzes Kapitel darüber, Sie können es unter [Zusätzliche Responses in OpenAPI](additional-responses.md){.internal-link target=_blank} lesen.
 
-## OpenAPI-Extra
+## OpenAPI-Extra { #openapi-extra }
 
 Wenn Sie in Ihrer Anwendung eine *Pfadoperation* deklarieren, generiert **FastAPI** automatisch die relevanten Metadaten dieser *Pfadoperation*, die in das OpenAPI-Schema aufgenommen werden sollen.
 
@@ -88,9 +88,9 @@ Wenn Sie nur zusätzliche Responses deklarieren müssen, können Sie dies bequem
 
 Sie können das OpenAPI-Schema für eine *Pfadoperation* erweitern, indem Sie den Parameter `openapi_extra` verwenden.
 
-### OpenAPI-Erweiterungen
+### OpenAPI-Erweiterungen { #openapi-extensions }
 
-Dieses `openapi_extra` kann beispielsweise hilfreich sein, um <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#specificationExtensions" class="external-link" target="_blank">OpenAPI-Erweiterungen</a> zu deklarieren:
+Dieses `openapi_extra` kann beispielsweise hilfreich sein, um [OpenAPI-Erweiterungen](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#specificationExtensions) zu deklarieren:
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial005.py hl[6] *}
 
@@ -129,43 +129,43 @@ Und wenn Sie die resultierende OpenAPI sehen (unter `/openapi.json` in Ihrer API
 }
 ```
 
-### Benutzerdefiniertes OpenAPI-*Pfadoperation*-Schema
+### Benutzerdefiniertes OpenAPI-*Pfadoperation*-Schema { #custom-openapi-path-operation-schema }
 
-Das Dictionary in `openapi_extra` wird mit dem automatisch generierten OpenAPI-Schema für die *Pfadoperation* zusammengeführt (mittels Deep Merge).
+Das <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">Dictionary</abbr> in `openapi_extra` wird mit dem automatisch generierten OpenAPI-Schema für die *Pfadoperation* zusammengeführt (mittels Deep Merge).
 
 Sie können dem automatisch generierten Schema also zusätzliche Daten hinzufügen.
 
-Sie könnten sich beispielsweise dafür entscheiden, den Request mit Ihrem eigenen Code zu lesen und zu validieren, ohne die automatischen Funktionen von FastAPI mit Pydantic zu verwenden, aber Sie könnten den Request trotzdem im OpenAPI-Schema definieren wollen.
+Sie könnten sich beispielsweise dafür entscheiden, den <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> mit Ihrem eigenen Code zu lesen und zu validieren, ohne die automatischen Funktionen von FastAPI mit Pydantic zu verwenden, aber Sie könnten den Request trotzdem im OpenAPI-Schema definieren wollen.
 
 Das könnte man mit `openapi_extra` machen:
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial006.py hl[20:37,39:40] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial006.py hl[19:36, 39:40] *}
 
-In diesem Beispiel haben wir kein Pydantic-Modell deklariert. Tatsächlich wird der Requestbody nicht einmal als JSON <abbr title="von einem einfachen Format, wie Bytes, in Python-Objekte konvertieren">geparst</abbr>, sondern direkt als `bytes` gelesen und die Funktion `magic_data_reader ()` wäre dafür verantwortlich, ihn in irgendeiner Weise zu parsen.
+In diesem Beispiel haben wir kein Pydantic-Modell deklariert. Tatsächlich wird der Requestbody nicht einmal als JSON <abbr title="von einem einfachen Format, wie Bytes, in Python-Objekte konvertieren">geparst</abbr>, sondern direkt als `bytes` gelesen und die Funktion `magic_data_reader()` wäre dafür verantwortlich, ihn in irgendeiner Weise zu parsen.
 
 Dennoch können wir das zu erwartende Schema für den Requestbody deklarieren.
 
-### Benutzerdefinierter OpenAPI-Content-Type
+### Benutzerdefinierter OpenAPI-Content-Type { #custom-openapi-content-type }
 
 Mit demselben Trick könnten Sie ein Pydantic-Modell verwenden, um das JSON-Schema zu definieren, das dann im benutzerdefinierten Abschnitt des OpenAPI-Schemas für die *Pfadoperation* enthalten ist.
 
-Und Sie könnten dies auch tun, wenn der Datentyp in der Anfrage nicht JSON ist.
+Und Sie könnten dies auch tun, wenn der Datentyp im Request nicht JSON ist.
 
 In der folgenden Anwendung verwenden wir beispielsweise weder die integrierte Funktionalität von FastAPI zum Extrahieren des JSON-Schemas aus Pydantic-Modellen noch die automatische Validierung für JSON. Tatsächlich deklarieren wir den Request-Content-Type als YAML und nicht als JSON:
 
 //// tab | Pydantic v2
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007.py hl[17:22,24] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007.py hl[17:22, 24] *}
 
 ////
 
 //// tab | Pydantic v1
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1.py hl[17:22,24] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1.py hl[17:22, 24] *}
 
 ////
 
-/// info
+/// info | Info
 
 In Pydantic Version 1 hieß die Methode zum Abrufen des JSON-Schemas für ein Modell `Item.schema()`, in Pydantic Version 2 heißt die Methode `Item.model_json_schema()`.
 
@@ -189,7 +189,7 @@ Und dann parsen wir in unserem Code diesen YAML-Inhalt direkt und verwenden dann
 
 ////
 
-/// info
+/// info | Info
 
 In Pydantic Version 1 war die Methode zum Parsen und Validieren eines Objekts `Item.parse_obj()`, in Pydantic Version 2 heißt die Methode `Item.model_validate()`.
 

docs/de/docs/advanced/response-change-status-code.md

@@ -1,31 +1,31 @@
-# Response – Statuscode ändern
+# Response – Statuscode ändern { #response-change-status-code }
 
-Sie haben wahrscheinlich schon vorher gelesen, dass Sie einen Standard-[Response-Statuscode](../tutorial/response-status-code.md){.internal-link target=_blank} festlegen können.
+Sie haben wahrscheinlich schon vorher gelesen, dass Sie einen Default-[Response-Statuscode](../tutorial/response-status-code.md){.internal-link target=_blank} festlegen können.
 
-In manchen Fällen müssen Sie jedoch einen anderen als den Standard-Statuscode zurückgeben.
+In manchen Fällen müssen Sie jedoch einen anderen als den Default-Statuscode zurückgeben.
 
-## Anwendungsfall
+## Anwendungsfall { #use-case }
 
 Stellen Sie sich zum Beispiel vor, Sie möchten standardmäßig den HTTP-Statuscode „OK“ `200` zurückgeben.
 
-Wenn die Daten jedoch nicht vorhanden waren, möchten Sie diese erstellen und den HTTP-Statuscode „CREATED“ `201` zurückgeben.
+Wenn die Daten jedoch nicht vorhanden sind, möchten Sie diese erstellen und den HTTP-Statuscode „CREATED“ `201` zurückgeben.
 
 Sie möchten aber dennoch in der Lage sein, die von Ihnen zurückgegebenen Daten mit einem `response_model` zu filtern und zu konvertieren.
 
 In diesen Fällen können Sie einen `Response`-Parameter verwenden.
 
-## Einen `Response`-Parameter verwenden
+## Einen `Response`-Parameter verwenden { #use-a-response-parameter }
 
 Sie können einen Parameter vom Typ `Response` in Ihrer *Pfadoperation-Funktion* deklarieren (wie Sie es auch für Cookies und Header tun können).
 
-Anschließend können Sie den `status_code` in diesem *vorübergehenden* Response-Objekt festlegen.
+Anschließend können Sie den `status_code` in diesem *vorübergehenden* <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr>-Objekt festlegen.
 
 {* ../../docs_src/response_change_status_code/tutorial001.py hl[1,9,12] *}
 
-Und dann können Sie wie gewohnt jedes benötigte Objekt zurückgeben (ein `dict`, ein Datenbankmodell usw.).
+Und dann können Sie jedes benötigte Objekt zurückgeben, wie Sie es normalerweise tun würden (ein `dict`, ein Datenbankmodell usw.).
 
 Und wenn Sie ein `response_model` deklariert haben, wird es weiterhin zum Filtern und Konvertieren des von Ihnen zurückgegebenen Objekts verwendet.
 
 **FastAPI** verwendet diese *vorübergehende* Response, um den Statuscode (auch Cookies und Header) zu extrahieren und fügt diese in die endgültige Response ein, die den von Ihnen zurückgegebenen Wert enthält, gefiltert nach einem beliebigen `response_model`.
 
-Sie können den Parameter `Response` auch in Abhängigkeiten deklarieren und den Statuscode darin festlegen. Bedenken Sie jedoch, dass der gewinnt, welcher zuletzt gesetzt wird.
+Sie können den Parameter `Response` auch in Abhängigkeiten deklarieren und den Statuscode darin festlegen. Bedenken Sie jedoch, dass der zuletzt gesetzte gewinnt.

docs/de/docs/advanced/response-cookies.md

@@ -1,12 +1,12 @@
-# Response-Cookies
+# Response-Cookies { #response-cookies }
 
-## Einen `Response`-Parameter verwenden
+## Einen `Response`-Parameter verwenden { #use-a-response-parameter }
 
 Sie können einen Parameter vom Typ `Response` in Ihrer *Pfadoperation-Funktion* deklarieren.
 
-Und dann können Sie Cookies in diesem *vorübergehenden* Response-Objekt setzen.
+Und dann können Sie Cookies in diesem *vorübergehenden* <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr>-Objekt setzen.
 
-{* ../../docs_src/response_cookies/tutorial002.py hl[1,8:9] *}
+{* ../../docs_src/response_cookies/tutorial002.py hl[1, 8:9] *}
 
 Anschließend können Sie wie gewohnt jedes gewünschte Objekt zurückgeben (ein `dict`, ein Datenbankmodell, usw.).
 
@@ -16,7 +16,7 @@ Und wenn Sie ein `response_model` deklariert haben, wird es weiterhin zum Filter
 
 Sie können den `Response`-Parameter auch in Abhängigkeiten deklarieren und darin Cookies (und Header) setzen.
 
-## Eine `Response` direkt zurückgeben
+## Eine `Response` direkt zurückgeben { #return-a-response-directly }
 
 Sie können Cookies auch erstellen, wenn Sie eine `Response` direkt in Ihrem Code zurückgeben.
 
@@ -36,7 +36,7 @@ Und auch, dass Sie keine Daten senden, die durch ein `response_model` hätten ge
 
 ///
 
-### Mehr Informationen
+### Mehr Informationen { #more-info }
 
 /// note | Technische Details
 

docs/de/docs/advanced/response-directly.md

@@ -1,16 +1,16 @@
-# Eine Response direkt zurückgeben
+# Eine Response direkt zurückgeben { #return-a-response-directly }
 
-Wenn Sie eine **FastAPI** *Pfadoperation* erstellen, können Sie normalerweise beliebige Daten davon zurückgeben: ein `dict`, eine `list`e, ein Pydantic-Modell, ein Datenbankmodell, usw.
+Wenn Sie eine **FastAPI** *Pfadoperation* erstellen, können Sie normalerweise beliebige Daten davon zurückgeben: ein `dict`, eine `list`, ein Pydantic-Modell, ein Datenbankmodell, usw.
 
 Standardmäßig konvertiert **FastAPI** diesen Rückgabewert automatisch nach JSON, mithilfe des `jsonable_encoder`, der in [JSON-kompatibler Encoder](../tutorial/encoder.md){.internal-link target=_blank} erläutert wird.
 
-Dann würde es hinter den Kulissen diese JSON-kompatiblen Daten (z. B. ein `dict`) in eine `JSONResponse` einfügen, die zum Senden der Response an den Client verwendet würde.
+Dann würde es hinter den Kulissen diese JSON-kompatiblen Daten (z. B. ein `dict`) in eine `JSONResponse` einfügen, die zum Senden der <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> an den Client verwendet wird.
 
 Sie können jedoch direkt eine `JSONResponse` von Ihren *Pfadoperationen* zurückgeben.
 
 Das kann beispielsweise nützlich sein, um benutzerdefinierte Header oder Cookies zurückzugeben.
 
-## Eine `Response` zurückgeben
+## Eine `Response` zurückgeben { #return-a-response }
 
 Tatsächlich können Sie jede `Response` oder jede Unterklasse davon zurückgeben.
 
@@ -26,7 +26,7 @@ Es wird keine Datenkonvertierung mit Pydantic-Modellen durchführen, es wird den
 
 Dadurch haben Sie viel Flexibilität. Sie können jeden Datentyp zurückgeben, jede Datendeklaration oder -validierung überschreiben, usw.
 
-## Verwendung des `jsonable_encoder` in einer `Response`
+## Verwendung des `jsonable_encoder` in einer `Response` { #using-the-jsonable-encoder-in-a-response }
 
 Da **FastAPI** keine Änderungen an einer von Ihnen zurückgegebenen `Response` vornimmt, müssen Sie sicherstellen, dass deren Inhalt dafür bereit ist.
 
@@ -38,13 +38,13 @@ In diesen Fällen können Sie den `jsonable_encoder` verwenden, um Ihre Daten zu
 
 /// note | Technische Details
 
-Sie können auch `from starlette.responses import JSONResponse` verwenden.
+Sie könnten auch `from starlette.responses import JSONResponse` verwenden.
 
 **FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, als Annehmlichkeit für Sie, den Entwickler. Die meisten verfügbaren Responses kommen aber direkt von Starlette.
 
 ///
 
-## Eine benutzerdefinierte `Response` zurückgeben
+## Eine benutzerdefinierte `Response` zurückgeben { #returning-a-custom-response }
 
 Das obige Beispiel zeigt alle Teile, die Sie benötigen, ist aber noch nicht sehr nützlich, da Sie das `item` einfach direkt hätten zurückgeben können, und **FastAPI** würde es für Sie in eine `JSONResponse` einfügen, es in ein `dict` konvertieren, usw. All das standardmäßig.
 
@@ -56,7 +56,7 @@ Sie könnten Ihren XML-Inhalt als String in eine `Response` einfügen und sie zu
 
 {* ../../docs_src/response_directly/tutorial002.py hl[1,18] *}
 
-## Anmerkungen
+## Anmerkungen { #notes }
 
 Wenn Sie eine `Response` direkt zurücksenden, werden deren Daten weder validiert, konvertiert (serialisiert), noch automatisch dokumentiert.
 

docs/de/docs/advanced/response-headers.md

@@ -1,12 +1,12 @@
-# Response-Header
+# Response-Header { #response-headers }
 
-## Verwenden Sie einen `Response`-Parameter
+## Einen `Response`-Parameter verwenden { #use-a-response-parameter }
 
 Sie können einen Parameter vom Typ `Response` in Ihrer *Pfadoperation-Funktion* deklarieren (wie Sie es auch für Cookies tun können).
 
-Und dann können Sie Header in diesem *vorübergehenden* Response-Objekt festlegen.
+Und dann können Sie Header in diesem *vorübergehenden* <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr>-Objekt festlegen.
 
-{* ../../docs_src/response_headers/tutorial002.py hl[1,7:8] *}
+{* ../../docs_src/response_headers/tutorial002.py hl[1, 7:8] *}
 
 Anschließend können Sie wie gewohnt jedes gewünschte Objekt zurückgeben (ein `dict`, ein Datenbankmodell, usw.).
 
@@ -16,7 +16,7 @@ Und wenn Sie ein `response_model` deklariert haben, wird es weiterhin zum Filter
 
 Sie können den Parameter `Response` auch in Abhängigkeiten deklarieren und darin Header (und Cookies) festlegen.
 
-## Eine `Response` direkt zurückgeben
+## Eine `Response` direkt zurückgeben { #return-a-response-directly }
 
 Sie können auch Header hinzufügen, wenn Sie eine `Response` direkt zurückgeben.
 
@@ -34,8 +34,8 @@ Und da die `Response` häufig zum Setzen von Headern und Cookies verwendet wird,
 
 ///
 
-## Benutzerdefinierte Header
+## Benutzerdefinierte Header { #custom-headers }
 
 Beachten Sie, dass benutzerdefinierte proprietäre Header <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers" class="external-link" target="_blank">mittels des Präfix 'X-'</a> hinzugefügt werden können.
 
-Wenn Sie jedoch benutzerdefinierte Header haben, die ein Client in einem Browser sehen können soll, müssen Sie diese zu Ihren CORS-Konfigurationen hinzufügen (weitere Informationen finden Sie unter [CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md){.internal-link target=_blank}), unter Verwendung des Parameters `expose_headers`, dokumentiert in <a href="https://www.starlette.io/middleware/#corsmiddleware" class="external-link" target="_blank">Starlettes CORS-Dokumentation</a>.
+Wenn Sie jedoch benutzerdefinierte Header haben, die ein Client in einem Browser sehen können soll, müssen Sie diese zu Ihrer CORS-Konfiguration hinzufügen (weitere Informationen finden Sie unter [CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md){.internal-link target=_blank}), unter Verwendung des Parameters `expose_headers`, dokumentiert in <a href="https://www.starlette.io/middleware/#corsmiddleware" class="external-link" target="_blank">Starlettes CORS-Dokumentation</a>.

docs/de/docs/advanced/security/http-basic-auth.md

@@ -1,4 +1,4 @@
-# HTTP Basic Auth
+# HTTP Basic Auth { #http-basic-auth }
 
 Für die einfachsten Fälle können Sie <abbr title="HTTP-Basisauthentifizierung">HTTP Basic Auth</abbr> verwenden.
 
@@ -12,7 +12,7 @@ Dadurch wird der Browser angewiesen, die integrierte Eingabeaufforderung für ei
 
 Wenn Sie dann den Benutzernamen und das Passwort eingeben, sendet der Browser diese automatisch im Header.
 
-## Einfaches HTTP Basic Auth
+## Einfaches HTTP Basic Auth { #simple-http-basic-auth }
 
 * Importieren Sie `HTTPBasic` und `HTTPBasicCredentials`.
 * Erstellen Sie mit `HTTPBasic` ein „`security`-Schema“.
@@ -21,11 +21,12 @@ Wenn Sie dann den Benutzernamen und das Passwort eingeben, sendet der Browser di
     * Es enthält den gesendeten `username` und das gesendete `password`.
 
 {* ../../docs_src/security/tutorial006_an_py39.py hl[4,8,12] *}
+
 Wenn Sie versuchen, die URL zum ersten Mal zu öffnen (oder in der Dokumentation auf den Button „Execute“ zu klicken), wird der Browser Sie nach Ihrem Benutzernamen und Passwort fragen:
 
 <img src="/img/tutorial/security/image12.png">
 
-## Den Benutzernamen überprüfen
+## Den Benutzernamen überprüfen { #check-the-username }
 
 Hier ist ein vollständigeres Beispiel.
 
@@ -51,13 +52,13 @@ if not (credentials.username == "stanleyjobson") or not (credentials.password ==
 
 Aber durch die Verwendung von `secrets.compare_digest()` ist dieser Code sicher vor einer Art von Angriffen, die „Timing-Angriffe“ genannt werden.
 
-### Timing-Angriffe
+### Timing-Angriffe { #timing-attacks }
 
 Aber was ist ein „Timing-Angriff“?
 
 Stellen wir uns vor, dass einige Angreifer versuchen, den Benutzernamen und das Passwort zu erraten.
 
-Und sie senden eine Anfrage mit dem Benutzernamen `johndoe` und dem Passwort `love123`.
+Und sie senden einen <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> mit dem Benutzernamen `johndoe` und dem Passwort `love123`.
 
 Dann würde der Python-Code in Ihrer Anwendung etwa so aussehen:
 
@@ -77,21 +78,21 @@ if "stanleyjobsox" == "stanleyjobson" and "love123" == "swordfish":
     ...
 ```
 
-Python muss das gesamte `stanleyjobso` in `stanleyjobsox` und `stanleyjobson` vergleichen, bevor es erkennt, dass beide Zeichenfolgen nicht gleich sind. Daher wird es einige zusätzliche Mikrosekunden dauern, bis die Antwort „Incorrect username or password“ erfolgt.
+Python muss das gesamte `stanleyjobso` in `stanleyjobsox` und `stanleyjobson` vergleichen, bevor es erkennt, dass beide Zeichenfolgen nicht gleich sind. Daher wird es einige zusätzliche Mikrosekunden dauern, bis die <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> „Incorrect username or password“ erfolgt.
 
-#### Die Zeit zum Antworten hilft den Angreifern
+#### Die Zeit zum Antworten hilft den Angreifern { #the-time-to-answer-helps-the-attackers }
 
-Wenn die Angreifer zu diesem Zeitpunkt feststellen, dass der Server einige Mikrosekunden länger braucht, um die Antwort „Incorrect username or password“ zu senden, wissen sie, dass sie _etwas_ richtig gemacht haben, einige der Anfangsbuchstaben waren richtig.
+Wenn die Angreifer zu diesem Zeitpunkt feststellen, dass der Server einige Mikrosekunden länger braucht, um die Response „Incorrect username or password“ zu senden, wissen sie, dass sie _etwas_ richtig gemacht haben, einige der Anfangsbuchstaben waren richtig.
 
 Und dann können sie es noch einmal versuchen, wohl wissend, dass es wahrscheinlich eher etwas mit `stanleyjobsox` als mit `johndoe` zu tun hat.
 
-#### Ein „professioneller“ Angriff
+#### Ein „professioneller“ Angriff { #a-professional-attack }
 
 Natürlich würden die Angreifer das alles nicht von Hand versuchen, sondern ein Programm dafür schreiben, möglicherweise mit Tausenden oder Millionen Tests pro Sekunde. Und würden jeweils nur einen zusätzlichen richtigen Buchstaben erhalten.
 
 Aber so hätten die Angreifer in wenigen Minuten oder Stunden mit der „Hilfe“ unserer Anwendung den richtigen Benutzernamen und das richtige Passwort erraten, indem sie die Zeitspanne zur Hilfe nehmen, die diese zur Beantwortung benötigt.
 
-#### Das Problem beheben mittels `secrets.compare_digest()`
+#### Das Problem beheben mittels `secrets.compare_digest()` { #fix-it-with-secrets-compare-digest }
 
 Aber in unserem Code verwenden wir tatsächlich `secrets.compare_digest()`.
 
@@ -99,7 +100,7 @@ Damit wird, kurz gesagt, der Vergleich von `stanleyjobsox` mit `stanleyjobson` g
 
 So ist Ihr Anwendungscode, dank der Verwendung von `secrets.compare_digest()`, vor dieser ganzen Klasse von Sicherheitsangriffen geschützt.
 
-### Den Error zurückgeben
+### Den Error zurückgeben { #return-the-error }
 
 Nachdem Sie festgestellt haben, dass die Anmeldeinformationen falsch sind, geben Sie eine `HTTPException` mit dem Statuscode 401 zurück (derselbe, der auch zurückgegeben wird, wenn keine Anmeldeinformationen angegeben werden) und fügen den Header `WWW-Authenticate` hinzu, damit der Browser die Anmeldeaufforderung erneut anzeigt:
 

docs/de/docs/advanced/security/index.md

@@ -1,6 +1,6 @@
-# Fortgeschrittene Sicherheit
+# Fortgeschrittene Sicherheit { #advanced-security }
 
-## Zusatzfunktionen
+## Zusatzfunktionen { #additional-features }
 
 Neben den in [Tutorial – Benutzerhandbuch: Sicherheit](../../tutorial/security/index.md){.internal-link target=_blank} behandelten Funktionen gibt es noch einige zusätzliche Funktionen zur Handhabung der Sicherheit.
 
@@ -12,8 +12,8 @@ Und es ist möglich, dass für Ihren Anwendungsfall die Lösung in einem davon l
 
 ///
 
-## Lesen Sie zuerst das Tutorial
+## Das Tutorial zuerst lesen { #read-the-tutorial-first }
 
-In den nächsten Abschnitten wird davon ausgegangen, dass Sie das Haupt-[Tutorial – Benutzerhandbuch: Sicherheit](../../tutorial/security/index.md){.internal-link target=_blank} bereits gelesen haben.
+Die nächsten Abschnitte setzen voraus, dass Sie das Haupt-[Tutorial – Benutzerhandbuch: Sicherheit](../../tutorial/security/index.md){.internal-link target=_blank} bereits gelesen haben.
 
 Sie basieren alle auf den gleichen Konzepten, ermöglichen jedoch einige zusätzliche Funktionalitäten.

docs/de/docs/advanced/security/oauth2-scopes.md

@@ -1,4 +1,4 @@
-# OAuth2-Scopes
+# OAuth2-Scopes { #oauth2-scopes }
 
 Sie können OAuth2-<abbr title="Geltungsbereiche">Scopes</abbr> direkt in **FastAPI** verwenden, sie sind nahtlos integriert.
 
@@ -26,7 +26,7 @@ Aber wenn Sie wissen, dass Sie es brauchen oder neugierig sind, lesen Sie weiter
 
 ///
 
-## OAuth2-Scopes und OpenAPI
+## OAuth2-Scopes und OpenAPI { #oauth2-scopes-and-openapi }
 
 Die OAuth2-Spezifikation definiert „Scopes“ als eine Liste von durch Leerzeichen getrennten Strings.
 
@@ -46,7 +46,7 @@ Er wird normalerweise verwendet, um bestimmte Sicherheitsberechtigungen zu dekla
 * `instagram_basic` wird von Facebook / Instagram verwendet.
 * `https://www.googleapis.com/auth/drive` wird von Google verwendet.
 
-/// info
+/// info | Info
 
 In OAuth2 ist ein „Scope“ nur ein String, der eine bestimmte erforderliche Berechtigung deklariert.
 
@@ -58,21 +58,21 @@ Für OAuth2 sind es einfach nur Strings.
 
 ///
 
-## Gesamtübersicht
+## Gesamtübersicht { #global-view }
 
 Sehen wir uns zunächst kurz die Teile an, die sich gegenüber den Beispielen im Haupt-**Tutorial – Benutzerhandbuch** für [OAuth2 mit Password (und Hashing), Bearer mit JWT-Tokens](../../tutorial/security/oauth2-jwt.md){.internal-link target=_blank} ändern. Diesmal verwenden wir OAuth2-Scopes:
 
-{* ../../docs_src/security/tutorial005_an_py310.py hl[4,8,12,46,64,105,107:115,121:124,128:134,139,155] *}
+{* ../../docs_src/security/tutorial005_an_py310.py hl[5,9,13,47,65,106,108:116,122:125,129:135,140,156] *}
 
 Sehen wir uns diese Änderungen nun Schritt für Schritt an.
 
-## OAuth2-Sicherheitsschema
+## OAuth2-Sicherheitsschema { #oauth2-security-scheme }
 
 Die erste Änderung ist, dass wir jetzt das OAuth2-Sicherheitsschema mit zwei verfügbaren Scopes deklarieren: `me` und `items`.
 
-Der `scopes`-Parameter erhält ein `dict` mit jedem Scope als Schlüssel und dessen Beschreibung als Wert:
+Der `scopes`-Parameter erhält ein <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">`dict`</abbr> mit jedem Scope als Schlüssel und dessen Beschreibung als Wert:
 
-{* ../../docs_src/security/tutorial005_an_py310.py hl[62:65] *}
+{* ../../docs_src/security/tutorial005_an_py310.py hl[63:66] *}
 
 Da wir diese Scopes jetzt deklarieren, werden sie in der API-Dokumentation angezeigt, wenn Sie sich einloggen/autorisieren.
 
@@ -82,11 +82,11 @@ Das ist derselbe Mechanismus, der verwendet wird, wenn Sie beim Anmelden mit Fac
 
 <img src="/img/tutorial/security/image11.png">
 
-## JWT-Token mit Scopes
+## JWT-Token mit Scopes { #jwt-token-with-scopes }
 
 Ändern Sie nun die Token-*Pfadoperation*, um die angeforderten Scopes zurückzugeben.
 
-Wir verwenden immer noch dasselbe `OAuth2PasswordRequestForm`. Es enthält eine Eigenschaft `scopes` mit einer `list`e von `str`s für jeden Scope, den es im Request erhalten hat.
+Wir verwenden immer noch dasselbe `OAuth2PasswordRequestForm`. Es enthält eine Eigenschaft `scopes` mit einer `list`e von `str`s für jeden Scope, den es im <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> erhalten hat.
 
 Und wir geben die Scopes als Teil des JWT-Tokens zurück.
 
@@ -98,9 +98,9 @@ Aus Sicherheitsgründen sollten Sie jedoch sicherstellen, dass Sie in Ihrer Anwe
 
 ///
 
-{* ../../docs_src/security/tutorial005_an_py310.py hl[155] *}
+{* ../../docs_src/security/tutorial005_an_py310.py hl[156] *}
 
-## Scopes in *Pfadoperationen* und Abhängigkeiten deklarieren
+## Scopes in *Pfadoperationen* und Abhängigkeiten deklarieren { #declare-scopes-in-path-operations-and-dependencies }
 
 Jetzt deklarieren wir, dass die *Pfadoperation* für `/users/me/items/` den Scope `items` erfordert.
 
@@ -124,7 +124,7 @@ Wir tun dies hier, um zu demonstrieren, wie **FastAPI** auf verschiedenen Ebenen
 
 ///
 
-{* ../../docs_src/security/tutorial005_an_py310.py hl[4,139,170] *}
+{* ../../docs_src/security/tutorial005_an_py310.py hl[5,140,171] *}
 
 /// info | Technische Details
 
@@ -136,7 +136,7 @@ Wenn Sie jedoch `Query`, `Path`, `Depends`, `Security` und andere von `fastapi`
 
 ///
 
-## `SecurityScopes` verwenden
+## `SecurityScopes` verwenden { #use-securityscopes }
 
 Aktualisieren Sie nun die Abhängigkeit `get_current_user`.
 
@@ -150,9 +150,9 @@ Wir deklarieren auch einen speziellen Parameter vom Typ `SecurityScopes`, der au
 
 Diese `SecurityScopes`-Klasse ähnelt `Request` (`Request` wurde verwendet, um das Request-Objekt direkt zu erhalten).
 
-{* ../../docs_src/security/tutorial005_an_py310.py hl[8,105] *}
+{* ../../docs_src/security/tutorial005_an_py310.py hl[9,106] *}
 
-## Die `scopes` verwenden
+## Die `scopes` verwenden { #use-the-scopes }
 
 Der Parameter `security_scopes` wird vom Typ `SecurityScopes` sein.
 
@@ -164,9 +164,9 @@ Wir erstellen eine `HTTPException`, die wir später an mehreren Stellen wiederve
 
 In diese Exception fügen wir (falls vorhanden) die erforderlichen Scopes als durch Leerzeichen getrennten String ein (unter Verwendung von `scope_str`). Wir fügen diesen String mit den Scopes in den Header `WWW-Authenticate` ein (das ist Teil der Spezifikation).
 
-{* ../../docs_src/security/tutorial005_an_py310.py hl[105,107:115] *}
+{* ../../docs_src/security/tutorial005_an_py310.py hl[106,108:116] *}
 
-## Den `username` und das Format der Daten überprüfen
+## Den `username` und das Format der Daten überprüfen { #verify-the-username-and-data-shape }
 
 Wir verifizieren, dass wir einen `username` erhalten, und extrahieren die Scopes.
 
@@ -180,17 +180,17 @@ Anstelle beispielsweise eines `dict`s oder etwas anderem, was später in der Anw
 
 Wir verifizieren auch, dass wir einen Benutzer mit diesem Benutzernamen haben, und wenn nicht, lösen wir dieselbe Exception aus, die wir zuvor erstellt haben.
 
-{* ../../docs_src/security/tutorial005_an_py310.py hl[46,116:127] *}
+{* ../../docs_src/security/tutorial005_an_py310.py hl[47,117:128] *}
 
-## Die `scopes` verifizieren
+## Die `scopes` verifizieren { #verify-the-scopes }
 
-Wir überprüfen nun, ob das empfangenen Token alle Scopes enthält, die von dieser Abhängigkeit und deren Verwendern (einschließlich *Pfadoperationen*) gefordert werden. Andernfalls lösen wir eine `HTTPException` aus.
+Wir überprüfen nun, ob das empfangene Token alle Scopes enthält, die von dieser Abhängigkeit und deren Verwendern (einschließlich *Pfadoperationen*) gefordert werden. Andernfalls lösen wir eine `HTTPException` aus.
 
 Hierzu verwenden wir `security_scopes.scopes`, das eine `list`e mit allen diesen Scopes als `str` enthält.
 
-{* ../../docs_src/security/tutorial005_an_py310.py hl[128:134] *}
+{* ../../docs_src/security/tutorial005_an_py310.py hl[129:135] *}
 
-## Abhängigkeitsbaum und Scopes
+## Abhängigkeitsbaum und Scopes { #dependency-tree-and-scopes }
 
 Sehen wir uns diesen Abhängigkeitsbaum und die Scopes noch einmal an.
 
@@ -223,7 +223,7 @@ Alles hängt von den „Scopes“ ab, die in jeder *Pfadoperation* und jeder Abh
 
 ///
 
-## Weitere Details zu `SecurityScopes`.
+## Weitere Details zu `SecurityScopes` { #more-details-about-securityscopes }
 
 Sie können `SecurityScopes` an jeder Stelle und an mehreren Stellen verwenden, es muss sich nicht in der „Wurzel“-Abhängigkeit befinden.
 
@@ -233,7 +233,7 @@ Da die `SecurityScopes` alle von den Verwendern der Abhängigkeiten deklarierten
 
 Diese werden für jede *Pfadoperation* unabhängig überprüft.
 
-## Testen Sie es
+## Es testen { #check-it }
 
 Wenn Sie die API-Dokumentation öffnen, können Sie sich authentisieren und angeben, welche Scopes Sie autorisieren möchten.
 
@@ -245,7 +245,7 @@ Und wenn Sie den Scope `me`, aber nicht den Scope `items` auswählen, können Si
 
 Das würde einer Drittanbieteranwendung passieren, die versucht, auf eine dieser *Pfadoperationen* mit einem Token zuzugreifen, das von einem Benutzer bereitgestellt wurde, abhängig davon, wie viele Berechtigungen der Benutzer dieser Anwendung erteilt hat.
 
-## Über Integrationen von Drittanbietern
+## Über Integrationen von Drittanbietern { #about-third-party-integrations }
 
 In diesem Beispiel verwenden wir den OAuth2-Flow „Password“.
 
@@ -269,6 +269,6 @@ Aber am Ende implementieren sie denselben OAuth2-Standard.
 
 **FastAPI** enthält Werkzeuge für alle diese OAuth2-Authentifizierungs-Flows in `fastapi.security.oauth2`.
 
-## `Security` in Dekorator-`dependencies`
+## `Security` in Dekorator-`dependencies` { #security-in-decorator-dependencies }
 
 Auf die gleiche Weise können Sie eine `list`e von `Depends` im Parameter `dependencies` des Dekorators definieren (wie in [Abhängigkeiten in Pfadoperation-Dekoratoren](../../tutorial/dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank} erläutert), Sie könnten auch dort `Security` mit `scopes` verwenden.

docs/de/docs/advanced/settings.md

@@ -1,4 +1,4 @@
-# Einstellungen und Umgebungsvariablen
+# Einstellungen und Umgebungsvariablen { #settings-and-environment-variables }
 
 In vielen Fällen benötigt Ihre Anwendung möglicherweise einige externe Einstellungen oder Konfigurationen, zum Beispiel geheime Schlüssel, Datenbank-Anmeldeinformationen, Anmeldeinformationen für E-Mail-Dienste, usw.
 
@@ -6,143 +6,25 @@ Die meisten dieser Einstellungen sind variabel (können sich ändern), wie z. B.
 
 Aus diesem Grund werden diese üblicherweise in Umgebungsvariablen bereitgestellt, die von der Anwendung gelesen werden.
 
-## Umgebungsvariablen
-
-/// tip | Tipp
-
-Wenn Sie bereits wissen, was „Umgebungsvariablen“ sind und wie man sie verwendet, können Sie gerne mit dem nächsten Abschnitt weiter unten fortfahren.
-
-///
-
-Eine <a href="https://de.wikipedia.org/wiki/Umgebungsvariable" class="external-link" target="_blank">Umgebungsvariable</a> (auch bekannt als „env var“) ist eine Variable, die sich außerhalb des Python-Codes im Betriebssystem befindet und von Ihrem Python-Code (oder auch von anderen Programmen) gelesen werden kann.
-
-Sie können Umgebungsvariablen in der Shell erstellen und verwenden, ohne Python zu benötigen:
-
-//// tab | Linux, macOS, Windows Bash
-
-<div class="termy">
-
-```console
-// Sie könnten eine Umgebungsvariable MY_NAME erstellen mittels
-$ export MY_NAME="Wade Wilson"
-
-// Dann könnten Sie diese mit anderen Programmen verwenden, etwa
-$ echo "Hello $MY_NAME"
-
-Hello Wade Wilson
-```
-
-</div>
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-// Erstelle eine Umgebungsvariable MY_NAME
-$ $Env:MY_NAME = "Wade Wilson"
-
-// Verwende sie mit anderen Programmen, etwa
-$ echo "Hello $Env:MY_NAME"
-
-Hello Wade Wilson
-```
-
-</div>
-
-////
-
-### Umgebungsvariablen mit Python auslesen
-
-Sie können Umgebungsvariablen auch außerhalb von Python im Terminal (oder mit einer anderen Methode) erstellen und diese dann mit Python auslesen.
-
-Sie könnten zum Beispiel eine Datei `main.py` haben mit:
-
-```Python hl_lines="3"
-import os
-
-name = os.getenv("MY_NAME", "World")
-print(f"Hello {name} from Python")
-```
-
-/// tip | Tipp
-
-Das zweite Argument für <a href="https://docs.python.org/3.8/library/os.html#os.getenv" class="external-link" target="_blank">`os.getenv()`</a> ist der zurückzugebende Defaultwert.
-
-Wenn nicht angegeben, ist er standardmäßig `None`. Hier übergeben wir `"World"` als Defaultwert.
-
-///
-
-Dann könnten Sie dieses Python-Programm aufrufen:
-
-<div class="termy">
-
-```console
-// Hier legen wir die Umgebungsvariable noch nicht fest
-$ python main.py
-
-// Da wir die Umgebungsvariable nicht festgelegt haben, erhalten wir den Standardwert
-
-Hello World from Python
-
-// Aber wenn wir zuerst eine Umgebungsvariable erstellen
-$ export MY_NAME="Wade Wilson"
-
-// Und dann das Programm erneut aufrufen
-$ python main.py
-
-// Kann es jetzt die Umgebungsvariable lesen
-
-Hello Wade Wilson from Python
-```
-
-</div>
-
-Da Umgebungsvariablen außerhalb des Codes festgelegt, aber vom Code gelesen werden können und nicht zusammen mit den übrigen Dateien gespeichert (an `git` committet) werden müssen, werden sie häufig für Konfigurationen oder Einstellungen verwendet.
-
-Sie können eine Umgebungsvariable auch nur für einen bestimmten Programmaufruf erstellen, die nur für dieses Programm und nur für dessen Dauer verfügbar ist.
-
-Erstellen Sie diese dazu direkt vor dem Programm selbst, in derselben Zeile:
-
-<div class="termy">
-
-```console
-// Erstelle eine Umgebungsvariable MY_NAME inline für diesen Programmaufruf
-$ MY_NAME="Wade Wilson" python main.py
-
-// main.py kann jetzt diese Umgebungsvariable lesen
-
-Hello Wade Wilson from Python
-
-// Die Umgebungsvariable existiert danach nicht mehr
-$ python main.py
-
-Hello World from Python
-```
-
-</div>
-
 /// tip | Tipp
 
-Weitere Informationen dazu finden Sie unter <a href="https://12factor.net/config" class="external-link" target="_blank">The Twelve-Factor App: Config</a>.
+Um Umgebungsvariablen zu verstehen, können Sie [Umgebungsvariablen](../environment-variables.md){.internal-link target=_blank} lesen.
 
 ///
 
-### Typen und Validierung
+## Typen und Validierung { #types-and-validation }
 
 Diese Umgebungsvariablen können nur Text-Zeichenketten verarbeiten, da sie außerhalb von Python liegen und mit anderen Programmen und dem Rest des Systems (und sogar mit verschiedenen Betriebssystemen wie Linux, Windows, macOS) kompatibel sein müssen.
 
 Das bedeutet, dass jeder in Python aus einer Umgebungsvariablen gelesene Wert ein `str` ist und jede Konvertierung in einen anderen Typ oder jede Validierung im Code erfolgen muss.
 
-## Pydantic `Settings`
+## Pydantic `Settings` { #pydantic-settings }
 
 Glücklicherweise bietet Pydantic ein großartiges Werkzeug zur Verarbeitung dieser Einstellungen, die von Umgebungsvariablen stammen, mit <a href="https://docs.pydantic.dev/latest/concepts/pydantic_settings/" class="external-link" target="_blank">Pydantic: Settings Management</a>.
 
-### `pydantic-settings` installieren
+### `pydantic-settings` installieren { #install-pydantic-settings }
 
-Installieren Sie zunächst das Package `pydantic-settings`:
+Stellen Sie zunächst sicher, dass Sie Ihre [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellt und aktiviert haben, und installieren Sie dann das Package `pydantic-settings`:
 
 <div class="termy">
 
@@ -164,13 +46,13 @@ $ pip install "fastapi[all]"
 
 </div>
 
-/// info
+/// info | Info
 
-In Pydantic v1 war das im Hauptpackage enthalten. Jetzt wird es als unabhängiges Package verteilt, sodass Sie wählen können, ob Sie es installieren möchten oder nicht, falls Sie die Funktionalität nicht benötigen.
+In Pydantic v1 war es im Hauptpackage enthalten. Jetzt wird es als unabhängiges Package verteilt, sodass Sie wählen können, ob Sie es installieren möchten oder nicht, falls Sie die Funktionalität nicht benötigen.
 
 ///
 
-### Das `Settings`-Objekt erstellen
+### Das `Settings`-Objekt erstellen { #create-the-settings-object }
 
 Importieren Sie `BaseSettings` aus Pydantic und erstellen Sie eine Unterklasse, ganz ähnlich wie bei einem Pydantic-Modell.
 
@@ -186,7 +68,7 @@ Sie können dieselben Validierungs-Funktionen und -Tools verwenden, die Sie für
 
 //// tab | Pydantic v1
 
-/// info
+/// info | Info
 
 In Pydantic v1 würden Sie `BaseSettings` direkt von `pydantic` statt von `pydantic_settings` importieren.
 
@@ -206,20 +88,20 @@ Wenn Sie dann eine Instanz dieser `Settings`-Klasse erstellen (in diesem Fall al
 
 Als Nächstes werden die Daten konvertiert und validiert. Wenn Sie also dieses `settings`-Objekt verwenden, verfügen Sie über Daten mit den von Ihnen deklarierten Typen (z. B. ist `items_per_user` ein `int`).
 
-### `settings` verwenden
+### `settings` verwenden { #use-the-settings }
 
 Dann können Sie das neue `settings`-Objekt in Ihrer Anwendung verwenden:
 
 {* ../../docs_src/settings/tutorial001.py hl[18:20] *}
 
-### Den Server ausführen
+### Den Server ausführen { #run-the-server }
 
 Als Nächstes würden Sie den Server ausführen und die Konfigurationen als Umgebungsvariablen übergeben. Sie könnten beispielsweise `ADMIN_EMAIL` und `APP_NAME` festlegen mit:
 
 <div class="termy">
 
 ```console
-$ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" uvicorn main:app
+$ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" fastapi run main.py
 
 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -236,9 +118,9 @@ Und dann würde die Einstellung `admin_email` auf `"deadpool@example.com"` geset
 
 Der `app_name` wäre `"ChimichangApp"`.
 
-Und `items_per_user` würde seinen Standardwert von `50` behalten.
+Und `items_per_user` würde seinen Defaultwert von `50` behalten.
 
-## Einstellungen in einem anderen Modul
+## Einstellungen in einem anderen Modul { #settings-in-another-module }
 
 Sie könnten diese Einstellungen in eine andere Moduldatei einfügen, wie Sie in [Größere Anwendungen – mehrere Dateien](../tutorial/bigger-applications.md){.internal-link target=_blank} gesehen haben.
 
@@ -256,13 +138,13 @@ Sie benötigen außerdem eine Datei `__init__.py`, wie in [Größere Anwendungen
 
 ///
 
-## Einstellungen in einer Abhängigkeit
+## Einstellungen in einer Abhängigkeit { #settings-in-a-dependency }
 
 In manchen Fällen kann es nützlich sein, die Einstellungen mit einer Abhängigkeit bereitzustellen, anstatt ein globales Objekt `settings` zu haben, das überall verwendet wird.
 
 Dies könnte besonders beim Testen nützlich sein, da es sehr einfach ist, eine Abhängigkeit mit Ihren eigenen benutzerdefinierten Einstellungen zu überschreiben.
 
-### Die Konfigurationsdatei
+### Die Konfigurationsdatei { #the-config-file }
 
 Ausgehend vom vorherigen Beispiel könnte Ihre Datei `config.py` so aussehen:
 
@@ -270,7 +152,7 @@ Ausgehend vom vorherigen Beispiel könnte Ihre Datei `config.py` so aussehen:
 
 Beachten Sie, dass wir jetzt keine Standardinstanz `settings = Settings()` erstellen.
 
-### Die Haupt-Anwendungsdatei
+### Die Haupt-Anwendungsdatei { #the-main-app-file }
 
 Jetzt erstellen wir eine Abhängigkeit, die ein neues `config.Settings()` zurückgibt.
 
@@ -288,7 +170,7 @@ Und dann können wir das von der *Pfadoperation-Funktion* als Abhängigkeit einf
 
 {* ../../docs_src/settings/app02_an_py39/main.py hl[17,19:21] *}
 
-### Einstellungen und Tests
+### Einstellungen und Tests { #settings-and-testing }
 
 Dann wäre es sehr einfach, beim Testen ein anderes Einstellungsobjekt bereitzustellen, indem man eine Abhängigkeitsüberschreibung für `get_settings` erstellt:
 
@@ -298,7 +180,7 @@ Bei der Abhängigkeitsüberschreibung legen wir einen neuen Wert für `admin_ema
 
 Dann können wir testen, ob das verwendet wird.
 
-## Lesen einer `.env`-Datei
+## Lesen einer `.env`-Datei { #reading-a-env-file }
 
 Wenn Sie viele Einstellungen haben, die sich möglicherweise oft ändern, vielleicht in verschiedenen Umgebungen, kann es nützlich sein, diese in eine Datei zu schreiben und sie dann daraus zu lesen, als wären sie Umgebungsvariablen.
 
@@ -320,7 +202,7 @@ Damit das funktioniert, müssen Sie `pip install python-dotenv` ausführen.
 
 ///
 
-### Die `.env`-Datei
+### Die `.env`-Datei { #the-env-file }
 
 Sie könnten eine `.env`-Datei haben, mit:
 
@@ -329,7 +211,7 @@ ADMIN_EMAIL="deadpool@example.com"
 APP_NAME="ChimichangApp"
 ```
 
-### Einstellungen aus `.env` lesen
+### Einstellungen aus `.env` lesen { #read-settings-from-env }
 
 Und dann aktualisieren Sie Ihre `config.py` mit:
 
@@ -339,7 +221,7 @@ Und dann aktualisieren Sie Ihre `config.py` mit:
 
 /// tip | Tipp
 
-Das Attribut `model_config` wird nur für die Pydantic-Konfiguration verwendet. Weitere Informationen finden Sie unter <a href="https://docs.pydantic.dev/latest/concepts/config/" class="external-link" target="_blank">Pydantic: Configuration</a>.
+Das Attribut `model_config` wird nur für die Pydantic-Konfiguration verwendet. Weitere Informationen finden Sie unter <a href="https://docs.pydantic.dev/latest/concepts/config/" class="external-link" target="_blank">Pydantic: Concepts: Configuration</a>.
 
 ///
 
@@ -357,17 +239,17 @@ Die Klasse `Config` wird nur für die Pydantic-Konfiguration verwendet. Weitere
 
 ////
 
-/// info
+/// info | Info
 
-In Pydantic Version 1 erfolgte die Konfiguration in einer internen Klasse `Config`, in Pydantic Version 2 erfolgt sie in einem Attribut `model_config`. Dieses Attribut akzeptiert ein `dict`. Um automatische Codevervollständigung und Inline-Fehlerberichte zu erhalten, können Sie `SettingsConfigDict` importieren und verwenden, um dieses `dict` zu definieren.
+In Pydantic Version 1 erfolgte die Konfiguration in einer internen Klasse `Config`, in Pydantic Version 2 erfolgt sie in einem Attribut `model_config`. Dieses Attribut akzeptiert ein <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">`dict`</abbr>. Um automatische Codevervollständigung und Inline-Fehlerberichte zu erhalten, können Sie `SettingsConfigDict` importieren und verwenden, um dieses `dict` zu definieren.
 
 ///
 
 Hier definieren wir die Konfiguration `env_file` innerhalb Ihrer Pydantic-`Settings`-Klasse und setzen den Wert auf den Dateinamen mit der dotenv-Datei, die wir verwenden möchten.
 
-### Die `Settings` nur einmal laden mittels `lru_cache`
+### Die `Settings` nur einmal laden mittels `lru_cache` { #creating-the-settings-only-once-with-lru-cache }
 
-Das Lesen einer Datei von der Festplatte ist normalerweise ein kostspieliger (langsamer) Vorgang, daher möchten Sie ihn wahrscheinlich nur einmal ausführen und dann dasselbe Einstellungsobjekt erneut verwenden, anstatt es für jeden Request zu lesen.
+Das Lesen einer Datei von der Festplatte ist normalerweise ein kostspieliger (langsamer) Vorgang, daher möchten Sie ihn wahrscheinlich nur einmal ausführen und dann dasselbe Einstellungsobjekt erneut verwenden, anstatt es für jeden <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> zu lesen.
 
 Aber jedes Mal, wenn wir ausführen:
 
@@ -392,7 +274,7 @@ Da wir jedoch den `@lru_cache`-Dekorator oben verwenden, wird das `Settings`-Obj
 
 Dann wird bei allen nachfolgenden Aufrufen von `get_settings()`, in den Abhängigkeiten für darauffolgende Requests, dasselbe Objekt zurückgegeben, das beim ersten Aufruf zurückgegeben wurde, anstatt den Code von `get_settings()` erneut auszuführen und ein neues `Settings`-Objekt zu erstellen.
 
-#### Technische Details zu `lru_cache`
+#### Technische Details zu `lru_cache` { #lru-cache-technical-details }
 
 `@lru_cache` ändert die Funktion, die es dekoriert, dahingehend, denselben Wert zurückzugeben, der beim ersten Mal zurückgegeben wurde, anstatt ihn erneut zu berechnen und den Code der Funktion jedes Mal auszuführen.
 
@@ -413,7 +295,7 @@ sequenceDiagram
 
 participant code as Code
 participant function as say_hi()
-participant execute as Funktion ausgeführt
+participant execute as Funktion ausführen
 
     rect rgba(0, 255, 0, .1)
         code ->> function: say_hi(name="Camila")
@@ -455,7 +337,7 @@ Auf diese Weise verhält es sich fast so, als wäre es nur eine globale Variable
 
 `@lru_cache` ist Teil von `functools`, welches Teil von Pythons Standardbibliothek ist. Weitere Informationen dazu finden Sie in der <a href="https://docs.python.org/3/library/functools.html#functools.lru_cache" class="external-link" target="_blank">Python Dokumentation für `@lru_cache`</a>.
 
-## Zusammenfassung
+## Zusammenfassung { #recap }
 
 Mit Pydantic Settings können Sie die Einstellungen oder Konfigurationen für Ihre Anwendung verwalten und dabei die gesamte Leistungsfähigkeit der Pydantic-Modelle nutzen.
 

docs/de/docs/advanced/sub-applications.md

@@ -1,41 +1,41 @@
-# Unteranwendungen – Mounts
+# Unteranwendungen – Mounts { #sub-applications-mounts }
 
 Wenn Sie zwei unabhängige FastAPI-Anwendungen mit deren eigenen unabhängigen OpenAPI und deren eigenen Dokumentationsoberflächen benötigen, können Sie eine Hauptanwendung haben und dann eine (oder mehrere) Unteranwendung(en) „mounten“.
 
-## Mounten einer **FastAPI**-Anwendung
+## Eine **FastAPI**-Anwendung mounten { #mounting-a-fastapi-application }
 
 „Mounten“ („Einhängen“) bedeutet das Hinzufügen einer völlig „unabhängigen“ Anwendung an einem bestimmten Pfad, die sich dann um die Handhabung aller unter diesem Pfad liegenden _Pfadoperationen_ kümmert, welche in dieser Unteranwendung deklariert sind.
 
-### Hauptanwendung
+### Hauptanwendung { #top-level-application }
 
 Erstellen Sie zunächst die Hauptanwendung **FastAPI** und deren *Pfadoperationen*:
 
-{* ../../docs_src/sub_applications/tutorial001.py hl[3,6:8] *}
+{* ../../docs_src/sub_applications/tutorial001.py hl[3, 6:8] *}
 
-### Unteranwendung
+### Unteranwendung { #sub-application }
 
 Erstellen Sie dann Ihre Unteranwendung und deren *Pfadoperationen*.
 
 Diese Unteranwendung ist nur eine weitere Standard-FastAPI-Anwendung, aber diese wird „gemountet“:
 
-{* ../../docs_src/sub_applications/tutorial001.py hl[11,14:16] *}
+{* ../../docs_src/sub_applications/tutorial001.py hl[11, 14:16] *}
 
-### Die Unteranwendung mounten
+### Die Unteranwendung mounten { #mount-the-sub-application }
 
 Mounten Sie in Ihrer Top-Level-Anwendung `app` die Unteranwendung `subapi`.
 
 In diesem Fall wird sie im Pfad `/subapi` gemountet:
 
-{* ../../docs_src/sub_applications/tutorial001.py hl[11,19] *}
+{* ../../docs_src/sub_applications/tutorial001.py hl[11, 19] *}
 
-### Es in der automatischen API-Dokumentation betrachten
+### Die automatische API-Dokumentation testen { #check-the-automatic-api-docs }
 
-Führen Sie nun `uvicorn` mit der Hauptanwendung aus. Wenn Ihre Datei `main.py` lautet, wäre das:
+Führen Sie nun den `fastapi`-Befehl mit Ihrer Datei aus:
 
 <div class="termy">
 
 ```console
-$ uvicorn main:app --reload
+$ fastapi dev main.py
 
 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -56,7 +56,7 @@ Sie sehen die automatische API-Dokumentation für die Unteranwendung, welche nur
 
 Wenn Sie versuchen, mit einer der beiden Benutzeroberflächen zu interagieren, funktionieren diese ordnungsgemäß, da der Browser mit jeder spezifischen Anwendung oder Unteranwendung kommunizieren kann.
 
-### Technische Details: `root_path`
+### Technische Details: `root_path` { #technical-details-root-path }
 
 Wenn Sie eine Unteranwendung wie oben beschrieben mounten, kümmert sich FastAPI darum, den Mount-Pfad für die Unteranwendung zu kommunizieren, mithilfe eines Mechanismus aus der ASGI-Spezifikation namens `root_path`.
 

docs/de/docs/advanced/templates.md

@@ -1,4 +1,4 @@
-# Templates
+# Templates { #templates }
 
 Sie können jede gewünschte Template-Engine mit **FastAPI** verwenden.
 
@@ -6,9 +6,9 @@ Eine häufige Wahl ist Jinja2, dasselbe, was auch von Flask und anderen Tools ve
 
 Es gibt Werkzeuge zur einfachen Konfiguration, die Sie direkt in Ihrer **FastAPI**-Anwendung verwenden können (bereitgestellt von Starlette).
 
-## Abhängigkeiten installieren
+## Abhängigkeiten installieren { #install-dependencies }
 
-Installieren Sie `jinja2`:
+Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellen, sie aktivieren und `jinja2` installieren:
 
 <div class="termy">
 
@@ -20,12 +20,12 @@ $ pip install jinja2
 
 </div>
 
-## Verwendung von `Jinja2Templates`
+## `Jinja2Templates` verwenden { #using-jinja2templates }
 
 * Importieren Sie `Jinja2Templates`.
 * Erstellen Sie ein `templates`-Objekt, das Sie später wiederverwenden können.
-* Deklarieren Sie einen `Request`-Parameter in der *Pfadoperation*, welcher ein Template zurückgibt.
-* Verwenden Sie die von Ihnen erstellten `templates`, um eine `TemplateResponse` zu rendern und zurückzugeben, übergeben Sie den Namen des Templates, das Requestobjekt und ein „Kontext“-Dictionary mit Schlüssel-Wert-Paaren, die innerhalb des Jinja2-Templates verwendet werden sollen.
+* Deklarieren Sie einen `<abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr>`-Parameter in der *Pfadoperation*, welcher ein Template zurückgibt.
+* Verwenden Sie die von Ihnen erstellten `templates`, um eine `TemplateResponse` zu rendern und zurückzugeben, übergeben Sie den Namen des Templates, das Requestobjekt und ein „Kontext“-<abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">Dictionary</abbr> mit Schlüssel-Wert-Paaren, die innerhalb des Jinja2-Templates verwendet werden sollen.
 
 {* ../../docs_src/templates/tutorial001.py hl[4,11,15:18] *}
 
@@ -39,7 +39,7 @@ Außerdem wurde in früheren Versionen das `request`-Objekt als Teil der Schlüs
 
 /// tip | Tipp
 
-Durch die Deklaration von `response_class=HTMLResponse` kann die Dokumentationsoberfläche erkennen, dass die Response HTML sein wird.
+Durch die Deklaration von `response_class=HTMLResponse` kann die Dokumentationsoberfläche erkennen, dass die <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> HTML sein wird.
 
 ///
 
@@ -47,11 +47,11 @@ Durch die Deklaration von `response_class=HTMLResponse` kann die Dokumentationso
 
 Sie können auch `from starlette.templating import Jinja2Templates` verwenden.
 
-**FastAPI** bietet dasselbe `starlette.templating` auch via `fastapi.templating` an, als Annehmlichkeit für Sie, den Entwickler. Es kommt aber direkt von Starlette. Das Gleiche gilt für `Request` und `StaticFiles`.
+**FastAPI** bietet dasselbe `starlette.templating` auch via `fastapi.templating` an, als Annehmlichkeit für Sie, den Entwickler. Aber die meisten der verfügbaren Responses kommen direkt von Starlette. Das Gleiche gilt für `Request` und `StaticFiles`.
 
 ///
 
-## Templates erstellen
+## Templates erstellen { #writing-templates }
 
 Dann können Sie unter `templates/item.html` ein Template erstellen, mit z. B. folgendem Inhalt:
 
@@ -59,7 +59,7 @@ Dann können Sie unter `templates/item.html` ein Template erstellen, mit z. B. f
 {!../../docs_src/templates/templates/item.html!}
 ```
 
-### Template-Kontextwerte
+### Template-Kontextwerte { #template-context-values }
 
 Im HTML, welches enthält:
 
@@ -83,7 +83,7 @@ Mit beispielsweise einer ID `42` würde das wie folgt gerendert werden:
 Item ID: 42
 ```
 
-### Template-`url_for`-Argumente
+### Template-`url_for`-Argumente { #template-url-for-arguments }
 
 Sie können `url_for()` auch innerhalb des Templates verwenden, es nimmt als Argumente dieselben Argumente, die von Ihrer *Pfadoperation-Funktion* verwendet werden.
 
@@ -105,7 +105,7 @@ Mit beispielsweise der ID `42` würde dies Folgendes ergeben:
 <a href="/items/42">
 ```
 
-## Templates und statische Dateien
+## Templates und statische Dateien { #templates-and-static-files }
 
 Sie können `url_for()` innerhalb des Templates auch beispielsweise mit den `StaticFiles` verwenden, die Sie mit `name="static"` gemountet haben.
 
@@ -119,8 +119,8 @@ In diesem Beispiel würde das zu einer CSS-Datei unter `static/styles.css` verli
 {!../../docs_src/templates/static/styles.css!}
 ```
 
-Und da Sie `StaticFiles` verwenden, wird diese CSS-Datei automatisch von Ihrer **FastAPI**-Anwendung unter der URL `/static/styles.css` bereitgestellt.
+Und da Sie `StaticFiles` verwenden, wird diese CSS-Datei automatisch von Ihrer **FastAPI**-Anwendung unter der URL `/static/styles.css` ausgeliefert.
 
-## Mehr Details
+## Mehr Details { #more-details }
 
-Weitere Informationen, einschließlich, wie man Templates testet, finden Sie in der <a href="https://www.starlette.io/templates/" class="external-link" target="_blank">Starlette Dokumentation zu Templates</a>.
+Weitere Informationen, einschließlich, wie man Templates testet, finden Sie in <a href="https://www.starlette.io/templates/" class="external-link" target="_blank">Starlettes Dokumentation zu Templates</a>.

docs/de/docs/advanced/testing-dependencies.md

@@ -1,6 +1,6 @@
-# Testen mit Ersatz für Abhängigkeiten
+# Testen mit Überschreibungen für Abhängigkeiten { #testing-dependencies-with-overrides }
 
-## Abhängigkeiten beim Testen überschreiben
+## Abhängigkeiten beim Testen überschreiben { #overriding-dependencies-during-testing }
 
 Es gibt einige Szenarien, in denen Sie beim Testen möglicherweise eine Abhängigkeit überschreiben möchten.
 
@@ -8,21 +8,21 @@ Sie möchten nicht, dass die ursprüngliche Abhängigkeit ausgeführt wird (und
 
 Stattdessen möchten Sie eine andere Abhängigkeit bereitstellen, die nur während Tests (möglicherweise nur bei einigen bestimmten Tests) verwendet wird und einen Wert bereitstellt, der dort verwendet werden kann, wo der Wert der ursprünglichen Abhängigkeit verwendet wurde.
 
-### Anwendungsfälle: Externer Service
+### Anwendungsfälle: Externer Service { #use-cases-external-service }
 
 Ein Beispiel könnte sein, dass Sie einen externen Authentifizierungsanbieter haben, mit dem Sie sich verbinden müssen.
 
 Sie senden ihm ein Token und er gibt einen authentifizierten Benutzer zurück.
 
-Dieser Anbieter berechnet Ihnen möglicherweise Gebühren pro Anfrage, und der Aufruf könnte etwas länger dauern, als wenn Sie einen vordefinierten Scheinbenutzer für Tests hätten.
+Dieser Anbieter berechnet Ihnen möglicherweise Gebühren pro <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr>, und der Aufruf könnte etwas länger dauern, als wenn Sie einen vordefinierten <abbr title="Platzhalter, vorgetäuscht, zum Schein">Mock</abbr>-Benutzer für Tests hätten.
 
 Sie möchten den externen Anbieter wahrscheinlich einmal testen, ihn aber nicht unbedingt bei jedem weiteren ausgeführten Test aufrufen.
 
-In diesem Fall können Sie die Abhängigkeit, die diesen Anbieter aufruft, überschreiben und eine benutzerdefinierte Abhängigkeit verwenden, die einen Scheinbenutzer zurückgibt, nur für Ihre Tests.
+In diesem Fall können Sie die Abhängigkeit, die diesen Anbieter aufruft, überschreiben und eine benutzerdefinierte Abhängigkeit verwenden, die einen Mock-Benutzer zurückgibt, nur für Ihre Tests.
 
-### Verwenden Sie das Attribut `app.dependency_overrides`.
+### Das Attribut `app.dependency_overrides` verwenden { #use-the-app-dependency-overrides-attribute }
 
-Für diese Fälle verfügt Ihre **FastAPI**-Anwendung über das Attribut `app.dependency_overrides`, bei diesem handelt sich um ein einfaches `dict`.
+Für diese Fälle verfügt Ihre **FastAPI**-Anwendung über das Attribut `app.dependency_overrides`, bei diesem handelt sich um ein einfaches <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">`dict`</abbr>.
 
 Um eine Abhängigkeit für das Testen zu überschreiben, geben Sie als Schlüssel die ursprüngliche Abhängigkeit (eine Funktion) und als Wert Ihre Überschreibung der Abhängigkeit (eine andere Funktion) ein.
 
@@ -46,6 +46,7 @@ Anschließend können Sie Ihre Überschreibungen zurücksetzen (entfernen), inde
 app.dependency_overrides = {}
 ```
 
+
 /// tip | Tipp
 
 Wenn Sie eine Abhängigkeit nur während einiger Tests überschreiben möchten, können Sie die Überschreibung zu Beginn des Tests (innerhalb der Testfunktion) festlegen und am Ende (am Ende der Testfunktion) zurücksetzen.

docs/de/docs/advanced/testing-events.md

@@ -1,4 +1,4 @@
-# Events testen: Hochfahren – Herunterfahren
+# Events testen: Hochfahren – Herunterfahren { #testing-events-startup-shutdown }
 
 Wenn Sie in Ihren Tests Ihre Event-Handler (`startup` und `shutdown`) ausführen wollen, können Sie den `TestClient` mit einer `with`-Anweisung verwenden:
 

docs/de/docs/advanced/testing-websockets.md

@@ -1,4 +1,4 @@
-# WebSockets testen
+# WebSockets testen { #testing-websockets }
 
 Sie können den schon bekannten `TestClient` zum Testen von WebSockets verwenden.
 
@@ -8,6 +8,6 @@ Dazu verwenden Sie den `TestClient` in einer `with`-Anweisung, eine Verbindung z
 
 /// note | Hinweis
 
-Weitere Informationen finden Sie in der Starlette-Dokumentation zum <a href="https://www.starlette.io/testclient/#testing-websocket-sessions" class="external-link" target="_blank">Testen von WebSockets</a>.
+Weitere Informationen finden Sie in Starlettes Dokumentation zum <a href="https://www.starlette.io/testclient/#testing-websocket-sessions" class="external-link" target="_blank">Testen von WebSockets</a>.
 
 ///

docs/de/docs/advanced/using-request-directly.md

@@ -1,6 +1,6 @@
-# Den Request direkt verwenden
+# Den Request direkt verwenden { #using-the-request-directly }
 
-Bisher haben Sie die Teile des Requests, die Sie benötigen, mithilfe von deren Typen deklariert.
+Bisher haben Sie die Teile des <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Requests</abbr>, die Sie benötigen, mithilfe von deren Typen deklariert.
 
 Daten nehmend von:
 
@@ -13,9 +13,9 @@ Und indem Sie das tun, validiert **FastAPI** diese Daten, konvertiert sie und ge
 
 Es gibt jedoch Situationen, in denen Sie möglicherweise direkt auf das `Request`-Objekt zugreifen müssen.
 
-## Details zum `Request`-Objekt
+## Details zum `Request`-Objekt { #details-about-the-request-object }
 
-Da **FastAPI** unter der Haube eigentlich **Starlette** ist, mit einer Ebene von mehreren Tools darüber, können Sie Starlette's <a href="https://www.starlette.io/requests/" class="external-link" target="_blank">`Request`</a>-Objekt direkt verwenden, wenn Sie es benötigen.
+Da **FastAPI** unter der Haube eigentlich **Starlette** ist, mit einer Ebene von mehreren Tools darüber, können Sie Starlettes <a href="https://www.starlette.io/requests/" class="external-link" target="_blank">`Request`</a>-Objekt direkt verwenden, wenn Sie es benötigen.
 
 Das bedeutet allerdings auch, dass, wenn Sie Daten direkt vom `Request`-Objekt nehmen (z. B. dessen Body lesen), diese von FastAPI nicht validiert, konvertiert oder dokumentiert werden (mit OpenAPI, für die automatische API-Benutzeroberfläche).
 
@@ -23,7 +23,7 @@ Obwohl jeder andere normal deklarierte Parameter (z. B. der Body, mit einem Pyda
 
 Es gibt jedoch bestimmte Fälle, in denen es nützlich ist, auf das `Request`-Objekt zuzugreifen.
 
-## Das `Request`-Objekt direkt verwenden
+## Das `Request`-Objekt direkt verwenden { #use-the-request-object-directly }
 
 Angenommen, Sie möchten auf die IP-Adresse/den Host des Clients in Ihrer *Pfadoperation-Funktion* zugreifen.
 
@@ -43,7 +43,7 @@ Auf die gleiche Weise können Sie wie gewohnt jeden anderen Parameter deklariere
 
 ///
 
-## `Request`-Dokumentation
+## `Request`-Dokumentation { #request-documentation }
 
 Weitere Details zum <a href="https://www.starlette.io/requests/" class="external-link" target="_blank">`Request`-Objekt finden Sie in der offiziellen Starlette-Dokumentation</a>.
 

docs/de/docs/advanced/websockets.md

@@ -1,10 +1,10 @@
-# WebSockets
+# WebSockets { #websockets }
 
 Sie können <a href="https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API" class="external-link" target="_blank">WebSockets</a> mit **FastAPI** verwenden.
 
-## `WebSockets` installieren
+## `websockets` installieren { #install-websockets }
 
-Zuerst müssen Sie `WebSockets` installieren:
+Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellen, sie aktivieren und `websockets` installieren (eine Python-Bibliothek, die die Verwendung von „WebSockets“, dem JavaScript-Standard, erleichtert):
 
 <div class="termy">
 
@@ -16,9 +16,9 @@ $ pip install websockets
 
 </div>
 
-## WebSockets-Client
+## WebSockets-Client { #websockets-client }
 
-### In Produktion
+### In Produktion { #in-production }
 
 In Ihrem Produktionssystem haben Sie wahrscheinlich ein Frontend, das mit einem modernen Framework wie React, Vue.js oder Angular erstellt wurde.
 
@@ -36,11 +36,11 @@ Das ist natürlich nicht optimal und man würde das nicht in der Produktion mach
 
 In der Produktion hätten Sie eine der oben genannten Optionen.
 
-Aber es ist die einfachste Möglichkeit, sich auf die Serverseite von WebSockets zu konzentrieren und ein funktionierendes Beispiel zu haben:
+Aber es ist der einfachste Weg, sich auf die Serverseite von WebSockets zu konzentrieren und ein funktionierendes Beispiel zu haben:
 
 {* ../../docs_src/websockets/tutorial001.py hl[2,6:38,41:43] *}
 
-## Einen `websocket` erstellen
+## Einen `websocket` erstellen { #create-a-websocket }
 
 Erstellen Sie in Ihrer **FastAPI**-Anwendung einen `websocket`:
 
@@ -48,13 +48,13 @@ Erstellen Sie in Ihrer **FastAPI**-Anwendung einen `websocket`:
 
 /// note | Technische Details
 
-Sie können auch `from starlette.websockets import WebSocket` verwenden.
+Sie könnten auch `from starlette.websockets import WebSocket` verwenden.
 
 **FastAPI** stellt den gleichen `WebSocket` direkt zur Verfügung, als Annehmlichkeit für Sie, den Entwickler. Er kommt aber direkt von Starlette.
 
 ///
 
-## Nachrichten erwarten und Nachrichten senden
+## Nachrichten erwarten und Nachrichten senden { #await-for-messages-and-send-messages }
 
 In Ihrer WebSocket-Route können Sie Nachrichten `await`en und Nachrichten senden.
 
@@ -62,14 +62,14 @@ In Ihrer WebSocket-Route können Sie Nachrichten `await`en und Nachrichten sende
 
 Sie können Binär-, Text- und JSON-Daten empfangen und senden.
 
-## Es ausprobieren
+## Es ausprobieren { #try-it }
 
 Wenn Ihre Datei `main.py` heißt, führen Sie Ihre Anwendung so aus:
 
 <div class="termy">
 
 ```console
-$ uvicorn main:app --reload
+$ fastapi dev main.py
 
 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -96,7 +96,7 @@ Sie können viele Nachrichten senden (und empfangen):
 
 Und alle verwenden dieselbe WebSocket-Verbindung.
 
-## Verwendung von `Depends` und anderen
+## Verwendung von `Depends` und anderen { #using-depends-and-others }
 
 In WebSocket-Endpunkten können Sie Folgendes aus `fastapi` importieren und verwenden:
 
@@ -111,7 +111,7 @@ Diese funktionieren auf die gleiche Weise wie für andere FastAPI-Endpunkte/*Pfa
 
 {* ../../docs_src/websockets/tutorial002_an_py310.py hl[68:69,82] *}
 
-/// info
+/// info | Info
 
 Da es sich um einen WebSocket handelt, macht es keinen Sinn, eine `HTTPException` auszulösen, stattdessen lösen wir eine `WebSocketException` aus.
 
@@ -119,14 +119,14 @@ Sie können einen „Closing“-Code verwenden, aus den <a href="https://tools.i
 
 ///
 
-### WebSockets mit Abhängigkeiten ausprobieren
+### WebSockets mit Abhängigkeiten ausprobieren { #try-the-websockets-with-dependencies }
 
 Wenn Ihre Datei `main.py` heißt, führen Sie Ihre Anwendung mit Folgendem aus:
 
 <div class="termy">
 
 ```console
-$ uvicorn main:app --reload
+$ fastapi dev main.py
 
 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -150,7 +150,7 @@ Damit können Sie den WebSocket verbinden und dann Nachrichten senden und empfan
 
 <img src="/img/tutorial/websockets/image05.png">
 
-## Verbindungsabbrüche und mehreren Clients handhaben
+## Verbindungsabbrüche und mehrere Clients handhaben { #handling-disconnections-and-multiple-clients }
 
 Wenn eine WebSocket-Verbindung geschlossen wird, löst `await websocket.receive_text()` eine `WebSocketDisconnect`-Exception aus, die Sie dann wie in folgendem Beispiel abfangen und behandeln können.
 
@@ -178,7 +178,7 @@ Wenn Sie etwas benötigen, das sich leicht in FastAPI integrieren lässt, aber r
 
 ///
 
-## Mehr Informationen
+## Mehr Informationen { #more-info }
 
 Weitere Informationen zu Optionen finden Sie in der Dokumentation von Starlette:
 

docs/de/docs/advanced/wsgi.md

@@ -1,10 +1,10 @@
-# WSGI inkludieren – Flask, Django und andere
+# WSGI inkludieren – Flask, Django und andere { #including-wsgi-flask-django-others }
 
 Sie können WSGI-Anwendungen mounten, wie Sie es in [Unteranwendungen – Mounts](sub-applications.md){.internal-link target=_blank}, [Hinter einem Proxy](behind-a-proxy.md){.internal-link target=_blank} gesehen haben.
 
 Dazu können Sie die `WSGIMiddleware` verwenden und damit Ihre WSGI-Anwendung wrappen, zum Beispiel Flask, Django usw.
 
-## `WSGIMiddleware` verwenden
+## `WSGIMiddleware` verwenden { #using-wsgimiddleware }
 
 Sie müssen `WSGIMiddleware` importieren.
 
@@ -12,15 +12,15 @@ Wrappen Sie dann die WSGI-Anwendung (z. B. Flask) mit der Middleware.
 
 Und dann mounten Sie das auf einem Pfad.
 
-{* ../../docs_src/wsgi/tutorial001.py hl[2:3,23] *}
+{* ../../docs_src/wsgi/tutorial001.py hl[2:3,3] *}
 
-## Es ansehen
+## Es testen { #check-it }
 
-Jetzt wird jede Anfrage unter dem Pfad `/v1/` von der Flask-Anwendung verarbeitet.
+Jetzt wird jeder <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> unter dem Pfad `/v1/` von der Flask-Anwendung verarbeitet.
 
 Und der Rest wird von **FastAPI** gehandhabt.
 
-Wenn Sie das mit Uvicorn ausführen und auf <a href="http://localhost:8000/v1/" class="external-link" target="_blank">http://localhost:8000/v1/</a> gehen, sehen Sie die Response von Flask:
+Wenn Sie das ausführen und auf <a href="http://localhost:8000/v1/" class="external-link" target="_blank">http://localhost:8000/v1/</a> gehen, sehen Sie die <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> von Flask:
 
 ```txt
 Hello, World from Flask!

docs/de/docs/alternatives.md

@@ -1,8 +1,8 @@
-# Alternativen, Inspiration und Vergleiche
+# Alternativen, Inspiration und Vergleiche { #alternatives-inspiration-and-comparisons }
 
-Was hat **FastAPI** inspiriert, ein Vergleich zu Alternativen, und was FastAPI von diesen gelernt hat.
+Was hat **FastAPI** inspiriert, wie es sich im Vergleich zu Alternativen verhält und was es von ihnen gelernt hat.
 
-## Einführung
+## Einführung { #intro }
 
 **FastAPI** würde ohne die frühere Arbeit anderer nicht existieren.
 
@@ -12,17 +12,17 @@ Ich habe die Schaffung eines neuen Frameworks viele Jahre lang vermieden. Zuerst
 
 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
+## Vorherige Tools { #previous-tools }
 
-### <a href="https://www.djangoproject.com/" class="external-link" target="_blank">Django</a>
+### <a href="https://www.djangoproject.com/" class="external-link" target="_blank">Django</a> { #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 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 <abbr title="Internet of Things">IoT</abbr>-Geräten) verwendet werden, um mit ihm zu kommunizieren.
+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 <abbr title="Internet of Things – Internet der Dinge">IoT</abbr>-Geräten) verwendet werden, um mit ihm zu kommunizieren.
 
-### <a href="https://www.django-rest-framework.org/" class="external-link" target="_blank">Django REST Framework</a>
+### <a href="https://www.django-rest-framework.org/" class="external-link" target="_blank">Django REST Framework</a> { #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.
 
@@ -42,7 +42,7 @@ Eine automatische API-Dokumentationsoberfläche zu haben.
 
 ///
 
-### <a href="https://flask.palletsprojects.com" class="external-link" target="_blank">Flask</a>
+### <a href="https://flask.palletsprojects.com" class="external-link" target="_blank">Flask</a> { #flask }
 
 Flask ist ein „Mikroframework“, es enthält weder Datenbankintegration noch viele der Dinge, die standardmäßig in Django enthalten sind.
 
@@ -64,7 +64,7 @@ Ein Mikroframework zu sein. Es einfach zu machen, die benötigten Tools und Teil
 
 ///
 
-### <a href="https://requests.readthedocs.io" class="external-link" target="_blank">Requests</a>
+### <a href="https://requests.readthedocs.io" class="external-link" target="_blank">Requests</a> { #requests }
 
 **FastAPI** ist eigentlich keine Alternative zu **Requests**. Der Umfang der beiden ist sehr unterschiedlich.
 
@@ -82,7 +82,7 @@ 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:
+Die Art und Weise, wie Sie es verwenden, ist sehr einfach. Um beispielsweise einen `GET`-<abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> zu machen, würden Sie schreiben:
 
 ```Python
 response = requests.get("http://example.com/some/url")
@@ -106,7 +106,7 @@ Sehen Sie sich die Ähnlichkeiten in `requests.get(...)` und `@app.get(...)` an.
 
 ///
 
-### <a href="https://swagger.io/" class="external-link" target="_blank">Swagger</a> / <a href="https://github.com/OAI/OpenAPI-Specification/" class="external-link" target="_blank">OpenAPI</a>
+### <a href="https://swagger.io/" class="external-link" target="_blank">Swagger</a> / <a href="https://github.com/OAI/OpenAPI-Specification/" class="external-link" target="_blank">OpenAPI</a> { #swagger-openapi }
 
 Die Hauptfunktion, die ich vom Django REST Framework haben wollte, war die automatische API-Dokumentation.
 
@@ -131,13 +131,13 @@ Diese beiden wurden ausgewählt, weil sie ziemlich beliebt und stabil sind, aber
 
 ///
 
-### Flask REST Frameworks
+### Flask REST Frameworks { #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.
 
-### <a href="https://marshmallow.readthedocs.io/en/stable/" class="external-link" target="_blank">Marshmallow</a>
+### <a href="https://marshmallow.readthedocs.io/en/stable/" class="external-link" target="_blank">Marshmallow</a> { #marshmallow }
 
-Eine der von API-Systemen benötigen Hauptfunktionen ist die Daten-„<abbr title="Auch „Marshalling“, „Konvertierung“ genannt">Serialisierung</abbr>“, 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 der von API-Systemen benötigten Hauptfunktionen ist die Daten-„<abbr title="Auch „Marshalling“, „Konvertierung“ genannt">Serialisierung</abbr>“, 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.
 
@@ -145,7 +145,7 @@ Ohne ein Datenvalidierungssystem müssten Sie alle Prüfungen manuell im Code du
 
 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 <abbr title="die Definition, wie Daten geformt sein werden sollen">Schema</abbr> zu definieren, müssen Sie bestimmte Werkzeuge und Klassen verwenden, die von Marshmallow bereitgestellt werden.
+Aber sie wurde erstellt, bevor Typhinweise in Python existierten. Um also ein <abbr title="die Definition, wie Daten geformt sein sollen">Schema</abbr> zu definieren, müssen Sie bestimmte Werkzeuge und Klassen verwenden, die von Marshmallow bereitgestellt werden.
 
 /// check | Inspirierte **FastAPI**
 
@@ -153,7 +153,7 @@ Code zu verwenden, um „Schemas“ zu definieren, welche Datentypen und Validie
 
 ///
 
-### <a href="https://webargs.readthedocs.io/en/latest/" class="external-link" target="_blank">Webargs</a>
+### <a href="https://webargs.readthedocs.io/en/latest/" class="external-link" target="_blank">Webargs</a> { #webargs }
 
 Eine weitere wichtige Funktion, die von APIs benötigt wird, ist das <abbr title="Lesen und Konvertieren nach Python-Daten">Parsen</abbr> von Daten aus eingehenden Requests.
 
@@ -163,7 +163,7 @@ Es verwendet unter der Haube Marshmallow, um die Datenvalidierung durchzuführen
 
 Es ist ein großartiges Tool und ich habe es auch oft verwendet, bevor ich **FastAPI** hatte.
 
-/// info
+/// info | Info
 
 Webargs wurde von denselben Marshmallow-Entwicklern erstellt.
 
@@ -175,7 +175,7 @@ Eingehende Requestdaten automatisch zu validieren.
 
 ///
 
-### <a href="https://apispec.readthedocs.io/en/stable/" class="external-link" target="_blank">APISpec</a>
+### <a href="https://apispec.readthedocs.io/en/stable/" class="external-link" target="_blank">APISpec</a> { #apispec }
 
 Marshmallow und Webargs bieten Validierung, Parsen und Serialisierung als Plugins.
 
@@ -193,7 +193,7 @@ Aber dann haben wir wieder das Problem einer Mikrosyntax innerhalb eines Python-
 
 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
+/// info | Info
 
 APISpec wurde von denselben Marshmallow-Entwicklern erstellt.
 
@@ -205,7 +205,7 @@ Den offenen Standard für APIs, OpenAPI, zu unterstützen.
 
 ///
 
-### <a href="https://flask-apispec.readthedocs.io/en/latest/" class="external-link" target="_blank">Flask-apispec</a>
+### <a href="https://flask-apispec.readthedocs.io/en/latest/" class="external-link" target="_blank">Flask-apispec</a> { #flask-apispec }
 
 Hierbei handelt es sich um ein Flask-Plugin, welches Webargs, Marshmallow und APISpec miteinander verbindet.
 
@@ -225,7 +225,7 @@ Die Verwendung führte zur Entwicklung mehrerer Flask-Full-Stack-Generatoren. Di
 
 Und dieselben Full-Stack-Generatoren bildeten die Basis der [**FastAPI**-Projektgeneratoren](project-generation.md){.internal-link target=_blank}.
 
-/// info
+/// info | Info
 
 Flask-apispec wurde von denselben Marshmallow-Entwicklern erstellt.
 
@@ -237,7 +237,7 @@ Das OpenAPI-Schema automatisch zu generieren, aus demselben Code, welcher die Se
 
 ///
 
-### <a href="https://nestjs.com/" class="external-link" target="_blank">NestJS</a> (und <a href="https://angular.io/" class="external-link" target="_blank">Angular</a>)
+### <a href="https://nestjs.com/" class="external-link" target="_blank">NestJS</a> (und <a href="https://angular.io/" class="external-link" target="_blank">Angular</a>) { #nestjs-and-angular }
 
 Dies ist nicht einmal Python, NestJS ist ein von Angular inspiriertes JavaScript (TypeScript) NodeJS Framework.
 
@@ -249,7 +249,7 @@ Da die Parameter mit TypeScript-Typen beschrieben werden (ähnlich den Python-Ty
 
 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.
+Es kann nicht sehr gut mit verschachtelten Modellen umgehen. Wenn es sich beim JSON-Body im Request also um ein JSON-Objekt mit inneren Feldern handelt, die wiederum verschachtelte JSON-Objekte sind, kann er nicht richtig dokumentiert und validiert werden.
 
 /// check | Inspirierte **FastAPI**
 
@@ -259,7 +259,7 @@ Python-Typen zu verwenden, um eine hervorragende Editorunterstützung zu erhalte
 
 ///
 
-### <a href="https://sanic.readthedocs.io/en/latest/" class="external-link" target="_blank">Sanic</a>
+### <a href="https://sanic.readthedocs.io/en/latest/" class="external-link" target="_blank">Sanic</a> { #sanic }
 
 Es war eines der ersten extrem schnellen Python-Frameworks, welches auf `asyncio` basierte. Es wurde so gestaltet, dass es Flask sehr ähnlich ist.
 
@@ -279,11 +279,11 @@ Aus diesem Grund basiert **FastAPI** auf Starlette, da dieses das schnellste ver
 
 ///
 
-### <a href="https://falconframework.org/" class="external-link" target="_blank">Falcon</a>
+### <a href="https://falconframework.org/" class="external-link" target="_blank">Falcon</a> { #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.
+Es ist so konzipiert, dass es über Funktionen verfügt, welche zwei Parameter empfangen, einen „<abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr>“ und eine „<abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr>“. 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.
 
@@ -297,7 +297,7 @@ Obwohl er in FastAPI optional ist und hauptsächlich zum Festlegen von Headern,
 
 ///
 
-### <a href="https://moltenframework.com/" class="external-link" target="_blank">Molten</a>
+### <a href="https://moltenframework.com/" class="external-link" target="_blank">Molten</a> { #molten }
 
 Ich habe Molten in den ersten Phasen der Entwicklung von **FastAPI** entdeckt. Und es hat ganz ähnliche Ideen:
 
@@ -321,7 +321,7 @@ Das hat tatsächlich dazu geführt, dass Teile von Pydantic aktualisiert wurden,
 
 ///
 
-### <a href="https://github.com/hugapi/hug" class="external-link" target="_blank">Hug</a>
+### <a href="https://github.com/hugapi/hug" class="external-link" target="_blank">Hug</a> { #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.
 
@@ -335,9 +335,9 @@ Es verfügt über eine interessante, ungewöhnliche Funktion: Mit demselben Fram
 
 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
+/// info | Info
 
-Hug wurde von Timothy Crosley erstellt, dem gleichen Schöpfer von <a href="https://github.com/timothycrosley/isort" class="external-link" target="_blank">`isort`</a>, einem großartigen Tool zum automatischen Sortieren von Importen in Python-Dateien.
+Hug wurde von Timothy Crosley erstellt, demselben Schöpfer von <a href="https://github.com/timothycrosley/isort" class="external-link" target="_blank">`isort`</a>, einem großartigen Tool zum automatischen Sortieren von Importen in Python-Dateien.
 
 ///
 
@@ -351,7 +351,7 @@ Hug inspirierte **FastAPI** dazu, einen `response`-Parameter in Funktionen zu de
 
 ///
 
-### <a href="https://github.com/encode/apistar" class="external-link" target="_blank">APIStar</a> (≦ 0.5)
+### <a href="https://github.com/encode/apistar" class="external-link" target="_blank">APIStar</a> (≦ 0.5) { #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.
 
@@ -375,7 +375,7 @@ Es handelte sich nicht länger um ein API-Webframework, da sich der Entwickler a
 
 Jetzt handelt es sich bei APIStar um eine Reihe von Tools zur Validierung von OpenAPI-Spezifikationen, nicht um ein Webframework.
 
-/// info
+/// info | Info
 
 APIStar wurde von Tom Christie erstellt. Derselbe, welcher Folgendes erstellt hat:
 
@@ -399,9 +399,9 @@ Ich betrachte **FastAPI** als einen „spirituellen Nachfolger“ von APIStar, w
 
 ///
 
-## Verwendet von **FastAPI**
+## Verwendet von **FastAPI** { #used-by-fastapi }
 
-### <a href="https://pydantic-docs.helpmanual.io/" class="external-link" target="_blank">Pydantic</a>
+### <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> { #pydantic }
 
 Pydantic ist eine Bibliothek zum Definieren von Datenvalidierung, Serialisierung und Dokumentation (unter Verwendung von JSON Schema) basierend auf Python-Typhinweisen.
 
@@ -417,7 +417,7 @@ Die gesamte Datenvalidierung, Datenserialisierung und automatische Modelldokumen
 
 ///
 
-### <a href="https://www.starlette.io/" class="external-link" target="_blank">Starlette</a>
+### <a href="https://www.starlette.io/" class="external-link" target="_blank">Starlette</a> { #starlette }
 
 Starlette ist ein leichtgewichtiges <abbr title="Der neue Standard für die Erstellung asynchroner Python-Webanwendungen">ASGI</abbr>-Framework/Toolkit, welches sich ideal für die Erstellung hochperformanter asynchroner Dienste eignet.
 
@@ -462,7 +462,7 @@ Alles, was Sie also mit Starlette machen können, können Sie direkt mit **FastA
 
 ///
 
-### <a href="https://www.uvicorn.org/" class="external-link" target="_blank">Uvicorn</a>
+### <a href="https://www.uvicorn.org/" class="external-link" target="_blank">Uvicorn</a> { #uvicorn }
 
 Uvicorn ist ein blitzschneller ASGI-Server, der auf uvloop und httptools basiert.
 
@@ -474,12 +474,12 @@ Es ist der empfohlene Server für Starlette und **FastAPI**.
 
 Hauptwebserver zum Ausführen von **FastAPI**-Anwendungen.
 
-Sie können ihn mit Gunicorn kombinieren, um einen asynchronen Multiprozess-Server zu erhalten.
+Sie können auch die Kommandozeilenoption `--workers` verwenden, um einen asynchronen Multiprozess-Server zu erhalten.
 
 Weitere Details finden Sie im Abschnitt [Deployment](deployment/index.md){.internal-link target=_blank}.
 
 ///
 
-## Benchmarks und Geschwindigkeit
+## Benchmarks und Geschwindigkeit { #benchmarks-and-speed }
 
 Um den Unterschied zwischen Uvicorn, Starlette und FastAPI zu verstehen, zu vergleichen und zu sehen, lesen Sie den Abschnitt über [Benchmarks](benchmarks.md){.internal-link target=_blank}.

docs/de/docs/async.md

@@ -1,8 +1,8 @@
-# Nebenläufigkeit und async / await
+# Nebenläufigkeit und async / await { #concurrency-and-async-await }
 
 Details zur `async def`-Syntax für *Pfadoperation-Funktionen* und Hintergrundinformationen zu asynchronem Code, Nebenläufigkeit und Parallelität.
 
-## In Eile?
+## In Eile? { #in-a-hurry }
 
 <abbr title="too long; didn't read – Zu lang; nicht gelesen"><strong>TL;DR:</strong></abbr>
 
@@ -12,7 +12,7 @@ Wenn Sie Bibliotheken von Dritten verwenden, die mit `await` aufgerufen werden m
 results = await some_library()
 ```
 
-Dann deklarieren Sie Ihre *Pfadoperation-Funktionen* mit `async def` wie in:
+Dann deklarieren Sie Ihre *Pfadoperation-Funktionen* mit `async def`, wie in:
 
 ```Python hl_lines="2"
 @app.get('/')
@@ -21,7 +21,7 @@ async def read_results():
     return results
 ```
 
-/// note
+/// note | Hinweis
 
 Sie können `await` nur innerhalb von Funktionen verwenden, die mit `async def` erstellt wurden.
 
@@ -29,7 +29,7 @@ Sie können `await` nur innerhalb von Funktionen verwenden, die mit `async def`
 
 ---
 
-Wenn Sie eine Bibliothek eines Dritten verwenden, die mit etwas kommuniziert (einer Datenbank, einer API, dem Dateisystem, usw.) und welche die Verwendung von `await` nicht unterstützt (dies ist derzeit bei den meisten Datenbankbibliotheken der Fall), dann deklarieren Sie Ihre *Pfadoperation-Funktionen* ganz normal nur mit `def`, etwa:
+Wenn Sie eine Bibliothek eines Dritten verwenden, die mit etwas kommuniziert (einer Datenbank, einer API, dem Dateisystem, usw.) und welche die Verwendung von `await` nicht unterstützt (dies ist derzeit bei den meisten Datenbankbibliotheken der Fall), dann deklarieren Sie Ihre *Pfadoperation-Funktionen* ganz normal nur mit `def`, wie in:
 
 ```Python hl_lines="2"
 @app.get('/')
@@ -40,7 +40,7 @@ def results():
 
 ---
 
-Wenn Ihre Anwendung (irgendwie) mit nichts anderem kommunizieren und auf dessen Antwort warten muss, verwenden Sie `async def`.
+Wenn Ihre Anwendung (irgendwie) nicht mit etwas anderem kommunizieren und auf dessen Antwort warten muss, verwenden Sie `async def`, auch wenn Sie `await` im Inneren nicht verwenden müssen.
 
 ---
 
@@ -54,9 +54,9 @@ Wie dem auch sei, in jedem der oben genannten Fälle wird FastAPI immer noch asy
 
 Wenn Sie jedoch den oben genannten Schritten folgen, können einige Performance-Optimierungen vorgenommen werden.
 
-## Technische Details
+## Technische Details { #technical-details }
 
-Moderne Versionen von Python unterstützen **„asynchronen Code“** unter Verwendung sogenannter **„Coroutinen“** mithilfe der Syntax **`async`** und **`await`**.
+Moderne Versionen von Python unterstützen **„asynchronen Code“** unter Verwendung sogenannter **„Coroutinen“** mithilfe der Syntax **`async` und `await`**.
 
 Nehmen wir obigen Satz in den folgenden Abschnitten Schritt für Schritt unter die Lupe:
 
@@ -64,13 +64,13 @@ Nehmen wir obigen Satz in den folgenden Abschnitten Schritt für Schritt unter d
 * **`async` und `await`**
 * **Coroutinen**
 
-## Asynchroner Code
+## Asynchroner Code { #asynchronous-code }
 
-Asynchroner Code bedeutet lediglich, dass die Sprache 💬 eine Möglichkeit hat, dem Computersystem / Programm 🤖 mitzuteilen, dass es 🤖 an einem bestimmten Punkt im Code darauf warten muss, dass *etwas anderes* irgendwo anders fertig wird. Nehmen wir an, *etwas anderes* ist hier „Langsam-Datei“ 📝.
+Asynchroner Code bedeutet lediglich, dass die Sprache 💬 eine Möglichkeit hat, dem Computer / Programm 🤖 mitzuteilen, dass es 🤖 an einem bestimmten Punkt im Code darauf warten muss, dass *etwas anderes* irgendwo anders fertig wird. Nehmen wir an, *etwas anderes* ist hier „Langsam-Datei“ 📝.
 
 Während der Zeit, die „Langsam-Datei“ 📝 benötigt, kann das System also andere Aufgaben erledigen.
 
-Dann kommt das System / Programm 🤖 bei jeder Gelegenheit zurück, wenn es entweder wieder wartet, oder wann immer es 🤖 die ganze Arbeit erledigt hat, die zu diesem Zeitpunkt zu tun war. Und es 🤖 wird nachschauen, ob eine der Aufgaben, auf die es gewartet hat, fertig damit ist, zu tun, was sie tun sollte.
+Dann kommt der Computer / das Programm 🤖 bei jeder Gelegenheit zurück, weil es entweder wieder wartet oder wann immer es 🤖 die ganze Arbeit erledigt hat, die zu diesem Zeitpunkt zu tun war. Und es 🤖 wird nachschauen, ob eine der Aufgaben, auf die es gewartet hat, fertig ist.
 
 Dann nimmt es 🤖 die erste erledigte Aufgabe (sagen wir, unsere „Langsam-Datei“ 📝) und bearbeitet sie weiter.
 
@@ -87,13 +87,13 @@ Das „Warten auf etwas anderes“ bezieht sich normalerweise auf <abbr title="I
 
 Da die Ausführungszeit hier hauptsächlich durch das Warten auf <abbr title="Input and Output – Eingabe und Ausgabe">I/O</abbr>-Operationen verbraucht wird, nennt man dies auch „I/O-lastige“ („I/O bound“) Operationen.
 
-„Asynchron“, sagt man, weil das Computersystem / Programm nicht mit einer langsamen Aufgabe „synchronisiert“ werden muss und nicht auf den genauen Moment warten muss, in dem die Aufgabe beendet ist, ohne dabei etwas zu tun, um schließlich das Ergebnis der Aufgabe zu übernehmen und die Arbeit fortsetzen zu können.
+„Asynchron“, sagt man, weil der Computer / das Programm nicht mit einer langsamen Aufgabe „synchronisiert“ werden muss und nicht auf den genauen Moment warten muss, in dem die Aufgabe beendet ist, ohne dabei etwas zu tun, um schließlich das Ergebnis der Aufgabe zu übernehmen und die Arbeit fortsetzen zu können.
 
-Da es sich stattdessen um ein „asynchrones“ System handelt, kann die Aufgabe nach Abschluss ein wenig (einige Mikrosekunden) in der Schlange warten, bis das System / Programm seine anderen Dinge erledigt hat und zurückkommt, um die Ergebnisse entgegenzunehmen und mit ihnen weiterzuarbeiten.
+Da es sich stattdessen um ein „asynchrones“ System handelt, kann die Aufgabe nach Abschluss ein wenig (einige Mikrosekunden) in der Schlange warten, bis der Computer / das Programm seine anderen Dinge erledigt hat und zurückkommt, um die Ergebnisse entgegenzunehmen und mit ihnen weiterzuarbeiten.
 
-Für „synchron“ (im Gegensatz zu „asynchron“) wird auch oft der Begriff „sequentiell“ verwendet, da das System / Programm alle Schritte in einer Sequenz („der Reihe nach“) ausführt, bevor es zu einer anderen Aufgabe wechselt, auch wenn diese Schritte mit Warten verbunden sind.
+Für „synchron“ (im Gegensatz zu „asynchron“) wird auch oft der Begriff „sequentiell“ verwendet, da der Computer / das Programm alle Schritte in einer Sequenz („der Reihe nach“) ausführt, bevor es zu einer anderen Aufgabe wechselt, auch wenn diese Schritte mit Warten verbunden sind.
 
-### Nebenläufigkeit und Hamburger
+### Nebenläufigkeit und Hamburger { #concurrency-and-burgers }
 
 Diese oben beschriebene Idee von **asynchronem** Code wird manchmal auch **„Nebenläufigkeit“** genannt. Sie unterscheidet sich von **„Parallelität“**.
 
@@ -103,7 +103,7 @@ Aber die Details zwischen *Nebenläufigkeit* und *Parallelität* sind ziemlich u
 
 Um den Unterschied zu erkennen, stellen Sie sich die folgende Geschichte über Hamburger vor:
 
-### Nebenläufige Hamburger
+### Nebenläufige Hamburger { #concurrent-burgers }
 
 Sie gehen mit Ihrem Schwarm Fastfood holen, stehen in der Schlange, während der Kassierer die Bestellungen der Leute vor Ihnen entgegennimmt. 😍
 
@@ -139,7 +139,7 @@ Sie und Ihr Schwarm essen die Burger und haben eine schöne Zeit. ✨
 
 <img src="/img/async/concurrent-burgers/concurrent-burgers-07.png" class="illustration">
 
-/// info
+/// info | Info
 
 Die wunderschönen Illustrationen stammen von <a href="https://www.instagram.com/ketrinadrawsalot" class="external-link" target="_blank">Ketrina Thompson</a>. 🎨
 
@@ -147,7 +147,7 @@ Die wunderschönen Illustrationen stammen von <a href="https://www.instagram.com
 
 ---
 
-Stellen Sie sich vor, Sie wären das Computersystem / Programm 🤖 in dieser Geschichte.
+Stellen Sie sich vor, Sie wären der Computer / das Programm 🤖 in dieser Geschichte.
 
 Während Sie an der Schlange stehen, sind Sie einfach untätig 😴, warten darauf, dass Sie an die Reihe kommen, und tun nichts sehr „Produktives“. Aber die Schlange ist schnell abgearbeitet, weil der Kassierer nur die Bestellungen entgegennimmt (und nicht zubereitet), also ist das vertretbar.
 
@@ -163,7 +163,7 @@ Also warten Sie darauf, dass Ihr Schwarm ihre Geschichte zu Ende erzählt (die a
 
 Dann gehen Sie zur Theke 🔀, zur ursprünglichen Aufgabe, die nun erledigt ist ⏯, nehmen die Burger auf, sagen Danke, und bringen sie zum Tisch. Damit ist dieser Schritt / diese Aufgabe der Interaktion mit der Theke abgeschlossen ⏹. Das wiederum schafft eine neue Aufgabe, „Burger essen“ 🔀 ⏯, aber die vorherige Aufgabe „Burger holen“ ist erledigt ⏹.
 
-### Parallele Hamburger
+### Parallele Hamburger { #parallel-burgers }
 
 Stellen wir uns jetzt vor, dass es sich hierbei nicht um „nebenläufige Hamburger“, sondern um „parallele Hamburger“ handelt.
 
@@ -205,7 +205,7 @@ Sie essen sie und sind fertig. ⏹
 
 Es wurde nicht viel geredet oder geflirtet, da die meiste Zeit mit Warten 🕙 vor der Theke verbracht wurde. 😞
 
-/// info
+/// info | Info
 
 Die wunderschönen Illustrationen stammen von <a href="https://www.instagram.com/ketrinadrawsalot" class="external-link" target="_blank">Ketrina Thompson</a>. 🎨
 
@@ -233,15 +233,15 @@ Und man muss lange in der Schlange warten 🕙 sonst kommt man nicht an die Reih
 
 Sie würden Ihren Schwarm 😍 wahrscheinlich nicht mitnehmen wollen, um Besorgungen bei der Bank zu erledigen 🏦.
 
-### Hamburger Schlussfolgerung
+### Hamburger Schlussfolgerung { #burger-conclusion }
 
-In diesem Szenario „Fast Food Burger mit Ihrem Schwarm“ ist es viel sinnvoller, ein nebenläufiges System zu haben ⏸🔀⏯, da viel gewartet wird 🕙.
+In diesem Szenario „Fastfood-Burger mit Ihrem Schwarm“ ist es viel sinnvoller, ein nebenläufiges System zu haben ⏸🔀⏯, da viel gewartet wird 🕙.
 
 Das ist auch bei den meisten Webanwendungen der Fall.
 
-Viele, viele Benutzer, aber Ihr Server wartet 🕙 darauf, dass deren nicht so gute Internetverbindungen die Requests übermitteln.
+Viele, viele Benutzer, aber Ihr Server wartet 🕙 darauf, dass deren nicht so gute Internetverbindungen die <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Requests</abbr> übermitteln.
 
-Und dann warten 🕙, bis die Responses zurückkommen.
+Und dann wieder warten 🕙, bis die <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Responses</abbr> zurückkommen.
 
 Dieses „Warten“ 🕙 wird in Mikrosekunden gemessen, aber zusammenfassend lässt sich sagen, dass am Ende eine Menge gewartet wird.
 
@@ -253,7 +253,7 @@ Und das ist das gleiche Leistungsniveau, das Sie mit **FastAPI** erhalten.
 
 Und da Sie Parallelität und Asynchronität gleichzeitig haben können, erzielen Sie eine höhere Performanz als die meisten getesteten NodeJS-Frameworks und sind mit Go auf Augenhöhe, einer kompilierten Sprache, die näher an C liegt <a href="https://www.techempower.com/benchmarks/#section=data-r17&hw=ph&test=query&l=zijmkf-1" class="external-link" target="_blank">(alles dank Starlette)</a>.
 
-### Ist Nebenläufigkeit besser als Parallelität?
+### Ist Nebenläufigkeit besser als Parallelität? { #is-concurrency-better-than-parallelism }
 
 Nein! Das ist nicht die Moral der Geschichte.
 
@@ -290,17 +290,17 @@ Zum Beispiel:
 * **Maschinelles Lernen**: Normalerweise sind viele „Matrix“- und „Vektor“-Multiplikationen erforderlich. Stellen Sie sich eine riesige Tabelle mit Zahlen vor, in der Sie alle Zahlen gleichzeitig multiplizieren.
 * **Deep Learning**: Dies ist ein Teilgebiet des maschinellen Lernens, daher gilt das Gleiche. Es ist nur so, dass es nicht eine einzige Tabelle mit Zahlen zum Multiplizieren gibt, sondern eine riesige Menge davon, und in vielen Fällen verwendet man einen speziellen Prozessor, um diese Modelle zu erstellen und / oder zu verwenden.
 
-### Nebenläufigkeit + Parallelität: Web + maschinelles Lernen
+### Nebenläufigkeit + Parallelität: Web + maschinelles Lernen { #concurrency-parallelism-web-machine-learning }
 
 Mit **FastAPI** können Sie die Vorteile der Nebenläufigkeit nutzen, die in der Webentwicklung weit verbreitet ist (derselbe Hauptvorteil von NodeJS).
 
-Sie können aber auch die Vorteile von Parallelität und Multiprocessing (Mehrere Prozesse werden parallel ausgeführt) für **CPU-lastige** Workloads wie in Systemen für maschinelles Lernen nutzen.
+Sie können aber auch die Vorteile von Parallelität und Multiprocessing (mehrere Prozesse werden parallel ausgeführt) für **CPU-lastige** Workloads wie in Systemen für maschinelles Lernen nutzen.
 
 Dies und die einfache Tatsache, dass Python die Hauptsprache für **Data Science**, maschinelles Lernen und insbesondere Deep Learning ist, machen FastAPI zu einem sehr passenden Werkzeug für Web-APIs und Anwendungen für Data Science / maschinelles Lernen (neben vielen anderen).
 
 Wie Sie diese Parallelität in der Produktion erreichen, erfahren Sie im Abschnitt über [Deployment](deployment/index.md){.internal-link target=_blank}.
 
-## `async` und `await`.
+## `async` und `await` { #async-and-await }
 
 Moderne Versionen von Python verfügen über eine sehr intuitive Möglichkeit, asynchronen Code zu schreiben. Dadurch sieht es wie normaler „sequentieller“ Code aus und übernimmt im richtigen Moment das „Warten“ für Sie.
 
@@ -316,16 +316,16 @@ Damit `await` funktioniert, muss es sich in einer Funktion befinden, die diese A
 
 ```Python hl_lines="1"
 async def get_burgers(number: int):
-    # Mach Sie hier etwas Asynchrones, um die Burger zu erstellen
+    # Mache hier etwas Asynchrones, um die Burger zu erstellen
     return burgers
 ```
 
 ... statt mit `def`:
 
 ```Python hl_lines="2"
-# Die ist nicht asynchron
+# Dies ist nicht asynchron
 def get_sequential_burgers(number: int):
-    # Mach Sie hier etwas Sequentielles, um die Burger zu erstellen
+    # Mache hier etwas Sequentielles, um die Burger zu erstellen
     return burgers
 ```
 
@@ -349,7 +349,7 @@ async def read_burgers():
     return burgers
 ```
 
-### Weitere technische Details
+### Weitere technische Details { #more-technical-details }
 
 Ihnen ist wahrscheinlich aufgefallen, dass `await` nur innerhalb von Funktionen verwendet werden kann, die mit `async def` definiert sind.
 
@@ -361,15 +361,17 @@ Wenn Sie mit **FastAPI** arbeiten, müssen Sie sich darüber keine Sorgen machen
 
 Wenn Sie jedoch `async` / `await` ohne FastAPI verwenden möchten, können Sie dies auch tun.
 
-### Schreiben Sie Ihren eigenen asynchronen Code
+### Schreiben Sie Ihren eigenen asynchronen Code { #write-your-own-async-code }
 
-Starlette (und **FastAPI**) basiert auf <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a>, was bedeutet, es ist sowohl kompatibel mit der Python-Standardbibliothek <a href="https://docs.python.org/3/library/asyncio-task.html" class="external-link" target="_blank">asyncio</a>, als auch mit <a href="https://trio.readthedocs.io/en/stable/" class="external-link" target="_blank">Trio</a>.
+Starlette (und **FastAPI**) basieren auf <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a>, was bedeutet, dass es sowohl kompatibel mit der Python-Standardbibliothek <a href="https://docs.python.org/3/library/asyncio-task.html" class="external-link" target="_blank">asyncio</a> als auch mit <a href="https://trio.readthedocs.io/en/stable/" class="external-link" target="_blank">Trio</a> ist.
 
-Insbesondere können Sie <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a> direkt verwenden für Ihre fortgeschritten nebenläufigen und parallelen Anwendungsfälle, die fortgeschrittenere Muster in Ihrem eigenen Code erfordern.
+Insbesondere können Sie <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a> direkt verwenden für Ihre fortgeschrittenen nebenläufigen und parallelen Anwendungsfälle, die fortgeschrittenere Muster in Ihrem eigenen Code erfordern.
 
-Und selbst wenn Sie FastAPI nicht verwenden würden, könnten Sie auch Ihre eigenen asynchronen Anwendungen mit <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a> so schreiben, dass sie hoch kompatibel sind und Sie dessen Vorteile nutzen können (z. B. *strukturierte Nebenläufigkeit*).
+Und auch wenn Sie FastAPI nicht verwenden würden, könnten Sie Ihre eigenen asynchronen Anwendungen mit <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a> schreiben, um hochkompatibel zu sein und dessen Vorteile zu nutzen (z. B. *strukturierte Nebenläufigkeit*).
 
-### Andere Formen von asynchronem Code
+Ich habe eine weitere Bibliothek auf Basis von AnyIO erstellt, als dünne Schicht obendrauf, um die Typannotationen etwas zu verbessern und bessere **Autovervollständigung**, **Inline-Fehler** usw. zu erhalten. Sie hat auch eine freundliche Einführung und ein Tutorial, um Ihnen zu helfen, **Ihren eigenen asynchronen Code zu verstehen** und zu schreiben: <a href="https://asyncer.tiangolo.com/" class="external-link" target="_blank">Asyncer</a>. Sie ist insbesondere nützlich, wenn Sie **asynchronen Code mit regulärem** (blockierendem/synchronem) Code kombinieren müssen.
+
+### Andere Formen von asynchronem Code { #other-forms-of-asynchronous-code }
 
 Diese Art der Verwendung von `async` und `await` ist in der Sprache relativ neu.
 
@@ -381,25 +383,25 @@ Davor war der Umgang mit asynchronem Code jedoch deutlich komplexer und schwieri
 
 In früheren Versionen von Python hätten Sie Threads oder <a href="https://www.gevent.org/" class="external-link" target="_blank">Gevent</a> verwenden können. Der Code ist jedoch viel komplexer zu verstehen, zu debuggen und nachzuvollziehen.
 
-In früheren Versionen von NodeJS / Browser JavaScript hätten Sie „Callbacks“ verwendet. Was zur <a href="http://callbackhell.com/" class="external-link" target="_blank">Callback-Hölle</a> führt.
+In früheren Versionen von NodeJS / Browser JavaScript hätten Sie „Callbacks“ verwendet, was zur <a href="http://callbackhell.com/" class="external-link" target="_blank">Callback-Hölle</a> führt.
 
-## Coroutinen
+## Coroutinen { #coroutines }
 
 **Coroutine** ist nur ein schicker Begriff für dasjenige, was von einer `async def`-Funktion zurückgegeben wird. Python weiß, dass es so etwas wie eine Funktion ist, die es starten kann und die irgendwann endet, aber auch dass sie pausiert ⏸ werden kann, wann immer darin ein `await` steht.
 
 Aber all diese Funktionalität der Verwendung von asynchronem Code mit `async` und `await` wird oft als Verwendung von „Coroutinen“ zusammengefasst. Es ist vergleichbar mit dem Hauptmerkmal von Go, den „Goroutinen“.
 
-## Fazit
+## Fazit { #conclusion }
 
 Sehen wir uns den gleichen Satz von oben noch mal an:
 
-> Moderne Versionen von Python unterstützen **„asynchronen Code“** unter Verwendung sogenannter **„Coroutinen“** mithilfe der Syntax **`async`** und **`await`**.
+> Moderne Versionen von Python unterstützen **„asynchronen Code“** unter Verwendung sogenannter **„Coroutinen“** mithilfe der Syntax **`async` und `await`**.
 
 Das sollte jetzt mehr Sinn ergeben. ✨
 
 All das ist es, was FastAPI (via Starlette) befeuert und es eine so beeindruckende Performanz haben lässt.
 
-## Sehr technische Details
+## Sehr technische Details { #very-technical-details }
 
 /// warning | Achtung
 
@@ -411,23 +413,23 @@ Wenn Sie über gute technische Kenntnisse verfügen (Coroutinen, Threads, Blocki
 
 ///
 
-### Pfadoperation-Funktionen
+### Pfadoperation-Funktionen { #path-operation-functions }
 
 Wenn Sie eine *Pfadoperation-Funktion* mit normalem `def` anstelle von `async def` deklarieren, wird sie in einem externen Threadpool ausgeführt, der dann `await`et wird, anstatt direkt aufgerufen zu werden (da dies den Server blockieren würde).
 
 Wenn Sie von einem anderen asynchronen Framework kommen, das nicht auf die oben beschriebene Weise funktioniert, und Sie es gewohnt sind, triviale, nur-berechnende *Pfadoperation-Funktionen* mit einfachem `def` zu definieren, um einen geringfügigen Geschwindigkeitsgewinn (etwa 100 Nanosekunden) zu erzielen, beachten Sie bitte, dass der Effekt in **FastAPI** genau gegenteilig wäre. In solchen Fällen ist es besser, `async def` zu verwenden, es sei denn, Ihre *Pfadoperation-Funktionen* verwenden Code, der blockierende <abbr title="Input/Output – Eingabe/Ausgabe: Lesen oder Schreiben von/auf Festplatte, Netzwerkkommunikation.">I/O</abbr>-Operationen durchführt.
 
-Dennoch besteht in beiden Fällen eine gute Chance, dass **FastAPI** [immer noch schneller](index.md#performanz){.internal-link target=_blank} als Ihr bisheriges Framework (oder zumindest damit vergleichbar) ist.
+Dennoch besteht in beiden Fällen eine gute Chance, dass **FastAPI** [immer noch schneller](index.md#performance){.internal-link target=_blank} als Ihr bisheriges Framework (oder zumindest damit vergleichbar) ist.
 
-### Abhängigkeiten
+### Abhängigkeiten { #dependencies }
 
-Das Gleiche gilt für [Abhängigkeiten](tutorial/dependencies/index.md){.internal-link target=_blank}. Wenn eine Abhängigkeit eine normale `def`-Funktion ist, anstelle einer `async def`-Funktion, dann wird sie im externen Threadpool ausgeführt.
+Das Gleiche gilt für [Abhängigkeiten](tutorial/dependencies/index.md){.internal-link target=_blank}. Wenn eine Abhängigkeit eine normale `def`-Funktion anstelle einer `async def` ist, wird sie im externen Threadpool ausgeführt.
 
-### Unterabhängigkeiten
+### Unterabhängigkeiten { #sub-dependencies }
 
-Sie können mehrere Abhängigkeiten und [Unterabhängigkeiten](tutorial/dependencies/sub-dependencies.md){.internal-link target=_blank} haben, die einander bedingen (als Parameter der Funktionsdefinitionen), einige davon könnten erstellt werden mit `async def` und einige mit normalem `def`. Es würde immer noch funktionieren und diejenigen, die mit normalem `def` erstellt wurden, würden in einem externen Thread (vom Threadpool stammend) aufgerufen werden, anstatt `await`et zu werden.
+Sie können mehrere Abhängigkeiten und [Unterabhängigkeiten](tutorial/dependencies/sub-dependencies.md){.internal-link target=_blank} haben, die einander bedingen (als Parameter der Funktionsdefinitionen), einige davon könnten erstellt werden mit `async def` und einige mit normalem `def`. Es würde immer noch funktionieren, und diejenigen, die mit normalem `def` erstellt wurden, würden in einem externen Thread (vom Threadpool stammend) aufgerufen werden, anstatt `await`et zu werden.
 
-### Andere Hilfsfunktionen
+### Andere Hilfsfunktionen { #other-utility-functions }
 
 Jede andere Hilfsfunktion, die Sie direkt aufrufen, kann mit normalem `def` oder `async def` erstellt werden, und FastAPI beeinflusst nicht die Art und Weise, wie Sie sie aufrufen.
 
@@ -439,4 +441,4 @@ Wenn Ihre Hilfsfunktion eine normale Funktion mit `def` ist, wird sie direkt auf
 
 Nochmal, es handelt sich hier um sehr technische Details, die Ihnen helfen, falls Sie danach gesucht haben.
 
-Andernfalls liegen Sie richtig, wenn Sie sich an die Richtlinien aus dem obigen Abschnitt halten: <a href="#in-eile">In Eile?</a>.
+Andernfalls liegen Sie richtig, wenn Sie sich an die Richtlinien aus dem obigen Abschnitt halten: <a href="#in-a-hurry">In Eile?</a>.

docs/de/docs/benchmarks.md

@@ -1,16 +1,16 @@
-# Benchmarks
+# Benchmarks { #benchmarks }
 
-Unabhängige TechEmpower-Benchmarks zeigen, **FastAPI**-Anwendungen, die unter Uvicorn ausgeführt werden, gehören zu <a href="https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7" class="external-link" target="_blank">den schnellsten existierenden Python-Frameworks</a>, nur Starlette und Uvicorn selbst (intern von FastAPI verwendet) sind schneller.
+Unabhängige TechEmpower-Benchmarks zeigen **FastAPI**-Anwendungen, die unter Uvicorn ausgeführt werden, als <a href="https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7" class="external-link" target="_blank">eines der schnellsten verfügbaren Python-Frameworks</a>, nur unterhalb von Starlette und Uvicorn selbst (die intern von FastAPI verwendet werden).
 
-Beim Ansehen von Benchmarks und Vergleichen sollten Sie jedoch Folgende Punkte beachten.
+Aber bei der Betrachtung von Benchmarks und Vergleichen sollten Sie Folgendes beachten.
 
-## Benchmarks und Geschwindigkeit
+## Benchmarks und Geschwindigkeit { #benchmarks-and-speed }
 
-Wenn Sie sich die Benchmarks ansehen, werden häufig mehrere Tools mit unterschiedlichen Eigenschaften als gleichwertig verglichen.
+Wenn Sie die Benchmarks ansehen, ist es üblich, dass mehrere Tools unterschiedlichen Typs als gleichwertig verglichen werden.
 
-Konkret geht es darum, Uvicorn, Starlette und FastAPI miteinander zu vergleichen (neben vielen anderen Tools).
+Insbesondere dass Uvicorn, Starlette und FastAPI zusammen verglichen werden (neben vielen anderen Tools).
 
-Je einfacher das Problem, welches durch das Tool gelöst wird, desto besser ist die Performanz. Und die meisten Benchmarks testen nicht die zusätzlichen Funktionen, welche das Tool bietet.
+Je einfacher das Problem, das durch das Tool gelöst wird, desto besser wird die Performanz sein. Und die meisten Benchmarks testen nicht die zusätzlichen Funktionen, die das Tool bietet.
 
 Die Hierarchie ist wie folgt:
 
@@ -19,16 +19,16 @@ Die Hierarchie ist wie folgt:
         * **FastAPI**: (verwendet Starlette) ein API-Mikroframework mit mehreren zusätzlichen Funktionen zum Erstellen von APIs, mit Datenvalidierung, usw.
 
 * **Uvicorn**:
-    * Bietet die beste Leistung, da außer dem Server selbst nicht viel zusätzlicher Code vorhanden ist.
-    * Sie würden eine Anwendung nicht direkt in Uvicorn schreiben. Das würde bedeuten, dass Ihr Code zumindest mehr oder weniger den gesamten von Starlette (oder **FastAPI**) bereitgestellten Code enthalten müsste. Und wenn Sie das täten, hätte Ihre endgültige Anwendung den gleichen Overhead wie die Verwendung eines Frameworks nebst Minimierung Ihres Anwendungscodes und der Fehler.
+    * Wird die beste Performanz haben, da außer dem Server selbst nicht viel zusätzlicher Code vorhanden ist.
+    * Sie würden eine Anwendung nicht direkt in Uvicorn schreiben. Das würde bedeuten, dass Ihr Code zumindest mehr oder weniger den gesamten von Starlette (oder **FastAPI**) bereitgestellten Code enthalten müsste. Und wenn Sie das täten, hätte Ihre endgültige Anwendung den gleichen Overhead wie bei der Verwendung eines Frameworks und der Minimierung Ihres Anwendungscodes und der Fehler.
     * Wenn Sie Uvicorn vergleichen, vergleichen Sie es mit Anwendungsservern wie Daphne, Hypercorn, uWSGI, usw.
 * **Starlette**:
-    * Wird nach Uvicorn die nächstbeste Performanz erbringen. Tatsächlich nutzt Starlette intern Uvicorn. Daher kann es wahrscheinlich nur „langsamer“ als Uvicorn sein, weil mehr Code ausgeführt wird.
-    * Aber es bietet Ihnen die Tools zum Erstellen einfacher Webanwendungen, mit Routing basierend auf Pfaden, usw.
+    * Wird nach Uvicorn die nächstbeste Performanz erbringen. Tatsächlich verwendet Starlette intern Uvicorn, um zu laufen. Daher kann es wahrscheinlich nur „langsamer“ als Uvicorn werden, weil mehr Code ausgeführt werden muss.
+    * Aber es bietet Ihnen die Werkzeuge, um einfache Webanwendungen zu erstellen, mit Routing basierend auf Pfaden, usw.
     * Wenn Sie Starlette vergleichen, vergleichen Sie es mit Webframeworks (oder Mikroframeworks) wie Sanic, Flask, Django, usw.
 * **FastAPI**:
     * So wie Starlette Uvicorn verwendet und nicht schneller als dieses sein kann, verwendet **FastAPI** Starlette, sodass es nicht schneller als dieses sein kann.
-    * FastAPI bietet zusätzlich zu Starlette weitere Funktionen. Funktionen, die Sie beim Erstellen von APIs fast immer benötigen, wie Datenvalidierung und Serialisierung. Und wenn Sie es verwenden, erhalten Sie kostenlos automatische Dokumentation (die automatische Dokumentation verursacht nicht einmal zusätzlichen Aufwand für laufende Anwendungen, sie wird beim Start generiert).
-    * Wenn Sie FastAPI nicht, und direkt Starlette (oder ein anderes Tool wie Sanic, Flask, Responder, usw.) verwenden würden, müssten Sie die gesamte Datenvalidierung und Serialisierung selbst implementieren. Ihre finale Anwendung hätte also immer noch den gleichen Overhead, als ob sie mit FastAPI erstellt worden wäre. Und in vielen Fällen ist diese Datenvalidierung und Serialisierung der größte Teil des in Anwendungen geschriebenen Codes.
-    * Durch die Verwendung von FastAPI sparen Sie also Entwicklungszeit, Fehler und Codezeilen und würden wahrscheinlich die gleiche Leistung (oder eine bessere) erzielen, die Sie hätten, wenn Sie es nicht verwenden würden (da Sie alles in Ihrem Code implementieren müssten).
-    * Wenn Sie FastAPI vergleichen, vergleichen Sie es mit einem Webanwendung-Framework (oder einer Reihe von Tools), welche Datenvalidierung, Serialisierung und Dokumentation bereitstellen, wie Flask-apispec, NestJS, Molten, usw. – Frameworks mit integrierter automatischer Datenvalidierung, Serialisierung und Dokumentation.
+    * FastAPI bietet zusätzliche Funktionen auf Basis von Starlette. Funktionen, die Sie beim Erstellen von APIs fast immer benötigen, wie Datenvalidierung und Serialisierung. Und wenn Sie es verwenden, erhalten Sie kostenlose automatische Dokumentation (die automatische Dokumentation verursacht nicht einmal zusätzlichen Overhead für laufende Anwendungen, sie wird beim Starten generiert).
+    * Wenn Sie FastAPI nicht verwenden und stattdessen Starlette direkt (oder ein anderes Tool wie Sanic, Flask, Responder, usw.) verwenden würden, müssten Sie die gesamte Datenvalidierung und Serialisierung selbst implementieren. Ihre finale Anwendung hätte also immer noch den gleichen Overhead, als ob sie mit FastAPI erstellt worden wäre. Und in vielen Fällen ist diese Datenvalidierung und Serialisierung der größte Teil des in Anwendungen geschriebenen Codes.
+    * Durch die Verwendung von FastAPI sparen Sie also Entwicklungszeit, Fehler und Codezeilen und würden wahrscheinlich die gleiche Performanz (oder eine bessere) erzielen, die Sie hätten, wenn Sie es nicht verwenden würden (da Sie alles in Ihrem Code implementieren müssten).
+    * Wenn Sie FastAPI vergleichen, vergleichen Sie es mit einem Webanwendungs-Framework (oder einer Reihe von Tools), das Datenvalidierung, Serialisierung und Dokumentation bereitstellt, wie Flask-apispec, NestJS, Molten, usw. – Frameworks mit integrierter automatischer Datenvalidierung, Serialisierung und Dokumentation.

docs/de/docs/deployment/cloud.md

@@ -1,17 +1,18 @@
-# FastAPI-Deployment bei Cloud-Anbietern
+# FastAPI bei Cloudanbietern bereitstellen { #deploy-fastapi-on-cloud-providers }
 
-Sie können praktisch **jeden Cloud-Anbieter** für das <abbr title="Bereitstellen der fertigen Anwendung für die Endbenutzer">Deployment</abbr> Ihrer FastAPI-Anwendung verwenden.
+Sie können praktisch **jeden Cloudanbieter** verwenden, um Ihre FastAPI-Anwendung bereitzustellen.
 
-In den meisten Fällen verfügen die Haupt-Cloud-Anbieter über Anleitungen zum Deployment von FastAPI.
+In den meisten Fällen bieten die großen Cloudanbieter Anleitungen zum Bereitstellen von FastAPI an.
 
-## Cloud-Anbieter – Sponsoren
+## Cloudanbieter – Sponsoren { #cloud-providers-sponsors }
 
-Einige Cloud-Anbieter ✨ [**sponsern FastAPI**](../help-fastapi.md#den-autor-sponsern){.internal-link target=_blank} ✨, dies gewährleistet die kontinuierliche und gesunde **Entwicklung** von FastAPI und seinem **Ökosystem**.
+Einige Cloudanbieter ✨ [**sponsern FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨, dies stellt die kontinuierliche und gesunde **Entwicklung** von FastAPI und seinem **Ökosystem** sicher.
 
-Und es zeigt deren wahres Engagement für FastAPI und seine **Community** (Sie), da diese Ihnen nicht nur einen **guten Service** bieten möchten, sondern auch sicherstellen möchten, dass Sie über ein **gutes und gesundes Framework** verfügen, FastAPI. 🙇
+Und es zeigt ihr wahres Engagement für FastAPI und seine **Community** (Sie), da sie Ihnen nicht nur einen **guten Service** bieten möchten, sondern auch sicherstellen möchten, dass Sie ein **gutes und gesundes Framework**, FastAPI, haben. 🙇
 
 Vielleicht möchten Sie deren Dienste ausprobieren und deren Anleitungen folgen:
 
 * <a href="https://docs.platform.sh/languages/python.html?utm_source=fastapi-signup&utm_medium=banner&utm_campaign=FastAPI-signup-June-2023" class="external-link" target="_blank">Platform.sh</a>
 * <a href="https://docs.porter.run/language-specific-guides/fastapi" class="external-link" target="_blank">Porter</a>
-* <a href="https://docs.withcoherence.com/docs/configuration/frameworks?utm_medium=advertising&utm_source=fastapi&utm_campaign=banner%20january%2024#fast-api-example" class="external-link" target="_blank">Coherence</a>
+* <a href="https://docs.render.com/deploy-fastapi?utm_source=deploydoc&utm_medium=referral&utm_campaign=fastapi" class="external-link" target="_blank">Render</a>
+* <a href="https://docs.railway.com/guides/fastapi?utm_medium=integration&utm_source=docs&utm_campaign=fastapi" class="external-link" target="_blank">Railway</a>

docs/de/docs/deployment/concepts.md

@@ -1,4 +1,4 @@
-# Deployment-Konzepte
+# Deployment-Konzepte { #deployments-concepts }
 
 Bei dem Deployment – der Bereitstellung – einer **FastAPI**-Anwendung, oder eigentlich jeder Art von Web-API, gibt es mehrere Konzepte, die Sie wahrscheinlich interessieren, und mithilfe der Sie die **am besten geeignete** Methode zur **Bereitstellung Ihrer Anwendung** finden können.
 
@@ -13,7 +13,7 @@ Einige wichtige Konzepte sind:
 
 Wir werden sehen, wie diese sich auf das **Deployment** auswirken.
 
-Letztendlich besteht das ultimative Ziel darin, **Ihre API-Clients** auf **sichere** Weise zu bedienen, um **Unterbrechungen** zu vermeiden und die **Rechenressourcen** (z. B. entfernte Server/virtuelle Maschinen) so effizient wie möglich zu nutzen. 🚀
+Letztendlich besteht das ultimative Ziel darin, **Ihre API-Clients** auf **sichere** Weise zu versorgen, um **Unterbrechungen** zu vermeiden und die **Rechenressourcen** (z. B. entfernte Server/virtuelle Maschinen) so effizient wie möglich zu nutzen. 🚀
 
 Ich erzähle Ihnen hier etwas mehr über diese **Konzepte**, was Ihnen hoffentlich die **Intuition** gibt, die Sie benötigen, um zu entscheiden, wie Sie Ihre API in sehr unterschiedlichen Umgebungen bereitstellen, möglicherweise sogar in **zukünftigen**, die jetzt noch nicht existieren.
 
@@ -23,7 +23,7 @@ In den nächsten Kapiteln werde ich Ihnen mehr **konkrete Rezepte** für die Ber
 
 Aber schauen wir uns zunächst einmal diese grundlegenden **konzeptionellen Ideen** an. Diese Konzepte gelten auch für jede andere Art von Web-API. 💡
 
-## Sicherheit – HTTPS
+## Sicherheit – HTTPS { #security-https }
 
 Im [vorherigen Kapitel über HTTPS](https.md){.internal-link target=_blank} haben wir erfahren, wie HTTPS Verschlüsselung für Ihre API bereitstellt.
 
@@ -31,7 +31,7 @@ Wir haben auch gesehen, dass HTTPS normalerweise von einer Komponente **außerha
 
 Und es muss etwas geben, das für die **Erneuerung der HTTPS-Zertifikate** zuständig ist, es könnte sich um dieselbe Komponente handeln oder um etwas anderes.
 
-### Beispieltools für HTTPS
+### Beispieltools für HTTPS { #example-tools-for-https }
 
 Einige der Tools, die Sie als TLS-Terminierungsproxy verwenden können, sind:
 
@@ -55,11 +55,11 @@ In den nächsten Kapiteln zeige ich Ihnen einige konkrete Beispiele.
 
 Die nächsten zu berücksichtigenden Konzepte drehen sich dann um das Programm, das Ihre eigentliche API ausführt (z. B. Uvicorn).
 
-## Programm und Prozess
+## Programm und Prozess { #program-and-process }
 
 Wir werden viel über den laufenden „**Prozess**“ sprechen, daher ist es nützlich, Klarheit darüber zu haben, was das bedeutet und was der Unterschied zum Wort „**Programm**“ ist.
 
-### Was ist ein Programm?
+### Was ist ein Programm { #what-is-a-program }
 
 Das Wort **Programm** wird häufig zur Beschreibung vieler Dinge verwendet:
 
@@ -67,7 +67,7 @@ Das Wort **Programm** wird häufig zur Beschreibung vieler Dinge verwendet:
 * Die **Datei**, die vom Betriebssystem **ausgeführt** werden kann, zum Beispiel: `python`, `python.exe` oder `uvicorn`.
 * Ein bestimmtes Programm, während es auf dem Betriebssystem **läuft**, die CPU nutzt und Dinge im Arbeitsspeicher ablegt. Dies wird auch als **Prozess** bezeichnet.
 
-### Was ist ein Prozess?
+### Was ist ein Prozess { #what-is-a-process }
 
 Das Wort **Prozess** wird normalerweise spezifischer verwendet und bezieht sich nur auf das, was im Betriebssystem ausgeführt wird (wie im letzten Punkt oben):
 
@@ -88,13 +88,13 @@ Und Sie werden beispielsweise wahrscheinlich feststellen, dass mehrere Prozesse
 
 Nachdem wir nun den Unterschied zwischen den Begriffen **Prozess** und **Programm** kennen, sprechen wir weiter über das Deployment.
 
-## Beim Hochfahren ausführen
+## Beim Hochfahren ausführen { #running-on-startup }
 
 Wenn Sie eine Web-API erstellen, möchten Sie in den meisten Fällen, dass diese **immer läuft**, ununterbrochen, damit Ihre Clients immer darauf zugreifen können. Es sei denn natürlich, Sie haben einen bestimmten Grund, warum Sie möchten, dass diese nur in bestimmten Situationen ausgeführt wird. Meistens möchten Sie jedoch, dass sie ständig ausgeführt wird und **verfügbar** ist.
 
-### Auf einem entfernten Server
+### Auf einem entfernten Server { #in-a-remote-server }
 
-Wenn Sie einen entfernten Server (einen Cloud-Server, eine virtuelle Maschine, usw.) einrichten, können Sie am einfachsten Uvicorn (oder ähnliches) manuell ausführen, genau wie bei der lokalen Entwicklung.
+Wenn Sie einen entfernten Server (einen Cloud-Server, eine virtuelle Maschine, usw.) einrichten, können Sie am einfachsten `fastapi run` (welches Uvicorn verwendet) oder etwas Ähnliches manuell ausführen, genau wie bei der lokalen Entwicklung.
 
 Und es wird funktionieren und **während der Entwicklung** nützlich sein.
 
@@ -102,15 +102,15 @@ Wenn Ihre Verbindung zum Server jedoch unterbrochen wird, wird der **laufende Pr
 
 Und wenn der Server neu gestartet wird (z. B. nach Updates oder Migrationen vom Cloud-Anbieter), werden Sie das wahrscheinlich **nicht bemerken**. Und deshalb wissen Sie nicht einmal, dass Sie den Prozess manuell neu starten müssen. Ihre API bleibt also einfach tot. 😱
 
-### Beim Hochfahren automatisch ausführen
+### Beim Hochfahren automatisch ausführen { #run-automatically-on-startup }
 
 Im Allgemeinen möchten Sie wahrscheinlich, dass das Serverprogramm (z. B. Uvicorn) beim Hochfahren des Servers automatisch gestartet wird und kein **menschliches Eingreifen** erforderlich ist, sodass immer ein Prozess mit Ihrer API ausgeführt wird (z. B. Uvicorn, welches Ihre FastAPI-Anwendung ausführt).
 
-### Separates Programm
+### Separates Programm { #separate-program }
 
 Um dies zu erreichen, haben Sie normalerweise ein **separates Programm**, welches sicherstellt, dass Ihre Anwendung beim Hochfahren ausgeführt wird. Und in vielen Fällen würde es auch sicherstellen, dass auch andere Komponenten oder Anwendungen ausgeführt werden, beispielsweise eine Datenbank.
 
-### Beispieltools zur Ausführung beim Hochfahren
+### Beispieltools zur Ausführung beim Hochfahren { #example-tools-to-run-at-startup }
 
 Einige Beispiele für Tools, die diese Aufgabe übernehmen können, sind:
 
@@ -125,29 +125,29 @@ Einige Beispiele für Tools, die diese Aufgabe übernehmen können, sind:
 
 In den nächsten Kapiteln werde ich Ihnen konkretere Beispiele geben.
 
-## Neustart
+## Neustart { #restarts }
 
 Ähnlich wie Sie sicherstellen möchten, dass Ihre Anwendung beim Hochfahren ausgeführt wird, möchten Sie wahrscheinlich auch sicherstellen, dass diese nach Fehlern **neu gestartet** wird.
 
-### Wir machen Fehler
+### Wir machen Fehler { #we-make-mistakes }
 
 Wir, als Menschen, machen ständig **Fehler**. Software hat fast *immer* **Bugs**, die an verschiedenen Stellen versteckt sind. 🐛
 
 Und wir als Entwickler verbessern den Code ständig, wenn wir diese Bugs finden und neue Funktionen implementieren (und möglicherweise auch neue Bugs hinzufügen 😅).
 
-### Kleine Fehler automatisch handhaben
+### Kleine Fehler automatisch handhaben { #small-errors-automatically-handled }
 
-Wenn beim Erstellen von Web-APIs mit FastAPI ein Fehler in unserem Code auftritt, wird FastAPI ihn normalerweise dem einzelnen Request zurückgeben, der den Fehler ausgelöst hat. 🛡
+Wenn beim Erstellen von Web-APIs mit FastAPI ein Fehler in unserem Code auftritt, wird FastAPI ihn normalerweise dem einzelnen <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> zurückgeben, der den Fehler ausgelöst hat. 🛡
 
 Der Client erhält für diesen Request einen **500 Internal Server Error**, aber die Anwendung arbeitet bei den nächsten Requests weiter, anstatt einfach komplett abzustürzen.
 
-### Größere Fehler – Abstürze
+### Größere Fehler – Abstürze { #bigger-errors-crashes }
 
 Dennoch kann es vorkommen, dass wir Code schreiben, der **die gesamte Anwendung zum Absturz bringt** und so zum Absturz von Uvicorn und Python führt. 💥
 
 Und dennoch möchten Sie wahrscheinlich nicht, dass die Anwendung tot bleibt, weil an einer Stelle ein Fehler aufgetreten ist. Sie möchten wahrscheinlich, dass sie zumindest für die *Pfadoperationen*, die nicht fehlerhaft sind, **weiterläuft**.
 
-### Neustart nach Absturz
+### Neustart nach Absturz { #restart-after-crash }
 
 Aber in den Fällen mit wirklich schwerwiegenden Fehlern, die den laufenden **Prozess** zum Absturz bringen, benötigen Sie eine externe Komponente, die den Prozess **neu startet**, zumindest ein paar Mal ...
 
@@ -161,7 +161,7 @@ Konzentrieren wir uns also auf die Hauptfälle, in denen die Anwendung in bestim
 
 Sie möchten wahrscheinlich, dass eine **externe Komponente** für den Neustart Ihrer Anwendung verantwortlich ist, da zu diesem Zeitpunkt dieselbe Anwendung mit Uvicorn und Python bereits abgestürzt ist und es daher nichts im selben Code derselben Anwendung gibt, was etwas dagegen tun kann.
 
-### Beispieltools zum automatischen Neustart
+### Beispieltools zum automatischen Neustart { #example-tools-to-restart-automatically }
 
 In den meisten Fällen wird dasselbe Tool, das zum **Ausführen des Programms beim Hochfahren** verwendet wird, auch für automatische **Neustarts** verwendet.
 
@@ -176,19 +176,19 @@ Dies könnte zum Beispiel erledigt werden durch:
 * Intern von einem Cloud-Anbieter im Rahmen seiner Dienste
 * Andere ...
 
-## Replikation – Prozesse und Arbeitsspeicher
+## Replikation – Prozesse und Arbeitsspeicher { #replication-processes-and-memory }
 
-Wenn Sie eine FastAPI-Anwendung verwenden und ein Serverprogramm wie Uvicorn verwenden, kann **ein einzelner Prozess** mehrere Clients gleichzeitig bedienen.
+Wenn Sie eine FastAPI-Anwendung verwenden und ein Serverprogramm wie den `fastapi`-Befehl, der Uvicorn ausführt, kann **ein einzelner Prozess** an mehrere Clients gleichzeitig ausliefern.
 
-In vielen Fällen möchten Sie jedoch mehrere Prozesse gleichzeitig ausführen.
+In vielen Fällen möchten Sie jedoch mehrere Workerprozesse gleichzeitig ausführen.
 
-### Mehrere Prozesse – Worker
+### Mehrere Prozesse – Worker { #multiple-processes-workers }
 
 Wenn Sie mehr Clients haben, als ein einzelner Prozess verarbeiten kann (z. B. wenn die virtuelle Maschine nicht sehr groß ist) und die CPU des Servers **mehrere Kerne** hat, dann könnten **mehrere Prozesse** gleichzeitig mit derselben Anwendung laufen und alle Requests unter sich verteilen.
 
 Wenn Sie mit **mehreren Prozessen** dasselbe API-Programm ausführen, werden diese üblicherweise als **<abbr title="Arbeiter">Worker</abbr>** bezeichnet.
 
-### Workerprozesse und Ports
+### Workerprozesse und Ports { #worker-processes-and-ports }
 
 Erinnern Sie sich aus der Dokumentation [Über HTTPS](https.md){.internal-link target=_blank}, dass nur ein Prozess auf einer Kombination aus Port und IP-Adresse auf einem Server lauschen kann?
 
@@ -196,35 +196,35 @@ Das ist immer noch wahr.
 
 Um also **mehrere Prozesse** gleichzeitig zu haben, muss es einen **einzelnen Prozess geben, der einen Port überwacht**, welcher dann die Kommunikation auf irgendeine Weise an jeden Workerprozess überträgt.
 
-### Arbeitsspeicher pro Prozess
+### Arbeitsspeicher pro Prozess { #memory-per-process }
 
 Wenn das Programm nun Dinge in den Arbeitsspeicher lädt, zum Beispiel ein Modell für maschinelles Lernen in einer Variablen oder den Inhalt einer großen Datei in einer Variablen, verbraucht das alles **einen Teil des Arbeitsspeichers (RAM – Random Access Memory)** des Servers.
 
 Und mehrere Prozesse teilen sich normalerweise keinen Speicher. Das bedeutet, dass jeder laufende Prozess seine eigenen Dinge, eigenen Variablen und eigenen Speicher hat. Und wenn Sie in Ihrem Code viel Speicher verbrauchen, verbraucht **jeder Prozess** die gleiche Menge Speicher.
 
-### Serverspeicher
+### Serverspeicher { #server-memory }
 
 Wenn Ihr Code beispielsweise ein Machine-Learning-Modell mit **1 GB Größe** lädt und Sie einen Prozess mit Ihrer API ausführen, verbraucht dieser mindestens 1 GB RAM. Und wenn Sie **4 Prozesse** (4 Worker) starten, verbraucht jeder 1 GB RAM. Insgesamt verbraucht Ihre API also **4 GB RAM**.
 
 Und wenn Ihr entfernter Server oder Ihre virtuelle Maschine nur über 3 GB RAM verfügt, führt der Versuch, mehr als 4 GB RAM zu laden, zu Problemen. 🚨
 
-### Mehrere Prozesse – Ein Beispiel
+### Mehrere Prozesse – Ein Beispiel { #multiple-processes-an-example }
 
 Im folgenden Beispiel gibt es einen **Manager-Prozess**, welcher zwei **Workerprozesse** startet und steuert.
 
 Dieser Manager-Prozess wäre wahrscheinlich derjenige, welcher der IP am **Port** lauscht. Und er würde die gesamte Kommunikation an die Workerprozesse weiterleiten.
 
-Diese Workerprozesse würden Ihre Anwendung ausführen, sie würden die Hauptberechnungen durchführen, um einen **Request** entgegenzunehmen und eine **Response** zurückzugeben, und sie würden alles, was Sie in Variablen einfügen, in den RAM laden.
+Diese Workerprozesse würden Ihre Anwendung ausführen, sie würden die Hauptberechnungen durchführen, um einen **<abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr>** entgegenzunehmen und eine **<abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr>** zurückzugeben, und sie würden alles, was Sie in Variablen einfügen, in den RAM laden.
 
 <img src="/img/deployment/concepts/process-ram.drawio.svg">
 
-Und natürlich würden auf derselben Maschine neben Ihrer Anwendung wahrscheinlich auch **andere Prozesse** laufen.
+Und natürlich würden auf derselben Maschine neben Ihrer Anwendung wahrscheinlich **andere Prozesse** laufen.
 
 Ein interessantes Detail ist dabei, dass der Prozentsatz der von jedem Prozess verwendeten **CPU** im Laufe der Zeit stark **variieren** kann, der **Arbeitsspeicher (RAM)** jedoch normalerweise mehr oder weniger **stabil** bleibt.
 
 Wenn Sie eine API haben, die jedes Mal eine vergleichbare Menge an Berechnungen durchführt, und Sie viele Clients haben, dann wird die **CPU-Auslastung** wahrscheinlich *ebenfalls stabil sein* (anstatt ständig schnell zu steigen und zu fallen).
 
-### Beispiele für Replikation-Tools und -Strategien
+### Beispiele für Replikation-Tools und -Strategien { #examples-of-replication-tools-and-strategies }
 
 Es gibt mehrere Ansätze, um dies zu erreichen, und ich werde Ihnen in den nächsten Kapiteln mehr über bestimmte Strategien erzählen, beispielsweise wenn es um Docker und Container geht.
 
@@ -232,9 +232,7 @@ Die wichtigste zu berücksichtigende Einschränkung besteht darin, dass es eine
 
 Hier sind einige mögliche Kombinationen und Strategien:
 
-* **Gunicorn**, welches **Uvicorn-Worker** managt
-    * Gunicorn wäre der **Prozessmanager**, der die **IP** und den **Port** überwacht, die Replikation würde durch **mehrere Uvicorn-Workerprozesse** erfolgen
-* **Uvicorn**, welches **Uvicorn-Worker** managt
+* **Uvicorn** mit `--workers`
     * Ein Uvicorn-**Prozessmanager** würde der **IP** am **Port** lauschen, und er würde **mehrere Uvicorn-Workerprozesse** starten.
 * **Kubernetes** und andere verteilte **Containersysteme**
     * Etwas in der **Kubernetes**-Ebene würde die **IP** und den **Port** abhören. Die Replikation hätte **mehrere Container**, in jedem wird jeweils **ein Uvicorn-Prozess** ausgeführt.
@@ -249,7 +247,7 @@ Ich werde Ihnen in einem zukünftigen Kapitel mehr über Container-Images, Docke
 
 ///
 
-## Schritte vor dem Start
+## Schritte vor dem Start { #previous-steps-before-starting }
 
 Es gibt viele Fälle, in denen Sie, **bevor Sie Ihre Anwendung starten**, einige Schritte ausführen möchten.
 
@@ -271,7 +269,7 @@ In diesem Fall müssen Sie sich darüber keine Sorgen machen. 🤷
 
 ///
 
-### Beispiele für Strategien für Vorab-Schritte
+### Beispiele für Strategien für Vorab-Schritte { #examples-of-previous-steps-strategies }
 
 Es hängt **stark** davon ab, wie Sie **Ihr System bereitstellen**, und hängt wahrscheinlich mit der Art und Weise zusammen, wie Sie Programme starten, Neustarts durchführen, usw.
 
@@ -287,7 +285,7 @@ Konkretere Beispiele hierfür mit Containern gebe ich Ihnen in einem späteren K
 
 ///
 
-## Ressourcennutzung
+## Ressourcennutzung { #resource-utilization }
 
 Ihr(e) Server ist (sind) eine **Ressource**, welche Sie mit Ihren Programmen, der Rechenzeit auf den CPUs und dem verfügbaren RAM-Speicher verbrauchen oder **nutzen** können.
 
@@ -303,11 +301,11 @@ In diesem Fall wäre es besser, **einen zusätzlichen Server** zu besorgen und e
 
 Es besteht auch die Möglichkeit, dass es aus irgendeinem Grund zu **Spitzen** in der Nutzung Ihrer API kommt. Vielleicht ist diese viral gegangen, oder vielleicht haben andere Dienste oder Bots damit begonnen, sie zu nutzen. Und vielleicht möchten Sie in solchen Fällen über zusätzliche Ressourcen verfügen, um auf der sicheren Seite zu sein.
 
-Sie können eine **beliebige Zahl** festlegen, um beispielsweise eine Ressourcenauslastung zwischen **50 % und 90 %** anzustreben. Der Punkt ist, dass dies wahrscheinlich die wichtigen Dinge sind, die Sie messen und verwenden sollten, um Ihre Deployments zu optimieren.
+Sie können eine **beliebige Zahl** festlegen, um beispielsweise eine Ressourcenauslastung zwischen **50 % und 90 %** anzustreben. Der Punkt ist, dass dies wahrscheinlich die wichtigen Dinge sind, die Sie messen und verwenden sollten, um Ihre Deployments zu optimieren.
 
 Sie können einfache Tools wie `htop` verwenden, um die in Ihrem Server verwendete CPU und den RAM oder die von jedem Prozess verwendete Menge anzuzeigen. Oder Sie können komplexere Überwachungstools verwenden, die möglicherweise auf mehrere Server usw. verteilt sind.
 
-## Zusammenfassung
+## Zusammenfassung { #recap }
 
 Sie haben hier einige der wichtigsten Konzepte gelesen, die Sie wahrscheinlich berücksichtigen müssen, wenn Sie entscheiden, wie Sie Ihre Anwendung bereitstellen:
 

docs/de/docs/deployment/docker.md

@@ -1,4 +1,4 @@
-# FastAPI in Containern – Docker
+# FastAPI in Containern – Docker { #fastapi-in-containers-docker }
 
 Beim Deployment von FastAPI-Anwendungen besteht ein gängiger Ansatz darin, ein **Linux-Containerimage** zu erstellen. Normalerweise erfolgt dies mit <a href="https://www.docker.com/" class="external-link" target="_blank">**Docker**</a>. Sie können dieses Containerimage dann auf eine von mehreren möglichen Arten bereitstellen.
 
@@ -6,11 +6,11 @@ Die Verwendung von Linux-Containern bietet mehrere Vorteile, darunter **Sicherhe
 
 /// tip | Tipp
 
-Sie haben es eilig und kennen sich bereits aus? Springen Sie zum [`Dockerfile` unten 👇](#ein-docker-image-fur-fastapi-erstellen).
+Sie haben es eilig und kennen sich bereits aus? Springen Sie zum [`Dockerfile` unten 👇](#build-a-docker-image-for-fastapi).
 
 ///
 
-<Details>
+<details>
 <summary>Dockerfile-Vorschau 👀</summary>
 
 ```Dockerfile
@@ -24,15 +24,15 @@ RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
 
 COPY ./app /code/app
 
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]
+CMD ["fastapi", "run", "app/main.py", "--port", "80"]
 
 # Wenn Sie hinter einem Proxy wie Nginx oder Traefik sind, fügen Sie --proxy-headers hinzu
-# CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80", "--proxy-headers"]
+# CMD ["fastapi", "run", "app/main.py", "--port", "80", "--proxy-headers"]
 ```
 
 </details>
 
-## Was ist ein Container?
+## Was ist ein Container { #what-is-a-container }
 
 Container (hauptsächlich Linux-Container) sind eine sehr **leichtgewichtige** Möglichkeit, Anwendungen einschließlich aller ihrer Abhängigkeiten und erforderlichen Dateien zu verpacken und sie gleichzeitig von anderen Containern (anderen Anwendungen oder Komponenten) im selben System isoliert zu halten.
 
@@ -42,7 +42,7 @@ Auf diese Weise verbrauchen Container **wenig Ressourcen**, eine Menge vergleich
 
 Container verfügen außerdem über ihre eigenen **isoliert** laufenden Prozesse (üblicherweise nur einen Prozess), über ihr eigenes Dateisystem und ihr eigenes Netzwerk, was die Bereitstellung, Sicherheit, Entwicklung usw. vereinfacht.
 
-## Was ist ein Containerimage?
+## Was ist ein Containerimage { #what-is-a-container-image }
 
 Ein **Container** wird von einem **Containerimage** ausgeführt.
 
@@ -50,17 +50,17 @@ Ein Containerimage ist eine **statische** Version aller Dateien, Umgebungsvariab
 
 Im Gegensatz zu einem „**Containerimage**“, bei dem es sich um den gespeicherten statischen Inhalt handelt, bezieht sich ein „**Container**“ normalerweise auf die laufende Instanz, das Ding, das **ausgeführt** wird.
 
-Wenn der **Container** gestartet und ausgeführt wird (gestartet von einem **Containerimage**), kann er Dateien, Umgebungsvariablen usw. erstellen oder ändern. Diese Änderungen sind nur in diesem Container vorhanden, nicht im zugrunde liegenden bestehen Containerimage (werden nicht auf der Festplatte gespeichert).
+Wenn der **Container** gestartet und ausgeführt wird (gestartet von einem **Containerimage**), kann er Dateien, Umgebungsvariablen usw. erstellen oder ändern. Diese Änderungen sind nur in diesem Container vorhanden, nicht im zugrunde liegenden Containerimage (werden nicht auf der Festplatte gespeichert).
 
 Ein Containerimage ist vergleichbar mit der **Programmdatei** und ihrem Inhalt, z. B. `python` und eine Datei `main.py`.
 
 Und der **Container** selbst (im Gegensatz zum **Containerimage**) ist die tatsächlich laufende Instanz des Images, vergleichbar mit einem **Prozess**. Tatsächlich läuft ein Container nur, wenn er einen **laufenden Prozess** hat (und normalerweise ist es nur ein einzelner Prozess). Der Container stoppt, wenn kein Prozess darin ausgeführt wird.
 
-## Containerimages
+## Containerimages { #container-images }
 
 Docker ist eines der wichtigsten Tools zum Erstellen und Verwalten von **Containerimages** und **Containern**.
 
-Und es gibt einen öffentlichen <a href="https://hub.docker.com/" class="external-link" target="_blank">Docker <abbr title="Umschlagsplatz">Hub</abbr></a> mit vorgefertigten **offiziellen Containerimages** für viele Tools, Umgebungen, Datenbanken und Anwendungen.
+Und es gibt einen öffentlichen <a href="https://hub.docker.com/" class="external-link" target="_blank">Docker <abbr title="Umschlagplatz">Hub</abbr></a> mit vorgefertigten **offiziellen Containerimages** für viele Tools, Umgebungen, Datenbanken und Anwendungen.
 
 Beispielsweise gibt es ein offizielles <a href="https://hub.docker.com/_/python" class="external-link" target="_blank">Python-Image</a>.
 
@@ -79,7 +79,7 @@ Sie würden also **mehrere Container** mit unterschiedlichen Dingen ausführen,
 
 In alle Containerverwaltungssysteme (wie Docker oder Kubernetes) sind diese Netzwerkfunktionen integriert.
 
-## Container und Prozesse
+## Container und Prozesse { #containers-and-processes }
 
 Ein **Containerimage** enthält normalerweise in seinen Metadaten das Standardprogramm oder den Standardbefehl, der ausgeführt werden soll, wenn der **Container** gestartet wird, sowie die Parameter, die an dieses Programm übergeben werden sollen. Sehr ähnlich zu dem, was wäre, wenn es über die Befehlszeile gestartet werden würde.
 
@@ -91,7 +91,7 @@ Ein Container hat normalerweise einen **einzelnen Prozess**, aber es ist auch m
 
 Es ist jedoch nicht möglich, einen laufenden Container, ohne **mindestens einen laufenden Prozess** zu haben. Wenn der Hauptprozess stoppt, stoppt der Container.
 
-## Ein Docker-Image für FastAPI erstellen
+## Ein Docker-Image für FastAPI erstellen { #build-a-docker-image-for-fastapi }
 
 Okay, wollen wir jetzt etwas bauen! 🚀
 
@@ -103,7 +103,7 @@ Das ist, was Sie in **den meisten Fällen** tun möchten, zum Beispiel:
 * Beim Betrieb auf einem **Raspberry Pi**
 * Bei Verwendung eines Cloud-Dienstes, der ein Containerimage für Sie ausführt, usw.
 
-### Paketanforderungen
+### Paketanforderungen { #package-requirements }
 
 Normalerweise befinden sich die **Paketanforderungen** für Ihre Anwendung in einer Datei.
 
@@ -116,9 +116,8 @@ Sie würden natürlich die gleichen Ideen verwenden, die Sie in [Über FastAPI-V
 Ihre `requirements.txt` könnte beispielsweise so aussehen:
 
 ```
-fastapi>=0.68.0,<0.69.0
-pydantic>=1.8.0,<2.0.0
-uvicorn>=0.15.0,<0.16.0
+fastapi[standard]>=0.113.0,<0.114.0
+pydantic>=2.7.0,<3.0.0
 ```
 
 Und normalerweise würden Sie diese Paketabhängigkeiten mit `pip` installieren, zum Beispiel:
@@ -128,20 +127,18 @@ Und normalerweise würden Sie diese Paketabhängigkeiten mit `pip` installieren,
 ```console
 $ pip install -r requirements.txt
 ---> 100%
-Successfully installed fastapi pydantic uvicorn
+Successfully installed fastapi pydantic
 ```
 
 </div>
 
-/// info
+/// info | Info
 
 Es gibt andere Formate und Tools zum Definieren und Installieren von Paketabhängigkeiten.
 
-Ich zeige Ihnen später in einem Abschnitt unten ein Beispiel unter Verwendung von Poetry. 👇
-
 ///
 
-### Den **FastAPI**-Code erstellen
+### Den **FastAPI**-Code erstellen { #create-the-fastapi-code }
 
 * Erstellen Sie ein `app`-Verzeichnis und betreten Sie es.
 * Erstellen Sie eine leere Datei `__init__.py`.
@@ -165,35 +162,35 @@ def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 
-### Dockerfile
+### Dockerfile { #dockerfile }
 
 Erstellen Sie nun im selben Projektverzeichnis eine Datei `Dockerfile` mit:
 
 ```{ .dockerfile .annotate }
-# (1)
+# (1)!
 FROM python:3.9
 
-# (2)
+# (2)!
 WORKDIR /code
 
-# (3)
+# (3)!
 COPY ./requirements.txt /code/requirements.txt
 
-# (4)
+# (4)!
 RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
 
-# (5)
+# (5)!
 COPY ./app /code/app
 
-# (6)
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]
+# (6)!
+CMD ["fastapi", "run", "app/main.py", "--port", "80"]
 ```
 
 1. Beginne mit dem offiziellen Python-Basisimage.
 
 2. Setze das aktuelle Arbeitsverzeichnis auf `/code`.
 
-    Hier plazieren wir die Datei `requirements.txt` und das Verzeichnis `app`.
+    Hier platzieren wir die Datei `requirements.txt` und das Verzeichnis `app`.
 
 3. Kopiere die Datei mit den Paketanforderungen in das Verzeichnis `/code`.
 
@@ -223,20 +220,50 @@ CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]
 
     Daher ist es wichtig, dies **nahe dem Ende** des `Dockerfile`s zu platzieren, um die Erstellungszeiten des Containerimages zu optimieren.
 
-6. Lege den **Befehl** fest, um den `uvicorn`-Server zu starten.
+6. Lege den **Befehl** fest, um `fastapi run` zu nutzen, welches Uvicorn darunter verwendet.
 
     `CMD` nimmt eine Liste von Zeichenfolgen entgegen. Jede dieser Zeichenfolgen entspricht dem, was Sie durch Leerzeichen getrennt in die Befehlszeile eingeben würden.
 
     Dieser Befehl wird aus dem **aktuellen Arbeitsverzeichnis** ausgeführt, dem gleichen `/code`-Verzeichnis, das Sie oben mit `WORKDIR /code` festgelegt haben.
 
-    Da das Programm unter `/code` gestartet wird und sich darin das Verzeichnis `./app` mit Ihrem Code befindet, kann **Uvicorn** `app` sehen und aus `app.main` **importieren**.
-
 /// tip | Tipp
 
 Lernen Sie, was jede Zeile bewirkt, indem Sie auf die Zahlenblasen im Code klicken. 👆
 
 ///
 
+/// warning | Achtung
+
+Stellen Sie sicher, dass Sie **immer** die **exec form** der Anweisung `CMD` verwenden, wie unten erläutert.
+
+///
+
+#### `CMD` – Exec Form verwenden { #use-cmd-exec-form }
+
+Die <a href="https://docs.docker.com/reference/dockerfile/#cmd" class="external-link" target="_blank">`CMD`</a> Docker-Anweisung kann in zwei Formen geschrieben werden:
+
+✅ **Exec** form:
+
+```Dockerfile
+# ✅ Tun Sie das
+CMD ["fastapi", "run", "app/main.py", "--port", "80"]
+```
+
+⛔️ **Shell** form:
+
+```Dockerfile
+# ⛔️ Tun Sie das nicht
+CMD fastapi run app/main.py --port 80
+```
+
+Achten Sie darauf, stets die **exec** form zu verwenden, um sicherzustellen, dass FastAPI ordnungsgemäß heruntergefahren wird und [Lifespan-Events](../advanced/events.md){.internal-link target=_blank} ausgelöst werden.
+
+Sie können mehr darüber in der <a href="https://docs.docker.com/reference/dockerfile/#shell-and-exec-form" class="external-link" target="_blank">Docker-Dokumentation für Shell und Exec Form lesen</a>.
+
+Dies kann insbesondere bei der Verwendung von `docker compose` deutlich spürbar sein. Sehen Sie sich diesen Abschnitt in der Docker Compose-FAQ für technische Details an: <a href="https://docs.docker.com/compose/faq/#why-do-my-services-take-10-seconds-to-recreate-or-stop" class="external-link" target="_blank">Warum benötigen meine Dienste 10 Sekunden, um neu erstellt oder gestoppt zu werden?</a>.
+
+#### Verzeichnisstruktur { #directory-structure }
+
 Sie sollten jetzt eine Verzeichnisstruktur wie diese haben:
 
 ```
@@ -248,15 +275,15 @@ Sie sollten jetzt eine Verzeichnisstruktur wie diese haben:
 └── requirements.txt
 ```
 
-#### Hinter einem TLS-Terminierungsproxy
+#### Hinter einem TLS-Terminierungsproxy { #behind-a-tls-termination-proxy }
 
-Wenn Sie Ihren Container hinter einem TLS-Terminierungsproxy (Load Balancer) wie Nginx oder Traefik ausführen, fügen Sie die Option `--proxy-headers` hinzu. Das sagt Uvicorn, den von diesem Proxy gesendeten Headern zu vertrauen und dass die Anwendung hinter HTTPS ausgeführt wird, usw.
+Wenn Sie Ihren Container hinter einem TLS-Terminierungsproxy (Load Balancer) wie Nginx oder Traefik ausführen, fügen Sie die Option `--proxy-headers` hinzu. Das sagt Uvicorn (durch das FastAPI-CLI), den von diesem Proxy gesendeten Headern zu vertrauen und dass die Anwendung hinter HTTPS ausgeführt wird, usw.
 
 ```Dockerfile
-CMD ["uvicorn", "app.main:app", "--proxy-headers", "--host", "0.0.0.0", "--port", "80"]
+CMD ["fastapi", "run", "app/main.py", "--proxy-headers", "--port", "80"]
 ```
 
-#### Docker-Cache
+#### Docker-Cache { #docker-cache }
 
 In diesem `Dockerfile` gibt es einen wichtigen Trick: Wir kopieren zuerst die **Datei nur mit den Abhängigkeiten**, nicht den Rest des Codes. Lassen Sie mich Ihnen erklären, warum.
 
@@ -288,7 +315,7 @@ Dann, gegen Ende des `Dockerfile`s, kopieren wir den gesamten Code. Da sich der
 COPY ./app /code/app
 ```
 
-### Das Docker-Image erstellen
+### Das Docker-Image erstellen { #build-the-docker-image }
 
 Nachdem nun alle Dateien vorhanden sind, erstellen wir das Containerimage.
 
@@ -313,7 +340,7 @@ In diesem Fall handelt es sich um dasselbe aktuelle Verzeichnis (`.`).
 
 ///
 
-### Den Docker-Container starten
+### Den Docker-Container starten { #start-the-docker-container }
 
 * Führen Sie einen Container basierend auf Ihrem Image aus:
 
@@ -325,7 +352,7 @@ $ docker run -d --name mycontainer -p 80:80 myimage
 
 </div>
 
-## Es überprüfen
+## Es testen { #check-it }
 
 Sie sollten es in der URL Ihres Docker-Containers überprüfen können, zum Beispiel: <a href="http://192.168.99.100/items/5?q=somequery" class="external-link" target="_blank">http://192.168.99.100/items/5?q=somequery</a> oder <a href="http://127.0.0.1/items/5?q=somequery" class="external-link" target="_blank">http://127.0.0.1/items/5?q=somequery</a> (oder gleichwertig, unter Verwendung Ihres Docker-Hosts).
 
@@ -335,7 +362,7 @@ Sie werden etwas sehen wie:
 {"item_id": 5, "q": "somequery"}
 ```
 
-## Interaktive API-Dokumentation
+## Interaktive API-Dokumentation { #interactive-api-docs }
 
 Jetzt können Sie auf <a href="http://192.168.99.100/docs" class="external-link" target="_blank">http://192.168.99.100/docs</a> oder <a href="http://127.0.0.1/docs" class="external-link" target="_blank">http://127.0.0.1/docs</a> gehen (oder ähnlich, unter Verwendung Ihres Docker-Hosts).
 
@@ -343,7 +370,7 @@ Sie sehen die automatische interaktive API-Dokumentation (bereitgestellt von <a
 
 ![Swagger-Oberfläche](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)
 
-## Alternative API-Dokumentation
+## Alternative API-Dokumentation { #alternative-api-docs }
 
 Sie können auch auf <a href="http://192.168.99.100/redoc" class="external-link" target="_blank">http://192.168.99.100/redoc</a> oder <a href="http://127.0.0.1/redoc" class="external-link" target="_blank">http://127.0.0.1/redoc</a> gehen (oder ähnlich, unter Verwendung Ihres Docker-Hosts).
 
@@ -351,7 +378,7 @@ Sie sehen die alternative automatische Dokumentation (bereitgestellt von <a href
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
 
-## Ein Docker-Image mit einem Single-File-FastAPI erstellen
+## Ein Docker-Image mit einem Single-File-FastAPI erstellen { #build-a-docker-image-with-a-single-file-fastapi }
 
 Wenn Ihr FastAPI eine einzelne Datei ist, zum Beispiel `main.py` ohne ein `./app`-Verzeichnis, könnte Ihre Dateistruktur wie folgt aussehen:
 
@@ -373,20 +400,20 @@ COPY ./requirements.txt /code/requirements.txt
 
 RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
 
-# (1)
+# (1)!
 COPY ./main.py /code/
 
-# (2)
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "80"]
+# (2)!
+CMD ["fastapi", "run", "main.py", "--port", "80"]
 ```
 
 1. Kopiere die Datei `main.py` direkt in das Verzeichnis `/code` (ohne ein Verzeichnis `./app`).
 
-2. Führe Uvicorn aus und weisen es an, das `app`-Objekt von `main` zu importieren (anstatt von `app.main` zu importieren).
+2. Verwenden Sie `fastapi run`, um Ihre Anwendung in der einzelnen Datei `main.py` bereitzustellen.
 
-Passen Sie dann den Uvicorn-Befehl an, um das neue Modul `main` anstelle von `app.main` zu verwenden, um das FastAPI-Objekt `app` zu importieren.
+Indem Sie die Datei an `fastapi run` übergeben, wird automatisch erkannt, dass es sich um eine einzelne Datei handelt und nicht um den Teil eines Packages, und es wird wissen, wie es zu importieren ist und Ihre FastAPI-App bereitzustellen. 😎
 
-## Deployment-Konzepte
+## Deployment-Konzepte { #deployment-concepts }
 
 Lassen Sie uns noch einmal über einige der gleichen [Deployment-Konzepte](concepts.md){.internal-link target=_blank} in Bezug auf Container sprechen.
 
@@ -396,14 +423,14 @@ Die **gute Nachricht** ist, dass es mit jeder unterschiedlichen Strategie eine M
 
 Sehen wir uns diese **Deployment-Konzepte** im Hinblick auf Container noch einmal an:
 
-* Sicherheit – HTTPS
+* HTTPS
 * Beim Hochfahren ausführen
 * Neustarts
 * Replikation (die Anzahl der laufenden Prozesse)
 * Arbeitsspeicher
 * Schritte vor dem Start
 
-## HTTPS
+## HTTPS { #https }
 
 Wenn wir uns nur auf das **Containerimage** für eine FastAPI-Anwendung (und später auf den laufenden **Container**) konzentrieren, würde HTTPS normalerweise **extern** von einem anderen Tool verarbeitet.
 
@@ -417,7 +444,7 @@ Traefik verfügt über Integrationen mit Docker, Kubernetes und anderen, sodass
 
 Alternativ könnte HTTPS von einem Cloud-Anbieter als einer seiner Dienste gehandhabt werden (während die Anwendung weiterhin in einem Container ausgeführt wird).
 
-## Beim Hochfahren ausführen und Neustarts
+## Beim Hochfahren ausführen und Neustarts { #running-on-startup-and-restarts }
 
 Normalerweise gibt es ein anderes Tool, das für das **Starten und Ausführen** Ihres Containers zuständig ist.
 
@@ -427,15 +454,15 @@ In den meisten (oder allen) Fällen gibt es eine einfache Option, um die Ausfüh
 
 Ohne die Verwendung von Containern kann es umständlich und schwierig sein, Anwendungen beim Hochfahren auszuführen und neu zu starten. Bei der **Arbeit mit Containern** ist diese Funktionalität jedoch in den meisten Fällen standardmäßig enthalten. ✨
 
-## Replikation – Anzahl der Prozesse
+## Replikation – Anzahl der Prozesse { #replication-number-of-processes }
 
-Wenn Sie einen <abbr title="Eine Gruppe von Maschinen, die so konfiguriert sind, dass sie verbunden sind und auf irgendeine Weise zusammenarbeiten.">Cluster</abbr> von Maschinen mit **Kubernetes**, Docker Swarm Mode, Nomad verwenden, oder einem anderen, ähnlich komplexen System zur Verwaltung verteilter Container auf mehreren Maschinen, möchten Sie wahrscheinlich die **Replikation auf Cluster-Ebene abwickeln**, anstatt in jedem Container einen **Prozessmanager** (wie Gunicorn mit Workern) zu verwenden.
+Wenn Sie einen <abbr title="Eine Gruppe von Maschinen, die so konfiguriert sind, dass sie verbunden sind und auf irgendeine Weise zusammenarbeiten.">Cluster</abbr> von Maschinen mit **Kubernetes**, Docker Swarm Mode, Nomad verwenden, oder einem anderen, ähnlich komplexen System zur Verwaltung verteilter Container auf mehreren Maschinen, möchten Sie wahrscheinlich die **Replikation auf Cluster-Ebene abwickeln**, anstatt in jedem Container einen **Prozessmanager** (wie Uvicorn mit Workern) zu verwenden.
 
-Diese verteilten Containerverwaltungssysteme wie Kubernetes verfügen normalerweise über eine integrierte Möglichkeit, die **Replikation von Containern** zu handhaben und gleichzeitig **Load Balancing** für die eingehenden Requests zu unterstützen. Alles auf **Cluster-Ebene**.
+Diese verteilten Containerverwaltungssysteme wie Kubernetes verfügen normalerweise über eine integrierte Möglichkeit, die **Replikation von Containern** zu handhaben und gleichzeitig **Load Balancing** für die eingehenden <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Requests</abbr> zu unterstützen. Alles auf **Cluster-Ebene**.
 
-In diesen Fällen möchten Sie wahrscheinlich ein **Docker-Image von Grund auf** erstellen, wie [oben erklärt](#dockerfile), Ihre Abhängigkeiten installieren und **einen einzelnen Uvicorn-Prozess** ausführen, anstatt etwas wie Gunicorn mit Uvicorn-Workern auszuführen.
+In diesen Fällen möchten Sie wahrscheinlich ein **Docker-Image von Grund auf** erstellen, wie [oben erklärt](#dockerfile), Ihre Abhängigkeiten installieren und **einen einzelnen Uvicorn-Prozess** ausführen, anstatt mehrere Uvicorn-Worker zu verwenden.
 
-### Load Balancer
+### Load Balancer { #load-balancer }
 
 Bei der Verwendung von Containern ist normalerweise eine Komponente vorhanden, **die am Hauptport lauscht**. Es könnte sich um einen anderen Container handeln, der auch ein **TLS-Terminierungsproxy** ist, um **HTTPS** zu verarbeiten, oder ein ähnliches Tool.
 
@@ -449,7 +476,7 @@ Die gleiche **TLS-Terminierungsproxy**-Komponente, die für HTTPS verwendet wird
 
 Und wenn Sie mit Containern arbeiten, verfügt das gleiche System, mit dem Sie diese starten und verwalten, bereits über interne Tools, um die **Netzwerkkommunikation** (z. B. HTTP-Requests) von diesem **Load Balancer** (das könnte auch ein **TLS-Terminierungsproxy** sein) zu den Containern mit Ihrer Anwendung weiterzuleiten.
 
-### Ein Load Balancer – mehrere Workercontainer
+### Ein Load Balancer – mehrere Workercontainer { #one-load-balancer-multiple-worker-containers }
 
 Bei der Arbeit mit **Kubernetes** oder ähnlichen verteilten Containerverwaltungssystemen würde die Verwendung ihrer internen Netzwerkmechanismen es dem einzelnen **Load Balancer**, der den Haupt-**Port** überwacht, ermöglichen, Kommunikation (Requests) an möglicherweise **mehrere Container** weiterzuleiten, in denen Ihre Anwendung ausgeführt wird.
 
@@ -459,41 +486,48 @@ Und das verteilte Containersystem mit dem **Load Balancer** würde **die Request
 
 Und normalerweise wäre dieser **Load Balancer** in der Lage, Requests zu verarbeiten, die an *andere* Anwendungen in Ihrem Cluster gerichtet sind (z. B. eine andere Domain oder unter einem anderen URL-Pfad-Präfix), und würde diese Kommunikation an die richtigen Container weiterleiten für *diese andere* Anwendung, die in Ihrem Cluster ausgeführt wird.
 
-### Ein Prozess pro Container
+### Ein Prozess pro Container { #one-process-per-container }
 
-In einem solchen Szenario möchten Sie wahrscheinlich **einen einzelnen (Uvicorn-)Prozess pro Container** haben, da Sie die Replikation bereits auf Cluster ebene durchführen würden.
+In einem solchen Szenario möchten Sie wahrscheinlich **einen einzelnen (Uvicorn-)Prozess pro Container** haben, da Sie die Replikation bereits auf Cluster-Ebene durchführen würden.
 
-In diesem Fall möchten Sie also **nicht** einen Prozessmanager wie Gunicorn mit Uvicorn-Workern oder Uvicorn mit seinen eigenen Uvicorn-Workern haben. Sie möchten nur einen **einzelnen Uvicorn-Prozess** pro Container haben (wahrscheinlich aber mehrere Container).
+In diesem Fall möchten Sie also **nicht** mehrere Worker im Container haben, z. B. mit der `--workers` Befehlszeilenoption. Sie möchten nur einen **einzelnen Uvicorn-Prozess** pro Container haben (wahrscheinlich aber mehrere Container).
 
-Ein weiterer Prozessmanager im Container (wie es bei Gunicorn oder Uvicorn der Fall wäre, welche Uvicorn-Worker verwalten) würde nur **unnötige Komplexität** hinzufügen, um welche Sie sich höchstwahrscheinlich bereits mit Ihrem Clustersystem kümmern.
+Ein weiterer Prozessmanager im Container (wie es bei mehreren Workern der Fall wäre) würde nur **unnötige Komplexität** hinzufügen, um welche Sie sich höchstwahrscheinlich bereits mit Ihrem Clustersystem kümmern.
 
-### Container mit mehreren Prozessen und Sonderfälle
+### Container mit mehreren Prozessen und Sonderfälle { #containers-with-multiple-processes-and-special-cases }
 
-Natürlich gibt es **Sonderfälle**, in denen Sie **einen Container** mit einem **Gunicorn-Prozessmanager** haben möchten, welcher mehrere **Uvicorn-Workerprozesse** darin startet.
+Natürlich gibt es **Sonderfälle**, in denen Sie **einen Container** mit mehreren **Uvicorn-Workerprozessen** haben möchten.
 
-In diesen Fällen können Sie das **offizielle Docker-Image** verwenden, welches **Gunicorn** als Prozessmanager enthält, welcher mehrere **Uvicorn-Workerprozesse** ausführt, sowie einige Standardeinstellungen, um die Anzahl der Worker basierend auf den verfügbaren CPU-Kernen automatisch anzupassen. Ich erzähle Ihnen weiter unten in [Offizielles Docker-Image mit Gunicorn – Uvicorn](#offizielles-docker-image-mit-gunicorn-uvicorn) mehr darüber.
+In diesen Fällen können Sie die `--workers` Befehlszeilenoption verwenden, um die Anzahl der zu startenden Worker festzulegen:
 
-Hier sind einige Beispiele, wann das sinnvoll sein könnte:
+```{ .dockerfile .annotate }
+FROM python:3.9
 
-#### Eine einfache Anwendung
+WORKDIR /code
 
-Sie könnten einen Prozessmanager im Container haben wollen, wenn Ihre Anwendung **einfach genug** ist, sodass Sie die Anzahl der Prozesse nicht (zumindest noch nicht) zu stark tunen müssen und Sie einfach einen automatisierten Standard verwenden können (mit dem offiziellen Docker-Image), und Sie führen es auf einem **einzelnen Server** aus, nicht auf einem Cluster.
+COPY ./requirements.txt /code/requirements.txt
 
-#### Docker Compose
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
 
-Sie könnten das Deployment auf einem **einzelnen Server** (kein Cluster) mit **Docker Compose** durchführen, sodass Sie keine einfache Möglichkeit hätten, die Replikation von Containern (mit Docker Compose) zu verwalten und gleichzeitig das gemeinsame Netzwerk mit **Load Balancing** zu haben.
+COPY ./app /code/app
 
-Dann möchten Sie vielleicht **einen einzelnen Container** mit einem **Prozessmanager** haben, der darin **mehrere Workerprozesse** startet.
+# (1)!
+CMD ["fastapi", "run", "app/main.py", "--port", "80", "--workers", "4"]
+```
+
+1. Hier verwenden wir die `--workers` Befehlszeilenoption, um die Anzahl der Worker auf 4 festzulegen.
 
-#### Prometheus und andere Gründe
+Hier sind einige Beispiele, wann das sinnvoll sein könnte:
+
+#### Eine einfache Anwendung { #a-simple-app }
 
-Sie könnten auch **andere Gründe** haben, die es einfacher machen würden, einen **einzelnen Container** mit **mehreren Prozessen** zu haben, anstatt **mehrere Container** mit **einem einzelnen Prozess** in jedem von ihnen.
+Sie könnten einen Prozessmanager im Container haben wollen, wenn Ihre Anwendung **einfach genug** ist, sodass Sie es auf einem **einzelnen Server** ausführen können, nicht auf einem Cluster.
 
-Beispielsweise könnten Sie (abhängig von Ihrem Setup) ein Tool wie einen Prometheus-Exporter im selben Container haben, welcher Zugriff auf **jeden der eingehenden Requests** haben sollte.
+#### Docker Compose { #docker-compose }
 
-Wenn Sie in hier **mehrere Container** hätten, würde Prometheus beim **Lesen der Metriken** standardmäßig jedes Mal diejenigen für **einen einzelnen Container** abrufen (für den Container, der den spezifischen Request verarbeitet hat), anstatt die **akkumulierten Metriken** für alle replizierten Container abzurufen.
+Sie könnten das Deployment auf einem **einzelnen Server** (kein Cluster) mit **Docker Compose** durchführen, sodass Sie keine einfache Möglichkeit hätten, die Replikation von Containern (mit Docker Compose) zu verwalten und gleichzeitig das gemeinsame Netzwerk mit **Load Balancing** zu haben.
 
-In diesem Fall könnte einfacher sein, **einen Container** mit **mehreren Prozessen** und ein lokales Tool (z. B. einen Prometheus-Exporter) in demselben Container zu haben, welches Prometheus-Metriken für alle internen Prozesse sammelt und diese Metriken für diesen einzelnen Container offenlegt.
+Dann möchten Sie vielleicht **einen einzelnen Container** mit einem **Prozessmanager** haben, der darin **mehrere Workerprozesse** startet.
 
 ---
 
@@ -506,25 +540,25 @@ Der Hauptpunkt ist, dass **keine** dieser Regeln **in Stein gemeißelt** ist, de
 * Arbeitsspeicher
 * Schritte vor dem Start
 
-## Arbeitsspeicher
+## Arbeitsspeicher { #memory }
 
 Wenn Sie **einen einzelnen Prozess pro Container** ausführen, wird von jedem dieser Container (mehr als einer, wenn sie repliziert werden) eine mehr oder weniger klar definierte, stabile und begrenzte Menge an Arbeitsspeicher verbraucht.
 
-Und dann können Sie dieselben Speichergrenzen und -anforderungen in Ihren Konfigurationen für Ihr Container-Management-System festlegen (z. B. in **Kubernetes**). Auf diese Weise ist es in der Lage, die Container auf den **verfügbaren Maschinen** zu replizieren, wobei die von denen benötigte Speichermenge und die auf den Maschinen im Cluster verfügbare Menge berücksichtigt werden.
+Und dann können Sie dieselben Speichergrenzen und -anforderungen in Ihren Konfigurationen für Ihr Container-Management-System festlegen (z. B. in **Kubernetes**). Auf diese Weise ist es in der Lage, die Container auf den **verfügbaren Maschinen** zu replizieren, wobei die von diesen benötigte Speichermenge und die auf den Maschinen im Cluster verfügbare Menge berücksichtigt werden.
 
-Wenn Ihre Anwendung **einfach** ist, wird dies wahrscheinlich **kein Problem darstellen** und Sie müssen möglicherweise keine festen Speichergrenzen angeben. Wenn Sie jedoch **viel Speicher verbrauchen** (z. B. bei **Modellen für maschinelles Lernen**), sollten Sie überprüfen, wie viel Speicher Sie verbrauchen, und die **Anzahl der Container** anpassen, die in **jeder Maschine** ausgeführt werden. (und möglicherweise weitere Maschinen zu Ihrem Cluster hinzufügen).
+Wenn Ihre Anwendung **einfach** ist, wird dies wahrscheinlich **kein Problem darstellen** und Sie müssen möglicherweise keine festen Speichergrenzen angeben. Wenn Sie jedoch **viel Speicher verbrauchen** (z. B. bei **Modellen für maschinelles Lernen**), sollten Sie überprüfen, wie viel Speicher Sie verbrauchen, und die **Anzahl der Container** anpassen, die in **jeder Maschine** ausgeführt werden (und möglicherweise weitere Maschinen zu Ihrem Cluster hinzufügen).
 
-Wenn Sie **mehrere Prozesse pro Container** ausführen (zum Beispiel mit dem offiziellen Docker-Image), müssen Sie sicherstellen, dass die Anzahl der gestarteten Prozesse nicht **mehr Speicher verbraucht** als verfügbar ist.
+Wenn Sie **mehrere Prozesse pro Container** ausführen, müssen Sie sicherstellen, dass die Anzahl der gestarteten Prozesse nicht **mehr Speicher verbraucht** als verfügbar ist.
 
-## Schritte vor dem Start und Container
+## Schritte vor dem Start und Container { #previous-steps-before-starting-and-containers }
 
 Wenn Sie Container (z. B. Docker, Kubernetes) verwenden, können Sie hauptsächlich zwei Ansätze verwenden.
 
-### Mehrere Container
+### Mehrere Container { #multiple-containers }
 
-Wenn Sie **mehrere Container** haben, von denen wahrscheinlich jeder einen **einzelnen Prozess** ausführt (z. B. in einem **Kubernetes**-Cluster), dann möchten Sie wahrscheinlich einen **separaten Container** haben, welcher die Arbeit der **Vorab-Schritte** in einem einzelnen Container, mit einem einzelnenen Prozess ausführt, **bevor** die replizierten Workercontainer ausgeführt werden.
+Wenn Sie **mehrere Container** haben, von denen wahrscheinlich jeder einen **einzelnen Prozess** ausführt (z. B. in einem **Kubernetes**-Cluster), dann möchten Sie wahrscheinlich einen **separaten Container** haben, welcher die Arbeit der **Vorab-Schritte** in einem einzelnen Container, mit einem einzelnen Prozess ausführt, **bevor** die replizierten Workercontainer ausgeführt werden.
 
-/// info
+/// info | Info
 
 Wenn Sie Kubernetes verwenden, wäre dies wahrscheinlich ein <a href="https://kubernetes.io/docs/concepts/workloads/pods/init-containers/" class="external-link" target="_blank">Init-Container</a>.
 
@@ -532,83 +566,29 @@ Wenn Sie Kubernetes verwenden, wäre dies wahrscheinlich ein <a href="https://ku
 
 Wenn es in Ihrem Anwendungsfall kein Problem darstellt, diese vorherigen Schritte **mehrmals parallel** auszuführen (z. B. wenn Sie keine Datenbankmigrationen ausführen, sondern nur prüfen, ob die Datenbank bereits bereit ist), können Sie sie auch einfach in jedem Container direkt vor dem Start des Hauptprozesses einfügen.
 
-### Einzelner Container
+### Einzelner Container { #single-container }
 
-Wenn Sie ein einfaches Setup mit einem **einzelnen Container** haben, welcher dann mehrere **Workerprozesse** (oder auch nur einen Prozess) startet, können Sie die Vorab-Schritte im selben Container direkt vor dem Starten des Prozesses mit der Anwendung ausführen. Das offizielle Docker-Image unterstützt das intern.
+Wenn Sie ein einfaches Setup mit einem **einzelnen Container** haben, welcher dann mehrere **Workerprozesse** (oder auch nur einen Prozess) startet, können Sie die Vorab-Schritte im selben Container direkt vor dem Starten des Prozesses mit der Anwendung ausführen.
 
-## Offizielles Docker-Image mit Gunicorn – Uvicorn
+### Docker-Basisimage { #base-docker-image }
 
-Es gibt ein offizielles Docker-Image, in dem Gunicorn mit Uvicorn-Workern ausgeführt wird, wie in einem vorherigen Kapitel beschrieben: [Serverworker – Gunicorn mit Uvicorn](server-workers.md){.internal-link target=_blank}.
+Es gab ein offizielles FastAPI-Docker-Image: <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker" class="external-link" target="_blank">tiangolo/uvicorn-gunicorn-fastapi</a>. Dieses ist jedoch jetzt veraltet. ⛔️
 
-Dieses Image wäre vor allem in den oben beschriebenen Situationen nützlich: [Container mit mehreren Prozessen und Sonderfälle](#container-mit-mehreren-prozessen-und-sonderfalle).
+Sie sollten wahrscheinlich **nicht** dieses Basis-Docker-Image (oder ein anderes ähnliches) verwenden.
 
-* <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker" class="external-link" target="_blank">tiangolo/uvicorn-gunicorn-fastapi</a>.
+Wenn Sie **Kubernetes** (oder andere) verwenden und bereits **Replikation** auf Cluster-Ebene mit mehreren **Containern** eingerichtet haben. In diesen Fällen ist es besser, **ein Image von Grund auf neu zu erstellen**, wie oben beschrieben: [Ein Docker-Image für FastAPI erstellen](#build-a-docker-image-for-fastapi).
 
-/// warning | Achtung
-
-Es besteht eine hohe Wahrscheinlichkeit, dass Sie dieses oder ein ähnliches Basisimage **nicht** benötigen und es besser wäre, wenn Sie das Image von Grund auf neu erstellen würden, wie [oben beschrieben in: Ein Docker-Image für FastAPI erstellen](#ein-docker-image-fur-fastapi-erstellen).
-
-///
+Und wenn Sie mehrere Worker benötigen, können Sie einfach die `--workers` Befehlszeilenoption verwenden.
 
-Dieses Image verfügt über einen **Auto-Tuning**-Mechanismus, um die **Anzahl der Arbeitsprozesse** basierend auf den verfügbaren CPU-Kernen festzulegen.
+/// note | Technische Details
 
-Es verfügt über **vernünftige Standardeinstellungen**, aber Sie können trotzdem alle Konfigurationen mit **Umgebungsvariablen** oder Konfigurationsdateien ändern und aktualisieren.
-
-Es unterstützt auch die Ausführung von <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker#pre_start_path" class="external-link" target="_blank">**Vorab-Schritten vor dem Start** </a> mit einem Skript.
-
-/// tip | Tipp
+Das Docker-Image wurde erstellt, als Uvicorn das Verwalten und Neustarten von ausgefallenen Workern noch nicht unterstützte, weshalb es notwendig war, Gunicorn mit Uvicorn zu verwenden, was zu einer erheblichen Komplexität führte, nur damit Gunicorn die Uvicorn-Workerprozesse verwaltet und neu startet.
 
-Um alle Konfigurationen und Optionen anzuzeigen, gehen Sie zur Docker-Image-Seite: <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker" class="external-link" target="_blank">tiangolo/uvicorn-gunicorn-fastapi</a>.
+Aber jetzt, da Uvicorn (und der `fastapi`-Befehl) die Verwendung von `--workers` unterstützen, gibt es keinen Grund, ein Basis-Docker-Image an Stelle eines eigenen (das praktisch denselben Code enthält 😅) zu verwenden.
 
 ///
 
-### Anzahl der Prozesse auf dem offiziellen Docker-Image
-
-Die **Anzahl der Prozesse** auf diesem Image wird **automatisch** anhand der verfügbaren CPU-**Kerne** berechnet.
-
-Das bedeutet, dass versucht wird, so viel **Leistung** wie möglich aus der CPU herauszuquetschen.
-
-Sie können das auch in der Konfiguration anpassen, indem Sie **Umgebungsvariablen**, usw. verwenden.
-
-Das bedeutet aber auch, da die Anzahl der Prozesse von der CPU abhängt, welche der Container ausführt, dass die **Menge des verbrauchten Speichers** ebenfalls davon abhängt.
-
-Wenn Ihre Anwendung also viel Speicher verbraucht (z. B. bei Modellen für maschinelles Lernen) und Ihr Server über viele CPU-Kerne, **aber wenig Speicher** verfügt, könnte Ihr Container am Ende versuchen, mehr Speicher als vorhanden zu verwenden, was zu erheblichen Leistungseinbußen (oder sogar zum Absturz) führen kann. 🚨
-
-### Ein `Dockerfile` erstellen
-
-So würden Sie ein `Dockerfile` basierend auf diesem Image erstellen:
-
-```Dockerfile
-FROM tiangolo/uvicorn-gunicorn-fastapi:python3.9
-
-COPY ./requirements.txt /app/requirements.txt
-
-RUN pip install --no-cache-dir --upgrade -r /app/requirements.txt
-
-COPY ./app /app
-```
-
-### Größere Anwendungen
-
-Wenn Sie dem Abschnitt zum Erstellen von [größeren Anwendungen mit mehreren Dateien](../tutorial/bigger-applications.md){.internal-link target=_blank} gefolgt sind, könnte Ihr `Dockerfile` stattdessen wie folgt aussehen:
-
-```Dockerfile hl_lines="7"
-FROM tiangolo/uvicorn-gunicorn-fastapi:python3.9
-
-COPY ./requirements.txt /app/requirements.txt
-
-RUN pip install --no-cache-dir --upgrade -r /app/requirements.txt
-
-COPY ./app /app/app
-```
-
-### Wann verwenden
-
-Sie sollten dieses offizielle Basisimage (oder ein ähnliches) wahrscheinlich **nicht** benutzen, wenn Sie **Kubernetes** (oder andere) verwenden und Sie bereits **Replikation** auf Cluster ebene mit mehreren **Containern** eingerichtet haben. In diesen Fällen ist es besser, **ein Image von Grund auf zu erstellen**, wie oben beschrieben: [Ein Docker-Image für FastAPI erstellen](#ein-docker-image-fur-fastapi-erstellen).
-
-Dieses Image wäre vor allem in den oben in [Container mit mehreren Prozessen und Sonderfälle](#container-mit-mehreren-prozessen-und-sonderfalle) beschriebenen Sonderfällen nützlich. Wenn Ihre Anwendung beispielsweise **einfach genug** ist, dass das Festlegen einer Standardanzahl von Prozessen basierend auf der CPU gut funktioniert, möchten Sie sich nicht mit der manuellen Konfiguration der Replikation auf Cluster ebene herumschlagen und führen nicht mehr als einen Container mit Ihrer Anwendung aus. Oder wenn Sie das Deployment mit **Docker Compose** durchführen und auf einem einzelnen Server laufen, usw.
-
-## Deployment des Containerimages
+## Deployment des Containerimages { #deploy-the-container-image }
 
 Nachdem Sie ein Containerimage (Docker) haben, gibt es mehrere Möglichkeiten, es bereitzustellen.
 
@@ -620,100 +600,11 @@ Zum Beispiel:
 * Mit einem anderen Tool wie Nomad
 * Mit einem Cloud-Dienst, der Ihr Containerimage nimmt und es bereitstellt
 
-## Docker-Image mit Poetry
-
-Wenn Sie <a href="https://python-poetry.org/" class="external-link" target="_blank">Poetry</a> verwenden, um die Abhängigkeiten Ihres Projekts zu verwalten, können Sie Dockers mehrphasige Builds verwenden:
-
-```{ .dockerfile .annotate }
-# (1)
-FROM python:3.9 as requirements-stage
-
-# (2)
-WORKDIR /tmp
-
-# (3)
-RUN pip install poetry
-
-# (4)
-COPY ./pyproject.toml ./poetry.lock* /tmp/
-
-# (5)
-RUN poetry export -f requirements.txt --output requirements.txt --without-hashes
-
-# (6)
-FROM python:3.9
-
-# (7)
-WORKDIR /code
-
-# (8)
-COPY --from=requirements-stage /tmp/requirements.txt /code/requirements.txt
-
-# (9)
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-
-# (10)
-COPY ./app /code/app
-
-# (11)
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]
-```
-
-1. Dies ist die erste Phase, genannt `requirements-stage` – „Anforderungsphase“.
+## Docker-Image mit `uv` { #docker-image-with-uv }
 
-2. Setze `/tmp` als aktuelles Arbeitsverzeichnis.
+Wenn Sie <a href="https://github.com/astral-sh/uv" class="external-link" target="_blank">uv</a> verwenden, um Ihr Projekt zu installieren und zu verwalten, können Sie deren <a href="https://docs.astral.sh/uv/guides/integration/docker/" class="external-link" target="_blank">uv-Docker-Leitfaden</a> befolgen.
 
-    Hier werden wir die Datei `requirements.txt` generieren.
-
-3. Installiere Poetry in dieser Docker-Phase.
-
-4. Kopiere die Dateien `pyproject.toml` und `poetry.lock` in das Verzeichnis `/tmp`.
-
-    Da es `./poetry.lock*` verwendet (endet mit einem `*`), stürzt es nicht ab, wenn diese Datei noch nicht verfügbar ist.
-
-5. Generiere die Datei `requirements.txt`.
-
-6. Dies ist die letzte Phase. Alles hier bleibt im endgültigen Containerimage erhalten.
-
-7. Setze das aktuelle Arbeitsverzeichnis auf `/code`.
-
-8. Kopiere die Datei `requirements.txt` in das Verzeichnis `/code`.
-
-    Diese Datei existiert nur in der vorherigen Docker-Phase, deshalb verwenden wir `--from-requirements-stage`, um sie zu kopieren.
-
-9. Installiere die Paketabhängigkeiten von der generierten Datei `requirements.txt`.
-
-10. Kopiere das Verzeichnis `app` in das Verzeichnis `/code`.
-
-11. Führe den Befehl `uvicorn` aus und weise ihn an, das aus `app.main` importierte `app`-Objekt zu verwenden.
-
-/// tip | Tipp
-
-Klicken Sie auf die Zahlenblasen, um zu sehen, was jede Zeile bewirkt.
-
-///
-
-Eine **Docker-Phase** ist ein Teil eines `Dockerfile`s, welcher als **temporäres Containerimage** fungiert und nur zum Generieren einiger Dateien für die spätere Verwendung verwendet wird.
-
-Die erste Phase wird nur zur **Installation von Poetry** und zur **Generierung der `requirements.txt`** mit deren Projektabhängigkeiten aus der Datei `pyproject.toml` von Poetry verwendet.
-
-Diese `requirements.txt`-Datei wird später in der **nächsten Phase** mit `pip` verwendet.
-
-Im endgültigen Containerimage bleibt **nur die letzte Stufe** erhalten. Die vorherigen Stufen werden verworfen.
-
-Bei der Verwendung von Poetry wäre es sinnvoll, **mehrstufige Docker-Builds** zu verwenden, da Poetry und seine Abhängigkeiten nicht wirklich im endgültigen Containerimage installiert sein müssen, sondern Sie brauchen **nur** die Datei `requirements.txt`, um Ihre Projektabhängigkeiten zu installieren.
-
-Dann würden Sie im nächsten (und letzten) Schritt das Image mehr oder weniger auf die gleiche Weise wie zuvor beschrieben erstellen.
-
-### Hinter einem TLS-Terminierungsproxy – Poetry
-
-Auch hier gilt: Wenn Sie Ihren Container hinter einem TLS-Terminierungsproxy (Load Balancer) wie Nginx oder Traefik ausführen, fügen Sie dem Befehl die Option `--proxy-headers` hinzu:
-
-```Dockerfile
-CMD ["uvicorn", "app.main:app", "--proxy-headers", "--host", "0.0.0.0", "--port", "80"]
-```
-
-## Zusammenfassung
+## Zusammenfassung { #recap }
 
 Mithilfe von Containersystemen (z. B. mit **Docker** und **Kubernetes**) ist es ziemlich einfach, alle **Deployment-Konzepte** zu handhaben:
 
@@ -727,5 +618,3 @@ Mithilfe von Containersystemen (z. B. mit **Docker** und **Kubernetes**) ist es
 In den meisten Fällen möchten Sie wahrscheinlich kein Basisimage verwenden und stattdessen **ein Containerimage von Grund auf erstellen**, eines basierend auf dem offiziellen Python-Docker-Image.
 
 Indem Sie auf die **Reihenfolge** der Anweisungen im `Dockerfile` und den **Docker-Cache** achten, können Sie **die Build-Zeiten minimieren**, um Ihre Produktivität zu erhöhen (und Langeweile zu vermeiden). 😎
-
-In bestimmten Sonderfällen möchten Sie möglicherweise das offizielle Docker-Image für FastAPI verwenden. 🤓

docs/de/docs/deployment/https.md

@@ -1,4 +1,4 @@
-# Über HTTPS
+# Über HTTPS { #about-https }
 
 Es ist leicht anzunehmen, dass HTTPS etwas ist, was einfach nur „aktiviert“ wird oder nicht.
 
@@ -22,19 +22,19 @@ Aus **Sicht des Entwicklers** sollten Sie beim Nachdenken über HTTPS Folgendes
 * Die Verschlüsselung der Verbindung erfolgt auf **TCP-Ebene**.
     * Das ist eine Schicht **unter HTTP**.
     * Die Handhabung von **Zertifikaten und Verschlüsselung** erfolgt also **vor HTTP**.
-* **TCP weiß nichts über „<abbr title="Domäne, Bereich, Wirkungsraum">Domains</abbr>“**. Nur über IP-Adressen.
+* **TCP weiß nichts über „Domains“**. Nur über IP-Adressen.
     * Die Informationen über die angeforderte **spezifische Domain** befinden sich in den **HTTP-Daten**.
 * Die **HTTPS-Zertifikate** „zertifizieren“ eine **bestimmte Domain**, aber das Protokoll und die Verschlüsselung erfolgen auf TCP-Ebene, **ohne zu wissen**, um welche Domain es sich handelt.
 * **Standardmäßig** bedeutet das, dass Sie nur **ein HTTPS-Zertifikat pro IP-Adresse** haben können.
     * Ganz gleich, wie groß Ihr Server ist oder wie klein die einzelnen Anwendungen darauf sind.
     * Hierfür gibt es jedoch eine **Lösung**.
-* Es gibt eine **Erweiterung** zum **TLS**-Protokoll (dasjenige, das die Verschlüsselung auf TCP-Ebene, vor HTTP, verwaltet) namens **<a href="https://en.wikipedia.org/wiki/Server_Name_Indication" class="external-link" target="_blank"><abbr title="Server Name Indication – Angabe des Servernamens">SNI</abbr></a>**.
-    * Mit dieser SNI-Erweiterung kann ein einzelner Server (mit einer **einzelnen IP-Adresse**) über **mehrere HTTPS-Zertifikate** verfügen und **mehrere HTTPS-Domains/Anwendungen** bedienen.
+* Es gibt eine **Erweiterung** zum **TLS**-Protokoll (dasjenige, das die Verschlüsselung auf TCP-Ebene, vor HTTP, verwaltet) namens **<a href="https://en.wikipedia.org/wiki/Server_Name_Indication" class="external-link" target="_blank"><abbr title="Server Name Indication – Servernamensanzeige">SNI</abbr></a>**.
+    * Mit dieser SNI-Erweiterung kann ein einzelner Server (mit einer **einzelnen IP-Adresse**) über **mehrere HTTPS-Zertifikate** verfügen und **mehrere HTTPS-Domains/Anwendungen bereitstellen**.
     * Damit das funktioniert, muss eine **einzelne** Komponente (Programm), die auf dem Server ausgeführt wird und welche die **öffentliche IP-Adresse** überwacht, **alle HTTPS-Zertifikate** des Servers haben.
 * **Nachdem** eine sichere Verbindung hergestellt wurde, ist das Kommunikationsprotokoll **immer noch HTTP**.
     * Die Inhalte sind **verschlüsselt**, auch wenn sie mit dem **HTTP-Protokoll** gesendet werden.
 
-Es ist eine gängige Praxis, **ein Programm/HTTP-Server** auf dem Server (der Maschine, dem Host usw.) laufen zu lassen, welches **alle HTTPS-Aspekte verwaltet**: Empfangen der **verschlüsselten HTTPS-Requests**, Senden der **entschlüsselten HTTP-Requests** an die eigentliche HTTP-Anwendung die auf demselben Server läuft (in diesem Fall die **FastAPI**-Anwendung), entgegennehmen der **HTTP-Response** von der Anwendung, **verschlüsseln derselben** mithilfe des entsprechenden **HTTPS-Zertifikats** und Zurücksenden zum Client über **HTTPS**. Dieser Server wird oft als **<a href="https://en.wikipedia.org/wiki/TLS_termination_proxy" class="external-link" target="_blank">TLS-Terminierungsproxy</a>** bezeichnet.
+Es ist eine gängige Praxis, **ein Programm/HTTP-Server** auf dem Server (der Maschine, dem Host usw.) laufen zu lassen, welches **alle HTTPS-Aspekte verwaltet**: Empfangen der **verschlüsselten HTTPS-<abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Requests</abbr>**, Senden der **entschlüsselten HTTP-Requests** an die eigentliche HTTP-Anwendung die auf demselben Server läuft (in diesem Fall die **FastAPI**-Anwendung), entgegennehmen der **HTTP-Response** von der Anwendung, **verschlüsseln derselben** mithilfe des entsprechenden **HTTPS-Zertifikats** und Zurücksenden zum Client über **HTTPS**. Dieser Server wird oft als **<a href="https://en.wikipedia.org/wiki/TLS_termination_proxy" class="external-link" target="_blank">TLS-Terminierungsproxy</a>** bezeichnet.
 
 Einige der Optionen, die Sie als TLS-Terminierungsproxy verwenden können, sind:
 
@@ -43,7 +43,7 @@ Einige der Optionen, die Sie als TLS-Terminierungsproxy verwenden können, sind:
 * Nginx
 * HAProxy
 
-## Let's Encrypt
+## Let's Encrypt { #lets-encrypt }
 
 Vor Let's Encrypt wurden diese **HTTPS-Zertifikate** von vertrauenswürdigen Dritten verkauft.
 
@@ -57,11 +57,11 @@ Die Domains werden sicher verifiziert und die Zertifikate werden automatisch gen
 
 Die Idee besteht darin, den Erwerb und die Erneuerung der Zertifikate zu automatisieren, sodass Sie **sicheres HTTPS, kostenlos und für immer** haben können.
 
-## HTTPS für Entwickler
+## HTTPS für Entwickler { #https-for-developers }
 
 Hier ist ein Beispiel, wie eine HTTPS-API aussehen könnte, Schritt für Schritt, wobei vor allem die für Entwickler wichtigen Ideen berücksichtigt werden.
 
-### Domainname
+### Domainname { #domain-name }
 
 Alles beginnt wahrscheinlich damit, dass Sie einen **Domainnamen erwerben**. Anschließend konfigurieren Sie ihn in einem DNS-Server (wahrscheinlich beim selben Cloud-Anbieter).
 
@@ -77,17 +77,17 @@ Dieser Domainnamen-Aspekt liegt weit vor HTTPS, aber da alles von der Domain und
 
 ///
 
-### DNS
+### DNS { #dns }
 
 Konzentrieren wir uns nun auf alle tatsächlichen HTTPS-Aspekte.
 
-Zuerst würde der Browser mithilfe der **DNS-Server** herausfinden, welches die **IP für die Domain** ist, in diesem Fall für `someapp.example.com`.
+Zuerst würde der Browser mithilfe der **DNS-Server** herausfinden, welches die **IP für die Domain** ist, in diesem Fall `someapp.example.com`.
 
 Die DNS-Server geben dem Browser eine bestimmte **IP-Adresse** zurück. Das wäre die von Ihrem Server verwendete öffentliche IP-Adresse, die Sie in den DNS-Servern konfiguriert haben.
 
 <img src="/img/deployment/https/https01.drawio.svg">
 
-### TLS-Handshake-Start
+### TLS-Handshake-Start { #tls-handshake-start }
 
 Der Browser kommuniziert dann mit dieser IP-Adresse über **Port 443** (den HTTPS-Port).
 
@@ -97,7 +97,7 @@ Der erste Teil der Kommunikation besteht lediglich darin, die Verbindung zwische
 
 Diese Interaktion zwischen dem Client und dem Server zum Aufbau der TLS-Verbindung wird als **<abbr title="TLS-Handschlag">TLS-Handshake</abbr>** bezeichnet.
 
-### TLS mit SNI-Erweiterung
+### TLS mit SNI-Erweiterung { #tls-with-sni-extension }
 
 **Nur ein Prozess** im Server kann an einem bestimmten **Port** einer bestimmten **IP-Adresse** lauschen. Möglicherweise gibt es andere Prozesse, die an anderen Ports dieselbe IP-Adresse abhören, jedoch nur einen für jede Kombination aus IP-Adresse und Port.
 
@@ -127,7 +127,7 @@ Beachten Sie, dass die Verschlüsselung der Kommunikation auf der **TCP-Ebene**
 
 ///
 
-### HTTPS-Request
+### HTTPS-Request { #https-request }
 
 Da Client und Server (sprich, der Browser und der TLS-Terminierungsproxy) nun über eine **verschlüsselte TCP-Verbindung** verfügen, können sie die **HTTP-Kommunikation** starten.
 
@@ -135,19 +135,19 @@ Der Client sendet also einen **HTTPS-Request**. Das ist einfach ein HTTP-Request
 
 <img src="/img/deployment/https/https04.drawio.svg">
 
-### Den Request entschlüsseln
+### Den Request entschlüsseln { #decrypt-the-request }
 
 Der TLS-Terminierungsproxy würde die vereinbarte Verschlüsselung zum **Entschlüsseln des Requests** verwenden und den **einfachen (entschlüsselten) HTTP-Request** an den Prozess weiterleiten, der die Anwendung ausführt (z. B. einen Prozess, bei dem Uvicorn die FastAPI-Anwendung ausführt).
 
 <img src="/img/deployment/https/https05.drawio.svg">
 
-### HTTP-Response
+### HTTP-Response { #http-response }
 
 Die Anwendung würde den Request verarbeiten und eine **einfache (unverschlüsselte) HTTP-Response** an den TLS-Terminierungsproxy senden.
 
 <img src="/img/deployment/https/https06.drawio.svg">
 
-### HTTPS-Response
+### HTTPS-Response { #https-response }
 
 Der TLS-Terminierungsproxy würde dann die Response mithilfe der zuvor vereinbarten Kryptografie (als das Zertifikat für `someapp.example.com` verhandelt wurde) **verschlüsseln** und sie an den Browser zurücksenden.
 
@@ -157,7 +157,7 @@ Als Nächstes überprüft der Browser, ob die Response gültig und mit dem richt
 
 Der Client (Browser) weiß, dass die Response vom richtigen Server kommt, da dieser die Kryptografie verwendet, die zuvor mit dem **HTTPS-Zertifikat** vereinbart wurde.
 
-### Mehrere Anwendungen
+### Mehrere Anwendungen { #multiple-applications }
 
 Auf demselben Server (oder denselben Servern) könnten sich **mehrere Anwendungen** befinden, beispielsweise andere API-Programme oder eine Datenbank.
 
@@ -167,7 +167,7 @@ Nur ein Prozess kann diese spezifische IP und den Port verarbeiten (in unserem B
 
 Auf diese Weise könnte der TLS-Terminierungsproxy HTTPS und Zertifikate für **mehrere Domains**, für mehrere Anwendungen, verarbeiten und die Requests dann jeweils an die richtige Anwendung weiterleiten.
 
-### Verlängerung des Zertifikats
+### Verlängerung des Zertifikats { #certificate-renewal }
 
 Irgendwann in der Zukunft würde jedes Zertifikat **ablaufen** (etwa 3 Monate nach dem Erwerb).
 
@@ -190,7 +190,7 @@ Um dies zu erreichen und den unterschiedlichen Anwendungsanforderungen gerecht z
 
 Dieser ganze Erneuerungsprozess, während die Anwendung weiterhin bereitgestellt wird, ist einer der Hauptgründe, warum Sie ein **separates System zur Verarbeitung von HTTPS** mit einem TLS-Terminierungsproxy haben möchten, anstatt einfach die TLS-Zertifikate direkt mit dem Anwendungsserver zu verwenden (z. B. Uvicorn).
 
-## Zusammenfassung
+## Zusammenfassung { #recap }
 
 **HTTPS** zu haben ist sehr wichtig und in den meisten Fällen eine **kritische Anforderung**. Die meiste Arbeit, die Sie als Entwickler in Bezug auf HTTPS aufwenden müssen, besteht lediglich darin, **diese Konzepte zu verstehen** und wie sie funktionieren.
 

docs/de/docs/deployment/index.md

@@ -1,18 +1,18 @@
-# Deployment
+# Deployment { #deployment }
 
 Das Deployment einer **FastAPI**-Anwendung ist relativ einfach.
 
-## Was bedeutet Deployment?
+## Was bedeutet Deployment? { #what-does-deployment-mean }
 
-**Deployment** (Deutsch etwa: **Bereitstellen der Anwendung**) bedeutet, die notwendigen Schritte durchzuführen, um die Anwendung **für die Endbenutzer verfügbar** zu machen.
+<abbr title="Bereitstellen der Anwendung">**Deployment**</abbr> bedeutet, die notwendigen Schritte durchzuführen, um die Anwendung **für die Endbenutzer verfügbar** zu machen.
 
 Bei einer **Web-API** bedeutet das normalerweise, diese auf einem **entfernten Rechner** zu platzieren, mit einem **Serverprogramm**, welches gute Leistung, Stabilität, usw. bietet, damit Ihre **Benutzer** auf die Anwendung effizient und ohne Unterbrechungen oder Probleme **zugreifen** können.
 
 Das steht im Gegensatz zu den **Entwicklungsphasen**, in denen Sie ständig den Code ändern, kaputt machen, reparieren, den Entwicklungsserver stoppen und neu starten, usw.
 
-## Deployment-Strategien
+## Deployment-Strategien { #deployment-strategies }
 
-Abhängig von Ihrem spezifischen Anwendungsfall und den von Ihnen verwendeten Tools gibt es mehrere Möglichkeiten, das zu tun.
+Es gibt mehrere Möglichkeiten, dies zu tun, abhängig von Ihrem spezifischen Anwendungsfall und den von Ihnen verwendeten Tools.
 
 Sie könnten mithilfe einer Kombination von Tools selbst **einen Server bereitstellen**, Sie könnten einen **Cloud-Dienst** nutzen, der einen Teil der Arbeit für Sie erledigt, oder andere mögliche Optionen.
 

docs/de/docs/deployment/manually.md

@@ -1,151 +1,149 @@
-# Einen Server manuell ausführen – Uvicorn
+# Einen Server manuell ausführen { #run-a-server-manually }
 
-Das Wichtigste, was Sie zum Ausführen einer **FastAPI**-Anwendung auf einer entfernten Servermaschine benötigen, ist ein ASGI-Serverprogramm, wie **Uvicorn**.
+## Den `fastapi run` Befehl verwenden { #use-the-fastapi-run-command }
 
-Es gibt 3 Hauptalternativen:
+Kurz gesagt, nutzen Sie `fastapi run`, um Ihre FastAPI-Anwendung bereitzustellen:
 
-* <a href="https://www.uvicorn.org/" class="external-link" target="_blank">Uvicorn</a>: ein hochperformanter ASGI-Server.
-* <a href="https://hypercorn.readthedocs.io/" class="external-link" target="_blank">Hypercorn</a>: ein ASGI-Server, der unter anderem mit HTTP/2 und Trio kompatibel ist.
-* <a href="https://github.com/django/daphne" class="external-link" target="_blank">Daphne</a>: Der für Django Channels entwickelte ASGI-Server.
-
-## Servermaschine und Serverprogramm
-
-Bei den Benennungen gibt es ein kleines Detail, das Sie beachten sollten. 💡
+<div class="termy">
 
-Das Wort „**Server**“ bezieht sich häufig sowohl auf den entfernten-/Cloud-Computer (die physische oder virtuelle Maschine) als auch auf das Programm, das auf dieser Maschine ausgeführt wird (z. B. Uvicorn).
+```console
+$ <font color="#4E9A06">fastapi</font> run <u style="text-decoration-style:solid">main.py</u>
 
-Denken Sie einfach daran, wenn Sie „Server“ im Allgemeinen lesen, dass es sich auf eines dieser beiden Dinge beziehen kann.
+  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting production server 🚀
 
-Wenn man sich auf die entfernte Maschine bezieht, wird sie üblicherweise als **Server**, aber auch als **Maschine**, **VM** (virtuelle Maschine) oder **Knoten** bezeichnet. Diese Begriffe beziehen sich auf irgendeine Art von entfernten Rechner, normalerweise unter Linux, auf dem Sie Programme ausführen.
+             Searching for package file structure from directories
+             with <font color="#3465A4">__init__.py</font> files
+             Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
 
-## Das Serverprogramm installieren
+   <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span>  🐍 main.py
 
-Sie können einen ASGI-kompatiblen Server installieren mit:
+     <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span>  Importing the FastAPI app object from the module with
+             the following code:
 
-//// tab | Uvicorn
+             <u style="text-decoration-style:solid">from </u><u style="text-decoration-style:solid"><b>main</b></u><u style="text-decoration-style:solid"> import </u><u style="text-decoration-style:solid"><b>app</b></u>
 
-* <a href="https://www.uvicorn.org/" class="external-link" target="_blank">Uvicorn</a>, ein blitzschneller ASGI-Server, basierend auf uvloop und httptools.
+      <span style="background-color:#007166"><font color="#D3D7CF"> app </font></span>  Using import string: <font color="#3465A4">main:app</font>
 
-<div class="termy">
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Server started at <font color="#729FCF"><u style="text-decoration-style:solid">http://0.0.0.0:8000</u></font>
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Documentation at <font color="#729FCF"><u style="text-decoration-style:solid">http://0.0.0.0:8000/docs</u></font>
 
-```console
-$ pip install "uvicorn[standard]"
+             Logs:
 
----> 100%
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started server process <b>[</b><font color="#34E2E2"><b>2306215</b></font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Waiting for application startup.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Application startup complete.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Uvicorn running on <font color="#729FCF"><u style="text-decoration-style:solid">http://0.0.0.0:8000</u></font> <b>(</b>Press CTRL+C
+             to quit<b>)</b>
 ```
 
 </div>
 
-/// tip | Tipp
+Das würde in den meisten Fällen funktionieren. 😎
 
-Durch das Hinzufügen von `standard` installiert und verwendet Uvicorn einige empfohlene zusätzliche Abhängigkeiten.
+Sie könnten diesen Befehl beispielsweise verwenden, um Ihre **FastAPI**-App in einem Container, auf einem Server usw. zu starten.
 
-Inklusive `uvloop`, einen hochperformanten Drop-in-Ersatz für `asyncio`, welcher für einen großen Leistungsschub bei der Nebenläufigkeit sorgt.
+## ASGI-Server { #asgi-servers }
 
-///
+Lassen Sie uns ein wenig tiefer in die Details eintauchen.
 
-////
+FastAPI verwendet einen Standard zum Erstellen von Python-Webframeworks und -Servern, der als <abbr title="Asynchrones Server-Gateway-Interface">ASGI</abbr> bekannt ist. FastAPI ist ein ASGI-Webframework.
 
-//// tab | Hypercorn
+Das Wichtigste, was Sie benötigen, um eine **FastAPI**-Anwendung (oder eine andere ASGI-Anwendung) auf einer entfernten Servermaschine auszuführen, ist ein ASGI-Serverprogramm wie **Uvicorn**, der standardmäßig im `fastapi`-Kommando enthalten ist.
 
-* <a href="https://github.com/pgjones/hypercorn" class="external-link" target="_blank">Hypercorn</a>, ein ASGI-Server, der auch mit HTTP/2 kompatibel ist.
+Es gibt mehrere Alternativen, einschließlich:
 
-<div class="termy">
-
-```console
-$ pip install hypercorn
-
----> 100%
-```
-
-</div>
-
-... oder jeden anderen ASGI-Server.
+* <a href="https://www.uvicorn.org/" class="external-link" target="_blank">Uvicorn</a>: ein hochperformanter ASGI-Server.
+* <a href="https://hypercorn.readthedocs.io/" class="external-link" target="_blank">Hypercorn</a>: ein ASGI-Server, der unter anderem kompatibel mit HTTP/2 und Trio ist.
+* <a href="https://github.com/django/daphne" class="external-link" target="_blank">Daphne</a>: der für Django Channels entwickelte ASGI-Server.
+* <a href="https://github.com/emmett-framework/granian" class="external-link" target="_blank">Granian</a>: Ein Rust HTTP-Server für Python-Anwendungen.
+* <a href="https://unit.nginx.org/howto/fastapi/" class="external-link" target="_blank">NGINX Unit</a>: NGINX Unit ist eine leichte und vielseitige Laufzeitumgebung für Webanwendungen.
 
-////
+## Servermaschine und Serverprogramm { #server-machine-and-server-program }
 
-## Das Serverprogramm ausführen
+Es gibt ein kleines Detail bei den Namen, das Sie beachten sollten. 💡
 
-Anschließend können Sie Ihre Anwendung auf die gleiche Weise ausführen, wie Sie es in den Tutorials getan haben, jedoch ohne die Option `--reload`, z. B.:
+Das Wort „**Server**“ wird häufig verwendet, um sowohl den entfernten/Cloud-Computer (die physische oder virtuelle Maschine) als auch das Programm zu bezeichnen, das auf dieser Maschine läuft (z. B. Uvicorn).
 
-//// tab | Uvicorn
+Denken Sie einfach daran, dass sich „Server“ im Allgemeinen auf eines dieser beiden Dinge beziehen kann.
 
-<div class="termy">
+Wenn man sich auf die entfernte Maschine bezieht, wird sie üblicherweise als **Server**, aber auch als **Maschine**, **VM** (virtuelle Maschine) oder **Knoten** bezeichnet. Diese Begriffe beziehen sich auf irgendeine Art von entfernten Rechner, normalerweise unter Linux, auf dem Sie Programme ausführen.
 
-```console
-$ uvicorn main:app --host 0.0.0.0 --port 80
+## Das Serverprogramm installieren { #install-the-server-program }
 
-<span style="color: green;">INFO</span>:     Uvicorn running on http://0.0.0.0:80 (Press CTRL+C to quit)
-```
+Wenn Sie FastAPI installieren, wird es mit einem Produktionsserver, Uvicorn, geliefert, und Sie können ihn mit dem `fastapi run` Befehl starten.
 
-</div>
+Aber Sie können auch ein ASGI-Serverprogramm manuell installieren.
 
-////
+Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellen, sie aktivieren und dann die Serveranwendung installieren.
 
-//// tab | Hypercorn
+Zum Beispiel, um Uvicorn zu installieren:
 
 <div class="termy">
 
 ```console
-$ hypercorn main:app --bind 0.0.0.0:80
+$ pip install "uvicorn[standard]"
 
-Running on 0.0.0.0:8080 over http (CTRL + C to quit)
+---> 100%
 ```
 
 </div>
 
-////
+Ein ähnlicher Prozess würde für jedes andere ASGI-Serverprogramm gelten.
 
-/// warning | Achtung
+/// tip | Tipp
 
-Denken Sie daran, die Option `--reload` zu entfernen, wenn Sie diese verwendet haben.
+Durch das Hinzufügen von `standard` installiert und verwendet Uvicorn einige empfohlene zusätzliche Abhängigkeiten.
 
-Die Option `--reload` verbraucht viel mehr Ressourcen, ist instabiler, usw.
+Dazu gehört `uvloop`, der hochperformante Drop-in-Ersatz für `asyncio`, der den großen Nebenläufigkeits-Performance-Schub bietet.
 
-Sie hilft sehr während der **Entwicklung**, aber Sie sollten sie **nicht** in der **Produktion** verwenden.
+Wenn Sie FastAPI mit etwas wie `pip install "fastapi[standard]"` installieren, erhalten Sie auch `uvicorn[standard]`.
 
 ///
 
-## Hypercorn mit Trio
-
-Starlette und **FastAPI** basieren auf <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a>, welches diese sowohl mit der Python-Standardbibliothek <a href="https://docs.python.org/3/library/asyncio-task.html" class="external-link" target="_blank">asyncio</a>, als auch mit <a href="https://trio.readthedocs.io/en/stable/" class="external-link" target="_blank">Trio</a> kompatibel macht.
-
-Dennoch ist Uvicorn derzeit nur mit asyncio kompatibel und verwendet normalerweise <a href="https://github.com/MagicStack/uvloop" class="external-link" target="_blank">`uvloop`</a>, den leistungsstarken Drop-in-Ersatz für `asyncio`.
-
-Wenn Sie jedoch **Trio** direkt verwenden möchten, können Sie **Hypercorn** verwenden, da dieses es unterstützt. ✨
+## Das Serverprogramm ausführen { #run-the-server-program }
 
-### Hypercorn mit Trio installieren
-
-Zuerst müssen Sie Hypercorn mit Trio-Unterstützung installieren:
+Wenn Sie einen ASGI-Server manuell installiert haben, müssen Sie normalerweise einen Importstring in einem speziellen Format übergeben, damit er Ihre FastAPI-Anwendung importiert:
 
 <div class="termy">
 
 ```console
-$ pip install "hypercorn[trio]"
----> 100%
+$ uvicorn main:app --host 0.0.0.0 --port 80
+
+<span style="color: green;">INFO</span>:     Uvicorn running on http://0.0.0.0:80 (Press CTRL+C to quit)
 ```
 
 </div>
 
-### Mit Trio ausführen
+/// note | Hinweis
 
-Dann können Sie die Befehlszeilenoption `--worker-class` mit dem Wert `trio` übergeben:
+Der Befehl `uvicorn main:app` bezieht sich auf:
 
-<div class="termy">
+* `main`: die Datei `main.py` (das Python-„Modul“).
+* `app`: das Objekt, das innerhalb von `main.py` mit der Zeile `app = FastAPI()` erstellt wurde.
 
-```console
-$ hypercorn main:app --worker-class trio
+Es ist äquivalent zu:
+
+```Python
+from main import app
 ```
 
-</div>
+///
 
-Und das startet Hypercorn mit Ihrer Anwendung und verwendet Trio als Backend.
+Jedes alternative ASGI-Serverprogramm hätte einen ähnlichen Befehl, Sie können in deren jeweiligen Dokumentationen mehr lesen.
 
-Jetzt können Sie Trio intern in Ihrer Anwendung verwenden. Oder noch besser: Sie können AnyIO verwenden, sodass Ihr Code sowohl mit Trio als auch asyncio kompatibel ist. 🎉
+/// warning | Achtung
+
+Uvicorn und andere Server unterstützen eine `--reload`-Option, die während der Entwicklung nützlich ist.
+
+Die `--reload`-Option verbraucht viel mehr Ressourcen, ist instabiler, usw.
+
+Sie hilft während der **Entwicklung**, Sie sollten sie jedoch **nicht** in der **Produktion** verwenden.
+
+///
 
-## Konzepte des Deployments
+## Deployment-Konzepte { #deployment-concepts }
 
-Obige Beispiele führen das Serverprogramm (z. B. Uvicorn) aus, starten **einen einzelnen Prozess** und überwachen alle IPs (`0.0.0.0`) an einem vordefinierten Port (z. B. `80`).
+Diese Beispiele führen das Serverprogramm (z. B. Uvicorn) aus, starten **einen einzelnen Prozess** und überwachen alle IPs (`0.0.0.0`) an einem vordefinierten Port (z. B. `80`).
 
 Das ist die Grundidee. Aber Sie möchten sich wahrscheinlich um einige zusätzliche Dinge kümmern, wie zum Beispiel:
 
@@ -153,7 +151,7 @@ Das ist die Grundidee. Aber Sie möchten sich wahrscheinlich um einige zusätzli
 * Beim Hochfahren ausführen
 * Neustarts
 * Replikation (die Anzahl der laufenden Prozesse)
-* Arbeitsspeicher
+* Speicher
 * Schritte vor dem Start
 
 In den nächsten Kapiteln erzähle ich Ihnen mehr über jedes dieser Konzepte, wie Sie über diese nachdenken, und gebe Ihnen einige konkrete Beispiele mit Strategien für den Umgang damit. 🚀

docs/de/docs/deployment/server-workers.md

@@ -1,4 +1,4 @@
-# Serverworker – Gunicorn mit Uvicorn
+# Serverworker – Uvicorn mit Workern { #server-workers-uvicorn-with-workers }
 
 Schauen wir uns die Deployment-Konzepte von früher noch einmal an:
 
@@ -9,123 +9,79 @@ Schauen wir uns die Deployment-Konzepte von früher noch einmal an:
 * Arbeitsspeicher
 * Schritte vor dem Start
 
-Bis zu diesem Punkt, in allen Tutorials in der Dokumentation, haben Sie wahrscheinlich ein **Serverprogramm** wie Uvicorn ausgeführt, in einem **einzelnen Prozess**.
+Bis zu diesem Punkt, in allen Tutorials in der Dokumentation, haben Sie wahrscheinlich ein **Serverprogramm** ausgeführt, zum Beispiel mit dem `fastapi`-Befehl, der Uvicorn startet, und einen **einzelnen Prozess** ausführt.
 
-Wenn Sie Anwendungen bereitstellen, möchten Sie wahrscheinlich eine gewisse **Replikation von Prozessen**, um **mehrere CPU-Kerne** zu nutzen und mehr Requests bearbeiten zu können.
+Wenn Sie Anwendungen bereitstellen, möchten Sie wahrscheinlich eine gewisse **Replikation von Prozessen**, um **mehrere Kerne** zu nutzen und mehr <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Requests</abbr> bearbeiten zu können.
 
 Wie Sie im vorherigen Kapitel über [Deployment-Konzepte](concepts.md){.internal-link target=_blank} gesehen haben, gibt es mehrere Strategien, die Sie anwenden können.
 
-Hier zeige ich Ihnen, wie Sie <a href="https://gunicorn.org/" class="external-link" target="_blank">**Gunicorn**</a> mit **Uvicorn Workerprozessen** verwenden.
+Hier zeige ich Ihnen, wie Sie **Uvicorn** mit **Workerprozessen** verwenden, indem Sie den `fastapi`-Befehl oder den `uvicorn`-Befehl direkt verwenden.
 
-/// info
+/// info | Info
 
 Wenn Sie Container verwenden, beispielsweise mit Docker oder Kubernetes, erzähle ich Ihnen mehr darüber im nächsten Kapitel: [FastAPI in Containern – Docker](docker.md){.internal-link target=_blank}.
 
-Insbesondere wenn die Anwendung auf **Kubernetes** läuft, werden Sie Gunicorn wahrscheinlich **nicht** verwenden wollen und stattdessen **einen einzelnen Uvicorn-Prozess pro Container** ausführen wollen, aber ich werde Ihnen später in diesem Kapitel mehr darüber erzählen.
+Insbesondere wenn die Anwendung auf **Kubernetes** läuft, werden Sie wahrscheinlich **keine** Worker verwenden wollen, und stattdessen **einen einzelnen Uvicorn-Prozess pro Container** ausführen wollen, aber ich werde Ihnen später in diesem Kapitel mehr darüber erzählen.
 
 ///
 
-## Gunicorn mit Uvicorn-Workern
+## Mehrere Worker { #multiple-workers }
 
-**Gunicorn** ist hauptsächlich ein Anwendungsserver, der den **WSGI-Standard** verwendet. Das bedeutet, dass Gunicorn Anwendungen wie Flask und Django ausliefern kann. Gunicorn selbst ist nicht mit **FastAPI** kompatibel, da FastAPI den neuesten **<a href="https://asgi.readthedocs.io/en/latest/" class="external-link" target="_blank">ASGI-Standard</a>** verwendet.
+Sie können mehrere Worker mit der `--workers`-Befehlszeilenoption starten:
 
-Aber Gunicorn kann als **Prozessmanager** arbeiten und Benutzer können ihm mitteilen, welche bestimmte **Workerprozessklasse** verwendet werden soll. Dann würde Gunicorn einen oder mehrere **Workerprozesse** starten, diese Klasse verwendend.
+//// tab | `fastapi`
 
-Und **Uvicorn** hat eine **Gunicorn-kompatible Workerklasse**.
-
-Mit dieser Kombination würde Gunicorn als **Prozessmanager** fungieren und den **Port** und die **IP** abhören. Und er würde die Kommunikation an die Workerprozesse **weiterleiten**, welche die **Uvicorn-Klasse** ausführen.
-
-Und dann wäre die Gunicorn-kompatible **Uvicorn-Worker**-Klasse dafür verantwortlich, die von Gunicorn gesendeten Daten in den ASGI-Standard zu konvertieren, damit FastAPI diese verwenden kann.
-
-## Gunicorn und Uvicorn installieren
+Wenn Sie den `fastapi`-Befehl verwenden:
 
 <div class="termy">
 
 ```console
-$ pip install "uvicorn[standard]" gunicorn
-
----> 100%
-```
-
-</div>
+$ <font color="#4E9A06">fastapi</font> run --workers 4 <u style="text-decoration-style:solid">main.py</u>
 
-Dadurch wird sowohl Uvicorn mit zusätzlichen `standard`-Packages (um eine hohe Leistung zu erzielen) als auch Gunicorn installiert.
+  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting production server 🚀
 
-## Gunicorn mit Uvicorn-Workern ausführen
+             Searching for package file structure from directories with
+             <font color="#3465A4">__init__.py</font> files
+             Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
 
-Dann können Sie Gunicorn ausführen mit:
+   <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span>  🐍 main.py
 
-<div class="termy">
-
-```console
-$ gunicorn main:app --workers 4 --worker-class uvicorn.workers.UvicornWorker --bind 0.0.0.0:80
-
-[19499] [INFO] Starting gunicorn 20.1.0
-[19499] [INFO] Listening at: http://0.0.0.0:80 (19499)
-[19499] [INFO] Using worker: uvicorn.workers.UvicornWorker
-[19511] [INFO] Booting worker with pid: 19511
-[19513] [INFO] Booting worker with pid: 19513
-[19514] [INFO] Booting worker with pid: 19514
-[19515] [INFO] Booting worker with pid: 19515
-[19511] [INFO] Started server process [19511]
-[19511] [INFO] Waiting for application startup.
-[19511] [INFO] Application startup complete.
-[19513] [INFO] Started server process [19513]
-[19513] [INFO] Waiting for application startup.
-[19513] [INFO] Application startup complete.
-[19514] [INFO] Started server process [19514]
-[19514] [INFO] Waiting for application startup.
-[19514] [INFO] Application startup complete.
-[19515] [INFO] Started server process [19515]
-[19515] [INFO] Waiting for application startup.
-[19515] [INFO] Application startup complete.
-```
-
-</div>
+     <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span>  Importing the FastAPI app object from the module with the
+             following code:
 
-Sehen wir uns an, was jede dieser Optionen bedeutet:
+             <u style="text-decoration-style:solid">from </u><u style="text-decoration-style:solid"><b>main</b></u><u style="text-decoration-style:solid"> import </u><u style="text-decoration-style:solid"><b>app</b></u>
 
-* `main:app`: Das ist die gleiche Syntax, die auch von Uvicorn verwendet wird. `main` bedeutet das Python-Modul mit dem Namen `main`, also eine Datei `main.py`. Und `app` ist der Name der Variable, welche die **FastAPI**-Anwendung ist.
-    * Stellen Sie sich einfach vor, dass `main:app` einer Python-`import`-Anweisung wie der folgenden entspricht:
+      <span style="background-color:#007166"><font color="#D3D7CF"> app </font></span>  Using import string: <font color="#3465A4">main:app</font>
 
-        ```Python
-        from main import app
-        ```
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Server started at <font color="#729FCF"><u style="text-decoration-style:solid">http://0.0.0.0:8000</u></font>
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Documentation at <font color="#729FCF"><u style="text-decoration-style:solid">http://0.0.0.0:8000/docs</u></font>
 
-    * Der Doppelpunkt in `main:app` entspricht also dem Python-`import`-Teil in `from main import app`.
+             Logs:
 
-* `--workers`: Die Anzahl der zu verwendenden Workerprozesse, jeder führt einen Uvicorn-Worker aus, in diesem Fall 4 Worker.
-
-* `--worker-class`: Die Gunicorn-kompatible Workerklasse zur Verwendung in den Workerprozessen.
-    * Hier übergeben wir die Klasse, die Gunicorn etwa so importiert und verwendet:
-
-        ```Python
-        import uvicorn.workers.UvicornWorker
-        ```
-
-* `--bind`: Das teilt Gunicorn die IP und den Port mit, welche abgehört werden sollen, wobei ein Doppelpunkt (`:`) verwendet wird, um die IP und den Port zu trennen.
-    * Wenn Sie Uvicorn direkt ausführen würden, würden Sie anstelle von `--bind 0.0.0.0:80` (die Gunicorn-Option) stattdessen `--host 0.0.0.0` und `--port 80` verwenden.
-
-In der Ausgabe können Sie sehen, dass die **PID** (Prozess-ID) jedes Prozesses angezeigt wird (es ist nur eine Zahl).
-
-Sie können sehen, dass:
-
-* Der Gunicorn **Prozessmanager** beginnt, mit der PID `19499` (in Ihrem Fall ist es eine andere Nummer).
-* Dann beginnt er zu lauschen: `Listening at: http://0.0.0.0:80`.
-* Dann erkennt er, dass er die Workerklasse `uvicorn.workers.UvicornWorker` verwenden muss.
-* Und dann werden **4 Worker** gestartet, jeder mit seiner eigenen PID: `19511`, `19513`, `19514` und `19515`.
-
-Gunicorn würde sich bei Bedarf auch um die Verwaltung **beendeter Prozesse** und den **Neustart** von Prozessen kümmern, um die Anzahl der Worker aufrechtzuerhalten. Das hilft also teilweise beim **Neustarts**-Konzept aus der obigen Liste.
-
-Dennoch möchten Sie wahrscheinlich auch etwas außerhalb haben, um sicherzustellen, dass Gunicorn bei Bedarf **neu gestartet wird**, und er auch **beim Hochfahren ausgeführt wird**, usw.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Uvicorn running on <font color="#729FCF"><u style="text-decoration-style:solid">http://0.0.0.0:8000</u></font> <b>(</b>Press CTRL+C to
+             quit<b>)</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started parent process <b>[</b><font color="#34E2E2"><b>27365</b></font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started server process <b>[</b><font color="#34E2E2"><b>27368</b></font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started server process <b>[</b><font color="#34E2E2"><b>27369</b></font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started server process <b>[</b><font color="#34E2E2"><b>27370</b></font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started server process <b>[</b><font color="#34E2E2"><b>27367</b></font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Waiting for application startup.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Waiting for application startup.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Waiting for application startup.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Waiting for application startup.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Application startup complete.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Application startup complete.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Application startup complete.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Application startup complete.
+```
 
-## Uvicorn mit Workern
+</div>
 
-Uvicorn bietet ebenfalls die Möglichkeit, mehrere **Workerprozesse** zu starten und auszuführen.
+////
 
-Dennoch sind die Fähigkeiten von Uvicorn zur Abwicklung von Workerprozessen derzeit eingeschränkter als die von Gunicorn. Wenn Sie also einen Prozessmanager auf dieser Ebene (auf der Python-Ebene) haben möchten, ist es vermutlich besser, es mit Gunicorn als Prozessmanager zu versuchen.
+//// tab | `uvicorn`
 
-Wie auch immer, Sie würden es so ausführen:
+Wenn Sie den `uvicorn`-Befehl direkt verwenden möchten:
 
 <div class="termy">
 
@@ -149,15 +105,17 @@ $ uvicorn main:app --host 0.0.0.0 --port 8080 --workers 4
 
 </div>
 
+////
+
 Die einzige neue Option hier ist `--workers`, die Uvicorn anweist, 4 Workerprozesse zu starten.
 
 Sie können auch sehen, dass die **PID** jedes Prozesses angezeigt wird, `27365` für den übergeordneten Prozess (dies ist der **Prozessmanager**) und eine für jeden Workerprozess: `27368`, `27369`, `27370` und `27367`.
 
-## Deployment-Konzepte
+## Deployment-Konzepte { #deployment-concepts }
 
-Hier haben Sie gesehen, wie Sie mit **Gunicorn** (oder Uvicorn) **Uvicorn-Workerprozesse** verwalten, um die Ausführung der Anwendung zu **parallelisieren**, **mehrere Kerne** der CPU zu nutzen und in der Lage zu sein, **mehr Requests** zu bedienen.
+Hier haben Sie gesehen, wie Sie mehrere **Worker** verwenden, um die Ausführung der Anwendung zu **parallelisieren**, **mehrere Kerne** der CPU zu nutzen und in der Lage zu sein, **mehr Requests** zu bearbeiten.
 
-In der Liste der Deployment-Konzepte von oben würde die Verwendung von Workern hauptsächlich beim **Replikation**-Teil und ein wenig bei **Neustarts** helfen, aber Sie müssen sich trotzdem um die anderen kümmern:
+In der Liste der Deployment-Konzepte von oben würde die Verwendung von Workern hauptsächlich bei der **Replikation** und ein wenig bei **Neustarts** helfen, aber Sie müssen sich trotzdem um die anderen kümmern:
 
 * **Sicherheit – HTTPS**
 * **Beim Hochfahren ausführen**
@@ -166,18 +124,16 @@ In der Liste der Deployment-Konzepte von oben würde die Verwendung von Workern
 * **Arbeitsspeicher**
 * **Schritte vor dem Start**
 
-## Container und Docker
+## Container und Docker { #containers-and-docker }
 
 Im nächsten Kapitel über [FastAPI in Containern – Docker](docker.md){.internal-link target=_blank} werde ich einige Strategien erläutern, die Sie für den Umgang mit den anderen **Deployment-Konzepten** verwenden können.
 
-Ich zeige Ihnen auch das **offizielle Docker-Image**, welches **Gunicorn mit Uvicorn-Workern** und einige Standardkonfigurationen enthält, die für einfache Fälle nützlich sein können.
-
-Dort zeige ich Ihnen auch, wie Sie **Ihr eigenes Image von Grund auf erstellen**, um einen einzelnen Uvicorn-Prozess (ohne Gunicorn) auszuführen. Es ist ein einfacher Vorgang und wahrscheinlich das, was Sie tun möchten, wenn Sie ein verteiltes Containerverwaltungssystem wie **Kubernetes** verwenden.
+Ich zeige Ihnen, wie Sie **Ihr eigenes Image von Grund auf erstellen**, um einen einzelnen Uvicorn-Prozess auszuführen. Es ist ein einfacher Vorgang und wahrscheinlich das, was Sie tun möchten, wenn Sie ein verteiltes Containerverwaltungssystem wie **Kubernetes** verwenden.
 
-## Zusammenfassung
+## Zusammenfassung { #recap }
 
-Sie können **Gunicorn** (oder auch Uvicorn) als Prozessmanager mit Uvicorn-Workern verwenden, um **Multikern-CPUs** zu nutzen und **mehrere Prozesse parallel** auszuführen.
+Sie können mehrere Workerprozesse mit der `--workers`-CLI-Option über die `fastapi`- oder `uvicorn`-Befehle nutzen, um **Multikern-CPUs** auszunutzen und **mehrere Prozesse parallel** auszuführen.
 
-Sie können diese Tools und Ideen nutzen, wenn Sie **Ihr eigenes Deployment-System** einrichten und sich dabei selbst um die anderen Deployment-Konzepte kümmern.
+Sie könnten diese Tools und Ideen nutzen, wenn Sie **Ihr eigenes Deployment-System** einrichten und sich dabei selbst um die anderen Deployment-Konzepte kümmern.
 
 Schauen Sie sich das nächste Kapitel an, um mehr über **FastAPI** mit Containern (z. B. Docker und Kubernetes) zu erfahren. Sie werden sehen, dass diese Tools auch einfache Möglichkeiten bieten, die anderen **Deployment-Konzepte** zu lösen. ✨

docs/de/docs/deployment/versions.md

@@ -1,4 +1,4 @@
-# Über FastAPI-Versionen
+# Über FastAPI-Versionen { #about-fastapi-versions }
 
 **FastAPI** wird bereits in vielen Anwendungen und Systemen produktiv eingesetzt. Und die Testabdeckung wird bei 100 % gehalten. Aber seine Entwicklung geht immer noch schnell voran.
 
@@ -8,35 +8,35 @@ Aus diesem Grund sind die aktuellen Versionen immer noch `0.x.x`, was darauf hin
 
 Sie können jetzt Produktionsanwendungen mit **FastAPI** erstellen (und das tun Sie wahrscheinlich schon seit einiger Zeit), Sie müssen nur sicherstellen, dass Sie eine Version verwenden, die korrekt mit dem Rest Ihres Codes funktioniert.
 
-## `fastapi`-Version pinnen
+## Ihre `fastapi`-Version pinnen { #pin-your-fastapi-version }
 
 Als Erstes sollten Sie die Version von **FastAPI**, die Sie verwenden, an die höchste Version „pinnen“, von der Sie wissen, dass sie für Ihre Anwendung korrekt funktioniert.
 
-Angenommen, Sie verwenden in Ihrer Anwendung die Version `0.45.0`.
+Angenommen, Sie verwenden in Ihrer App die Version `0.112.0`.
 
 Wenn Sie eine `requirements.txt`-Datei verwenden, können Sie die Version wie folgt angeben:
 
 ```txt
-fastapi==0.45.0
+fastapi[standard]==0.112.0
 ```
 
-Das würde bedeuten, dass Sie genau die Version `0.45.0` verwenden.
+Das würde bedeuten, dass Sie genau die Version `0.112.0` verwenden.
 
 Oder Sie können sie auch anpinnen mit:
 
 ```txt
-fastapi>=0.45.0,<0.46.0
+fastapi[standard]>=0.112.0,<0.113.0
 ```
 
-Das würde bedeuten, dass Sie eine Version `0.45.0` oder höher verwenden würden, aber kleiner als `0.46.0`, beispielsweise würde eine Version `0.45.2` immer noch akzeptiert.
+Das würde bedeuten, dass Sie eine Version `0.112.0` oder höher verwenden würden, aber kleiner als `0.113.0`, beispielsweise würde eine Version `0.112.2` immer noch akzeptiert.
 
-Wenn Sie zum Verwalten Ihrer Installationen andere Tools wie Poetry, Pipenv oder andere verwenden, sie verfügen alle über eine Möglichkeit, bestimmte Versionen für Ihre Packages zu definieren.
+Wenn Sie zum Verwalten Ihrer Installationen andere Tools wie `uv`, Poetry, Pipenv oder andere verwenden, sie verfügen alle über eine Möglichkeit, bestimmte Versionen für Ihre Packages zu definieren.
 
-## Verfügbare Versionen
+## Verfügbare Versionen { #available-versions }
 
 Die verfügbaren Versionen können Sie in den [Release Notes](../release-notes.md){.internal-link target=_blank} einsehen (z. B. um zu überprüfen, welches die neueste Version ist).
 
-## Über Versionen
+## Über Versionen { #about-versions }
 
 Gemäß den Konventionen zur semantischen Versionierung könnte jede Version unter `1.0.0` potenziell nicht abwärtskompatible Änderungen hinzufügen.
 
@@ -62,9 +62,9 @@ Nicht abwärtskompatible Änderungen und neue Funktionen werden in „MINOR“-V
 
 ///
 
-## Upgrade der FastAPI-Versionen
+## Upgrade der FastAPI-Versionen { #upgrading-the-fastapi-versions }
 
-Sie sollten Tests für Ihre Anwendung hinzufügen.
+Sie sollten Tests für Ihre App hinzufügen.
 
 Mit **FastAPI** ist das sehr einfach (dank Starlette), schauen Sie sich die Dokumentation an: [Testen](../tutorial/testing.md){.internal-link target=_blank}
 
@@ -72,7 +72,7 @@ Nachdem Sie Tests erstellt haben, können Sie die **FastAPI**-Version auf eine n
 
 Wenn alles funktioniert oder nachdem Sie die erforderlichen Änderungen vorgenommen haben und alle Ihre Tests bestehen, können Sie Ihr `fastapi` an die neue aktuelle Version pinnen.
 
-## Über Starlette
+## Über Starlette { #about-starlette }
 
 Sie sollten die Version von `starlette` nicht pinnen.
 
@@ -80,13 +80,14 @@ Verschiedene Versionen von **FastAPI** verwenden eine bestimmte neuere Version v
 
 Sie können **FastAPI** also einfach die korrekte Starlette-Version verwenden lassen.
 
-## Über Pydantic
+## Über Pydantic { #about-pydantic }
 
 Pydantic integriert die Tests für **FastAPI** in seine eigenen Tests, sodass neue Versionen von Pydantic (über `1.0.0`) immer mit FastAPI kompatibel sind.
 
-Sie können Pydantic an jede für Sie geeignete Version über `1.0.0` und unter `2.0.0` anpinnen.
+Sie können Pydantic an jede für Sie geeignete Version über `1.0.0` anpinnen.
 
 Zum Beispiel:
+
 ```txt
-pydantic>=1.2.0,<2.0.0
+pydantic>=2.7.0,<3.0.0
 ```

docs/de/docs/environment-variables.md

@@ -0,0 +1,298 @@
+# Umgebungsvariablen { #environment-variables }
+
+/// tip | Tipp
+
+Wenn Sie bereits wissen, was „Umgebungsvariablen“ sind und wie man sie verwendet, können Sie dies überspringen.
+
+///
+
+Eine Umgebungsvariable (auch bekannt als „**env var**“) ist eine Variable, die **außerhalb** des Python-Codes im **Betriebssystem** lebt und von Ihrem Python-Code (oder auch von anderen Programmen) gelesen werden kann.
+
+Umgebungsvariablen können nützlich sein, um **Einstellungen** der Anwendung zu handhaben, als Teil der **Installation** von Python usw.
+
+## Umgebungsvariablen erstellen und verwenden { #create-and-use-env-vars }
+
+Sie können Umgebungsvariablen in der **Shell (Terminal)** erstellen und verwenden, ohne Python zu benötigen:
+
+//// tab | Linux, macOS, Windows Bash
+
+<div class="termy">
+
+```console
+// Sie können eine Umgebungsvariable MY_NAME erstellen mit
+$ export MY_NAME="Wade Wilson"
+
+// Dann können Sie sie mit anderen Programmen verwenden, etwa
+$ echo "Hello $MY_NAME"
+
+Hello Wade Wilson
+```
+
+</div>
+
+////
+
+//// tab | Windows PowerShell
+
+<div class="termy">
+
+```console
+// Erstellen Sie eine Umgebungsvariable MY_NAME
+$ $Env:MY_NAME = "Wade Wilson"
+
+// Verwenden Sie sie mit anderen Programmen, etwa
+$ echo "Hello $Env:MY_NAME"
+
+Hello Wade Wilson
+```
+
+</div>
+
+////
+
+## Umgebungsvariablen in Python lesen { #read-env-vars-in-python }
+
+Sie können auch Umgebungsvariablen **außerhalb** von Python erstellen, im Terminal (oder mit jeder anderen Methode) und sie dann **in Python** lesen.
+
+Zum Beispiel könnten Sie eine Datei `main.py` haben mit:
+
+```Python hl_lines="3"
+import os
+
+name = os.getenv("MY_NAME", "World")
+print(f"Hello {name} from Python")
+```
+
+/// tip | Tipp
+
+Das zweite Argument von <a href="https://docs.python.org/3.8/library/os.html#os.getenv" class="external-link" target="_blank">`os.getenv()`</a> ist der Defaultwert, der zurückgegeben wird.
+
+Wenn er nicht angegeben wird, ist er standardmäßig `None`. Hier geben wir `"World"` als den zu verwendenden Defaultwert an.
+
+///
+
+Dann könnten Sie das Python-Programm aufrufen:
+
+//// tab | Linux, macOS, Windows Bash
+
+<div class="termy">
+
+```console
+// Hier setzen wir die Umgebungsvariable noch nicht
+$ python main.py
+
+// Da wir die Umgebungsvariable nicht gesetzt haben, erhalten wir den Defaultwert
+
+Hello World from Python
+
+// Aber wenn wir zuerst eine Umgebungsvariable erstellen
+$ export MY_NAME="Wade Wilson"
+
+// Und dann das Programm erneut aufrufen
+$ python main.py
+
+// Jetzt kann es die Umgebungsvariable lesen
+
+Hello Wade Wilson from Python
+```
+
+</div>
+
+////
+
+//// tab | Windows PowerShell
+
+<div class="termy">
+
+```console
+// Hier setzen wir die Umgebungsvariable noch nicht
+$ python main.py
+
+// Da wir die Umgebungsvariable nicht gesetzt haben, erhalten wir den Defaultwert
+
+Hello World from Python
+
+// Aber wenn wir zuerst eine Umgebungsvariable erstellen
+$ $Env:MY_NAME = "Wade Wilson"
+
+// Und dann das Programm erneut aufrufen
+$ python main.py
+
+// Jetzt kann es die Umgebungsvariable lesen
+
+Hello Wade Wilson from Python
+```
+
+</div>
+
+////
+
+Da Umgebungsvariablen außerhalb des Codes gesetzt werden können, aber vom Code gelesen werden können und nicht mit den restlichen Dateien gespeichert (in `git` committet) werden müssen, werden sie häufig für Konfigurationen oder **Einstellungen** verwendet.
+
+Sie können auch eine Umgebungsvariable nur für einen **spezifischen Programmaufruf** erstellen, die nur für dieses Programm und nur für dessen Dauer verfügbar ist.
+
+Um dies zu tun, erstellen Sie sie direkt vor dem Programmaufruf, in derselben Zeile:
+
+<div class="termy">
+
+```console
+// Erstellen Sie eine Umgebungsvariable MY_NAME in der Zeile für diesen Programmaufruf
+$ MY_NAME="Wade Wilson" python main.py
+
+// Jetzt kann es die Umgebungsvariable lesen
+
+Hello Wade Wilson from Python
+
+// Die Umgebungsvariable existiert danach nicht mehr
+$ python main.py
+
+Hello World from Python
+```
+
+</div>
+
+/// tip | Tipp
+
+Sie können mehr darüber lesen auf <a href="https://12factor.net/config" class="external-link" target="_blank">The Twelve-Factor App: Config</a>.
+
+///
+
+## Typen und Validierung { #types-and-validation }
+
+Diese Umgebungsvariablen können nur **Textstrings** handhaben, da sie extern zu Python sind und kompatibel mit anderen Programmen und dem Rest des Systems (und sogar mit verschiedenen Betriebssystemen, wie Linux, Windows, macOS) sein müssen.
+
+Das bedeutet, dass **jeder Wert**, der in Python von einer Umgebungsvariable gelesen wird, **ein `str` sein wird**, und jede Konvertierung in einen anderen Typ oder jede Validierung muss im Code vorgenommen werden.
+
+Sie werden mehr darüber lernen, wie man Umgebungsvariablen zur Handhabung von **Anwendungseinstellungen** verwendet, im [Handbuch für fortgeschrittene Benutzer – Einstellungen und Umgebungsvariablen](./advanced/settings.md){.internal-link target=_blank}.
+
+## `PATH`-Umgebungsvariable { #path-environment-variable }
+
+Es gibt eine **spezielle** Umgebungsvariable namens **`PATH`**, die von den Betriebssystemen (Linux, macOS, Windows) verwendet wird, um Programme zu finden, die ausgeführt werden sollen.
+
+Der Wert der Variable `PATH` ist ein langer String, der aus Verzeichnissen besteht, die auf Linux und macOS durch einen Doppelpunkt `:` und auf Windows durch ein Semikolon `;` getrennt sind.
+
+Zum Beispiel könnte die `PATH`-Umgebungsvariable so aussehen:
+
+//// tab | Linux, macOS
+
+```plaintext
+/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin
+```
+
+Das bedeutet, dass das System nach Programmen in den Verzeichnissen suchen sollte:
+
+* `/usr/local/bin`
+* `/usr/bin`
+* `/bin`
+* `/usr/sbin`
+* `/sbin`
+
+////
+
+//// tab | Windows
+
+```plaintext
+C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32
+```
+
+Das bedeutet, dass das System nach Programmen in den Verzeichnissen suchen sollte:
+
+* `C:\Program Files\Python312\Scripts`
+* `C:\Program Files\Python312`
+* `C:\Windows\System32`
+
+////
+
+Wenn Sie einen **Befehl** im Terminal eingeben, **sucht** das Betriebssystem nach dem Programm in **jedem dieser Verzeichnisse**, die in der `PATH`-Umgebungsvariable aufgeführt sind.
+
+Zum Beispiel, wenn Sie `python` im Terminal eingeben, sucht das Betriebssystem nach einem Programm namens `python` im **ersten Verzeichnis** in dieser Liste.
+
+Wenn es es findet, wird es **benutzt**. Andernfalls sucht es weiter in den **anderen Verzeichnissen**.
+
+### Python installieren und den `PATH` aktualisieren { #installing-python-and-updating-the-path }
+
+Wenn Sie Python installieren, könnten Sie gefragt werden, ob Sie die `PATH`-Umgebungsvariable aktualisieren möchten.
+
+//// tab | Linux, macOS
+
+Angenommen, Sie installieren Python und es landet in einem Verzeichnis `/opt/custompython/bin`.
+
+Wenn Sie erlauben, die `PATH`-Umgebungsvariable zu aktualisieren, fügt der Installer `/opt/custompython/bin` zur `PATH`-Umgebungsvariable hinzu.
+
+Das könnte so aussehen:
+
+```plaintext
+/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/custompython/bin
+```
+
+Auf diese Weise, wenn Sie `python` im Terminal eingeben, findet das System das Python-Programm in `/opt/custompython/bin` (das letzte Verzeichnis) und verwendet dieses.
+
+////
+
+//// tab | Windows
+
+Angenommen, Sie installieren Python und es landet in einem Verzeichnis `C:\opt\custompython\bin`.
+
+Wenn Sie erlauben, die `PATH`-Umgebungsvariable zu aktualisieren, fügt der Installer `C:\opt\custompython\bin` zur `PATH`-Umgebungsvariable hinzu.
+
+```plaintext
+C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32;C:\opt\custompython\bin
+```
+
+Auf diese Weise, wenn Sie `python` im Terminal eingeben, findet das System das Python-Programm in `C:\opt\custompython\bin` (das letzte Verzeichnis) und verwendet dieses.
+
+////
+
+Also, wenn Sie tippen:
+
+<div class="termy">
+
+```console
+$ python
+```
+
+</div>
+
+//// tab | Linux, macOS
+
+Das System wird das `python` Programm in `/opt/custompython/bin` **finden** und es ausführen.
+
+Es wäre ungefähr gleichbedeutend mit der Eingabe von:
+
+<div class="termy">
+
+```console
+$ /opt/custompython/bin/python
+```
+
+</div>
+
+////
+
+//// tab | Windows
+
+Das System wird das `python` Programm in `C:\opt\custompython\bin\python` **finden** und es ausführen.
+
+Es wäre ungefähr gleichbedeutend mit der Eingabe von:
+
+<div class="termy">
+
+```console
+$ C:\opt\custompython\bin\python
+```
+
+</div>
+
+////
+
+Diese Informationen werden nützlich sein, wenn Sie über [Virtuelle Umgebungen](virtual-environments.md){.internal-link target=_blank} lernen.
+
+## Fazit { #conclusion }
+
+Mit diesem Wissen sollten Sie ein grundlegendes Verständnis davon haben, was **Umgebungsvariablen** sind und wie man sie in Python verwendet.
+
+Sie können auch mehr darüber in der <a href="https://en.wikipedia.org/wiki/Environment_variable" class="external-link" target="_blank">Wikipedia zu Umgebungsvariablen</a> lesen.
+
+In vielen Fällen ist es nicht sehr offensichtlich, wie Umgebungsvariablen nützlich und sofort anwendbar sein könnten. Aber sie tauchen immer wieder in vielen verschiedenen Szenarien auf, wenn Sie entwickeln, deshalb ist es gut, darüber Bescheid zu wissen.
+
+Zum Beispiel werden Sie diese Informationen im nächsten Abschnitt über [Virtuelle Umgebungen](virtual-environments.md) benötigen.

docs/de/docs/fastapi-cli.md

@@ -0,0 +1,75 @@
+# FastAPI CLI { #fastapi-cli }
+
+**FastAPI CLI** ist ein Kommandozeilenprogramm, mit dem Sie Ihre FastAPI-App bereitstellen, Ihr FastAPI-Projekt verwalten und mehr.
+
+Wenn Sie FastAPI installieren (z. B. mit `pip install "fastapi[standard]"`), wird ein Package namens `fastapi-cli` mitgeliefert, das den Befehl `fastapi` im Terminal bereitstellt.
+
+Um Ihre FastAPI-App für die Entwicklung auszuführen, können Sie den Befehl `fastapi dev` verwenden:
+
+<div class="termy">
+
+```console
+$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:solid">main.py</u>
+
+  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting development server 🚀
+
+             Searching for package file structure from directories with
+             <font color="#3465A4">__init__.py</font> files
+             Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
+
+   <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span>  🐍 main.py
+
+     <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span>  Importing the FastAPI app object from the module with the
+             following code:
+
+             <u style="text-decoration-style:solid">from </u><u style="text-decoration-style:solid"><b>main</b></u><u style="text-decoration-style:solid"> import </u><u style="text-decoration-style:solid"><b>app</b></u>
+
+      <span style="background-color:#007166"><font color="#D3D7CF"> app </font></span>  Using import string: <font color="#3465A4">main:app</font>
+
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Server started at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font>
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Documentation at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000/docs</u></font>
+
+      <span style="background-color:#007166"><font color="#D3D7CF"> tip </font></span>  Running in development mode, for production use:
+             <b>fastapi run</b>
+
+             Logs:
+
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Will watch for changes in these directories:
+             <b>[</b><font color="#4E9A06">&apos;/home/user/code/awesomeapp&apos;</font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Uvicorn running on <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font> <b>(</b>Press CTRL+C to
+             quit<b>)</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started reloader process <b>[</b><font color="#34E2E2"><b>383138</b></font><b>]</b> using WatchFiles
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started server process <b>[</b><font color="#34E2E2"><b>383153</b></font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Waiting for application startup.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Application startup complete.
+```
+
+</div>
+
+Das Kommandozeilenprogramm namens `fastapi` ist die **FastAPI-CLI**.
+
+FastAPI-CLI nimmt den Pfad zu Ihrem Python-Programm (z. B. `main.py`), erkennt automatisch die `FastAPI`-Instanz (häufig `app` genannt), bestimmt den korrekten Importprozess und stellt sie dann bereit.
+
+Für die Produktion würden Sie stattdessen `fastapi run` verwenden. 🚀
+
+Intern verwendet die **FastAPI CLI** <a href="https://www.uvicorn.org" class="external-link" target="_blank">Uvicorn</a>, einen leistungsstarken, produktionsreifen, ASGI-Server. 😎
+
+## `fastapi dev` { #fastapi-dev }
+
+Das Ausführen von `fastapi dev` startet den Entwicklermodus.
+
+Standardmäßig ist **Autoreload** aktiviert, das den Server automatisch neu lädt, wenn Sie Änderungen an Ihrem Code vornehmen. Dies ist ressourcenintensiv und könnte weniger stabil sein als wenn es deaktiviert ist. Sie sollten es nur für die Entwicklung verwenden. Es horcht auch auf der IP-Adresse `127.0.0.1`, die die IP für Ihre Maschine ist, um nur mit sich selbst zu kommunizieren (`localhost`).
+
+## `fastapi run` { #fastapi-run }
+
+Das Ausführen von `fastapi run` startet FastAPI standardmäßig im Produktionsmodus.
+
+Standardmäßig ist **Autoreload** deaktiviert. Es horcht auch auf der IP-Adresse `0.0.0.0`, was alle verfügbaren IP-Adressen bedeutet, so wird es öffentlich zugänglich für jeden, der mit der Maschine kommunizieren kann. So würden Sie es normalerweise in der Produktion ausführen, beispielsweise in einem Container.
+
+In den meisten Fällen würden (und sollten) Sie einen „Terminierungsproxy“ haben, der HTTPS für Sie verwaltet. Dies hängt davon ab, wie Sie Ihre Anwendung bereitstellen. Ihr Anbieter könnte dies für Sie erledigen, oder Sie müssen es selbst einrichten.
+
+/// tip | Tipp
+
+Sie können mehr darüber in der [Deployment-Dokumentation](deployment/index.md){.internal-link target=_blank} erfahren.
+
+///

docs/de/docs/features.md

@@ -1,21 +1,21 @@
-# Merkmale
+# Merkmale { #features }
 
-## FastAPI Merkmale
+## FastAPI Merkmale { #fastapi-features }
 
 **FastAPI** ermöglicht Ihnen Folgendes:
 
-### Basiert auf offenen Standards
+### Basiert auf offenen Standards { #based-on-open-standards }
 
-* <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank"><strong>OpenAPI</strong></a> für die Erstellung von APIs, inklusive Deklarationen von <abbr title="auch genannt Endpunkte, Routen">Pfad</abbr>-<abbr title="gemeint sind HTTP-Methoden wie POST, GET, PUT, DELETE">Operationen</abbr>, Parametern, Requestbodys, Sicherheit, usw.
+* <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank"><strong>OpenAPI</strong></a> für die Erstellung von APIs, inklusive Deklarationen von <abbr title="auch bekannt als: Endpunkte, Routen">Pfad</abbr>-<abbr title="auch bekannt als HTTP-Methoden, wie POST, GET, PUT, DELETE">Operationen</abbr>, Parametern, <abbr title="Anfragekörper">Requestbodys</abbr>, Sicherheit, usw.
 * Automatische Dokumentation der Datenmodelle mit <a href="https://json-schema.org/" class="external-link" target="_blank"><strong>JSON Schema</strong></a> (da OpenAPI selbst auf JSON Schema basiert).
 * Um diese Standards herum entworfen, nach sorgfältigem Studium. Statt einer nachträglichen Schicht darüber.
 * Dies ermöglicht auch automatische **Client-Code-Generierung** in vielen Sprachen.
 
-### Automatische Dokumentation
+### Automatische Dokumentation { #automatic-docs }
 
 Interaktive API-Dokumentation und erkundbare Web-Benutzeroberflächen. Da das Framework auf OpenAPI basiert, gibt es mehrere Optionen, zwei sind standardmäßig vorhanden.
 
-* <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank"><strong>Swagger UI</strong></a>, bietet interaktive Erkundung, testen und rufen Sie ihre API direkt im Webbrowser auf.
+* <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank"><strong>Swagger UI</strong></a>, bietet interaktive Erkundung, testen und rufen Sie Ihre API direkt im Webbrowser auf.
 
 ![Swagger UI Interaktion](https://fastapi.tiangolo.com/img/index/index-03-swagger-02.png)
 
@@ -23,22 +23,21 @@ Interaktive API-Dokumentation und erkundbare Web-Benutzeroberflächen. Da das Fr
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)
 
-### Nur modernes Python
+### Nur modernes Python { #just-modern-python }
 
-Alles basiert auf **Python 3.8 Typ**-Deklarationen (dank Pydantic). Es muss keine neue Syntax gelernt werden, nur standardisiertes modernes Python.
+Alles basiert auf Standard-**Python-Typ**-Deklarationen (dank Pydantic). Es muss keine neue Syntax gelernt werden, nur standardisiertes modernes Python.
 
 Wenn Sie eine zweiminütige Auffrischung benötigen, wie man Python-Typen verwendet (auch wenn Sie FastAPI nicht benutzen), schauen Sie sich das kurze Tutorial an: [Einführung in Python-Typen](python-types.md){.internal-link target=_blank}.
 
 Sie schreiben Standard-Python mit Typen:
 
 ```Python
-from typing import List, Dict
 from datetime import date
 
 from pydantic import BaseModel
 
-# Deklarieren Sie eine Variable als ein `str`
-# und bekommen Sie Editor-Unterstütung innerhalb der Funktion
+# Deklarieren Sie eine Variable als ein str
+# und bekommen Sie Editor-Unterstützung innerhalb der Funktion
 def main(user_id: str):
     return user_id
 
@@ -64,25 +63,25 @@ second_user_data = {
 my_second_user: User = User(**second_user_data)
 ```
 
-/// info
+/// info | Info
 
 `**second_user_data` bedeutet:
 
-Nimm die Schlüssel-Wert-Paare des `second_user_data` <abbr title="Dictionary – Wörterbuch: In anderen Programmiersprachen auch Hash, Map, Objekt, Assoziatives Array genannt">Dicts</abbr> und übergib sie direkt als Schlüsselwort-Argumente. Äquivalent zu: `User(id=4, name="Mary", joined="2018-11-30")`.
+Nimm die Schlüssel-Wert-Paare des `second_user_data` <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">Dicts</abbr> und übergebe sie direkt als Schlüsselwort-Argumente. Äquivalent zu: `User(id=4, name="Mary", joined="2018-11-30")`
 
 ///
 
-### Editor Unterstützung
+### Editor Unterstützung { #editor-support }
 
 Das ganze Framework wurde so entworfen, dass es einfach und intuitiv zu benutzen ist; alle Entscheidungen wurden auf mehreren Editoren getestet, sogar vor der Implementierung, um die bestmögliche Entwicklererfahrung zu gewährleisten.
 
-In der letzten Python-Entwickler-Umfrage wurde klar, <a href="https://www.jetbrains.com/research/python-developers-survey-2017/#tools-and-features" class="external-link" target="_blank">dass die meist genutzte Funktion die „Autovervollständigung“ ist</a>.
+In den Python-Entwickler-Umfragen wird klar, <a href="https://www.jetbrains.com/research/python-developers-survey-2017/#tools-and-features" class="external-link" target="_blank">dass die meist genutzte Funktion die „Autovervollständigung“ ist</a>.
 
 Das gesamte **FastAPI**-Framework ist darauf ausgelegt, das zu erfüllen. Autovervollständigung funktioniert überall.
 
 Sie werden selten noch mal in der Dokumentation nachschauen müssen.
 
-So kann ihr Editor Sie unterstützen:
+So kann Ihr Editor Sie unterstützen:
 
 * in <a href="https://code.visualstudio.com/" class="external-link" target="_blank">Visual Studio Code</a>:
 
@@ -92,23 +91,23 @@ So kann ihr Editor Sie unterstützen:
 
 ![Editor Unterstützung](https://fastapi.tiangolo.com/img/pycharm-completion.png)
 
-Sie bekommen sogar Autovervollständigung an Stellen, an denen Sie dies vorher nicht für möglich gehalten hätten. Zum Beispiel der `price` Schlüssel in einem JSON Datensatz (dieser könnte auch verschachtelt sein), der aus einer Anfrage kommt.
+Sie bekommen sogar Autovervollständigung an Stellen, an denen Sie dies vorher nicht für möglich gehalten hätten. Zum Beispiel der `price` Schlüssel in einem JSON Datensatz (dieser könnte auch verschachtelt sein), der aus einem Request kommt.
 
 Nie wieder falsche Schlüsselnamen tippen, Hin und Herhüpfen zwischen der Dokumentation, Hoch- und Runterscrollen, um herauszufinden, ob es `username` oder `user_name` war.
 
-### Kompakt
+### Kompakt { #short }
 
 Es gibt für alles sensible **Defaultwerte**, mit optionaler Konfiguration überall. Alle Parameter können feinjustiert werden, damit sie tun, was Sie benötigen, und die API definieren, die Sie brauchen.
 
 Aber standardmäßig **„funktioniert einfach alles“**.
 
-### Validierung
+### Validierung { #validation }
 
 * Validierung für die meisten (oder alle?) Python-**Datentypen**, hierzu gehören:
     * JSON Objekte (`dict`).
     * JSON Listen (`list`), die den Typ ihrer Elemente definieren.
     * Strings (`str`) mit definierter minimaler und maximaler Länge.
-    * Zahlen (`int`, `float`) mit Mindest- und Maximal-Werten, usw.
+    * Zahlen (`int`, `float`) mit Mindest- und Maximalwerten, usw.
 
 * Validierung für mehr exotische Typen, wie:
     * URL.
@@ -118,47 +117,47 @@ Aber standardmäßig **„funktioniert einfach alles“**.
 
 Die gesamte Validierung übernimmt das gut etablierte und robuste **Pydantic**.
 
-### Sicherheit und Authentifizierung
+### Sicherheit und Authentifizierung { #security-and-authentication }
 
-Sicherheit und Authentifizierung ist integriert. Ohne Kompromisse bei Datenbanken oder Datenmodellen.
+Sicherheit und Authentifizierung sind integriert. Ohne Kompromisse bei Datenbanken oder Datenmodellen.
 
 Alle in OpenAPI definierten Sicherheitsschemas, inklusive:
 
-* HTTP Basic Authentifizierung.
+* HTTP Basic.
 * **OAuth2** (auch mit **JWT Tokens**). Siehe dazu das Tutorial zu [OAuth2 mit JWT](tutorial/security/oauth2-jwt.md){.internal-link target=_blank}.
 * API Schlüssel in:
-    * Header-Feldern.
-    * Anfrageparametern.
+    * Headern.
+    * Query-Parametern.
     * Cookies, usw.
 
 Zusätzlich alle Sicherheitsfunktionen von Starlette (inklusive **Session Cookies**).
 
-Alles als wiederverwendbare Tools und Komponenten gebaut, die einfach in ihre Systeme, Datenspeicher, relationalen und nicht-relationalen Datenbanken, usw., integriert werden können.
+Alles als wiederverwendbare Tools und Komponenten gebaut, die einfach in Ihre Systeme, Datenspeicher, relationale und nicht-relationale Datenbanken, usw., integriert werden können.
 
-### Einbringen von Abhängigkeiten (Dependency Injection)
+### Dependency Injection { #dependency-injection }
 
 FastAPI enthält ein extrem einfach zu verwendendes, aber extrem mächtiges <abbr title='Dependency Injection – Einbringen von Abhängigkeiten: Auch bekannt als Komponenten, Resourcen, Dienste, Dienstanbieter'><strong>Dependency Injection</strong></abbr> System.
 
 * Selbst Abhängigkeiten können Abhängigkeiten haben, woraus eine Hierarchie oder ein **„Graph“ von Abhängigkeiten** entsteht.
 * Alles **automatisch gehandhabt** durch das Framework.
-* Alle Abhängigkeiten können Daten von Anfragen anfordern und das Verhalten von **Pfadoperationen** und der automatisierten Dokumentation **modifizieren**.
+* Alle Abhängigkeiten können Daten von Requests anfordern und das Verhalten von **Pfadoperationen** und der automatisierten Dokumentation **modifizieren**.
 * **Automatische Validierung** selbst für solche Parameter von *Pfadoperationen*, welche in Abhängigkeiten definiert sind.
 * Unterstützung für komplexe Authentifizierungssysteme, **Datenbankverbindungen**, usw.
 * **Keine Kompromisse** bei Datenbanken, Frontends, usw., sondern einfache Integration mit allen.
 
-### Unbegrenzte Erweiterungen
+### Unbegrenzte Erweiterungen { #unlimited-plug-ins }
 
 Oder mit anderen Worten, sie werden nicht benötigt. Importieren und nutzen Sie den Code, den Sie brauchen.
 
 Jede Integration wurde so entworfen, dass sie so einfach zu nutzen ist (mit Abhängigkeiten), dass Sie eine Erweiterung für Ihre Anwendung mit nur zwei Zeilen Code erstellen können. Hierbei nutzen Sie die gleiche Struktur und Syntax, wie bei *Pfadoperationen*.
 
-### Getestet
+### Getestet { #tested }
 
 * 100 % <abbr title="Der Prozentsatz an Code, der automatisch getestet wird">Testabdeckung</abbr>.
-* 100 % <abbr title="Python-Typannotationen, mit denen Ihr Editor und andere exteren Werkezuge Sie besser unterstützen können">Typen annotiert</abbr>.
+* 100 % <abbr title="Python-Typannotationen, mit denen Ihr Editor und andere externe Werkzeuge Sie besser unterstützen können">Typen annotiert</abbr>.
 * Verwendet in Produktionsanwendungen.
 
-## Starlette's Merkmale
+## Starlette Merkmale { #starlette-features }
 
 **FastAPI** ist vollkommen kompatibel (und basiert auf) <a href="https://www.starlette.io/" class="external-link" target="_blank"><strong>Starlette</strong></a>. Das bedeutet, wenn Sie eigenen Starlette Quellcode haben, funktioniert der.
 
@@ -171,28 +170,28 @@ Mit **FastAPI** bekommen Sie alles von **Starlette** (da FastAPI nur Starlette a
 * Hintergrundaufgaben im selben Prozess.
 * Ereignisse beim Starten und Herunterfahren.
 * Testclient baut auf HTTPX auf.
-* **CORS**, GZip, statische Dateien, Responses streamen.
+* **CORS**, GZip, statische Dateien, <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Responses</abbr> streamen.
 * **Sitzungs- und Cookie**-Unterstützung.
 * 100 % Testabdeckung.
 * 100 % Typen annotierte Codebasis.
 
-## Pydantic's Merkmale
+## Pydantic Merkmale { #pydantic-features }
 
 **FastAPI** ist vollkommen kompatibel (und basiert auf) <a href="https://docs.pydantic.dev/" class="external-link" target="_blank"><strong>Pydantic</strong></a>. Das bedeutet, wenn Sie eigenen Pydantic Quellcode haben, funktioniert der.
 
-Inklusive externer Bibliotheken, die auf Pydantic basieren, wie <abbr title="Object-Relational Mapper (Abbildung von Objekten auf relationale Strukturen)">ORM</abbr>s, <abbr title="Object-Document Mapper (Abbildung von Objekten auf nicht-relationale Strukturen)">ODM</abbr>s für Datenbanken.
+Inklusive externer Bibliotheken, die auf Pydantic basieren, wie <abbr title="Object-Relational Mapper – Objektrelationaler Abbilder">ORM</abbr>s, <abbr title="Object-Document Mapper – Objekt-Dokument-Abbilder">ODM</abbr>s für Datenbanken.
 
-Daher können Sie in vielen Fällen das Objekt einer Anfrage **direkt zur Datenbank** schicken, weil alles automatisch validiert wird.
+Daher können Sie in vielen Fällen das Objekt eines Requests **direkt zur Datenbank** schicken, weil alles automatisch validiert wird.
 
-Das gleiche gilt auch für die andere Richtung: Sie können in vielen Fällen das Objekt aus der Datenbank **direkt zum Client** schicken.
+Das gleiche gilt auch für die andere Richtung: Sie können in vielen Fällen das Objekt aus der Datenbank **direkt zum Client** senden.
 
 Mit **FastAPI** bekommen Sie alle Funktionen von **Pydantic** (da FastAPI für die gesamte Datenverarbeitung Pydantic nutzt):
 
 * **Kein Kopfzerbrechen**:
     * Keine neue Schemadefinition-Mikrosprache zu lernen.
     * Wenn Sie Pythons Typen kennen, wissen Sie, wie man Pydantic verwendet.
-* Gutes Zusammenspiel mit Ihrer/Ihrem **<abbr title="Integrierten Entwicklungsumgebung, ähnlich zu (Quellcode-)Editor">IDE</abbr>/<abbr title="Ein Programm, was Fehler im Quellcode sucht">Linter</abbr>/Gehirn**:
-    * Weil Pydantics Datenstrukturen einfach nur Instanzen ihrer definierten Klassen sind; Autovervollständigung, Linting, mypy und ihre Intuition sollten alle einwandfrei mit ihren validierten Daten funktionieren.
+* Gutes Zusammenspiel mit Ihrer/Ihrem **<abbr title="Integrated Development Environment – Integrierte Entwicklungsumgebung: Ähnlich einem Code-Editor">IDE</abbr>/<abbr title="Ein Programm, das Fehler im Quellcode sucht">Linter</abbr>/Gehirn**:
+    * Weil Pydantics Datenstrukturen einfach nur Instanzen ihrer definierten Klassen sind; Autovervollständigung, Linting, mypy und Ihre Intuition sollten alle einwandfrei mit Ihren validierten Daten funktionieren.
 * Validierung von **komplexen Strukturen**:
     * Benutzung von hierarchischen Pydantic-Modellen, Python-`typing`s `List` und `Dict`, etc.
     * Die Validierer erlauben es, komplexe Datenschemen klar und einfach zu definieren, überprüft und dokumentiert als JSON Schema.

docs/de/docs/help-fastapi.md

@@ -1,74 +1,75 @@
-# FastAPI helfen – Hilfe erhalten
+# FastAPI helfen – Hilfe erhalten { #help-fastapi-get-help }
 
-Gefällt Ihnen **FastAPI**?
+Mögen Sie **FastAPI**?
 
 Möchten Sie FastAPI, anderen Benutzern und dem Autor helfen?
 
 Oder möchten Sie Hilfe zu **FastAPI** erhalten?
 
-Es gibt sehr einfache Möglichkeiten zu helfen (manche erfordern nur ein oder zwei Klicks).
+Es gibt sehr einfache Möglichkeiten zu helfen (einige erfordern nur ein oder zwei Klicks).
 
-Und es gibt auch viele Möglichkeiten, Hilfe zu bekommen.
+Und es gibt auch mehrere Möglichkeiten, Hilfe zu bekommen.
 
-## Newsletter abonnieren
+## Newsletter abonnieren { #subscribe-to-the-newsletter }
 
-Sie können den (unregelmäßig erscheinenden) [**FastAPI and Friends**-Newsletter](newsletter.md){.internal-link target=_blank} abonnieren, um auf dem Laufenden zu bleiben:
+Sie können den (unregelmäßigen) [**FastAPI and friends**-Newsletter](newsletter.md){.internal-link target=_blank} abonnieren, um über folgende Themen informiert zu bleiben:
 
-* Neuigkeiten über FastAPI and Friends 🚀
+* Neuigkeiten über FastAPI und Freunde 🚀
 * Anleitungen 📝
 * Funktionen ✨
 * Breaking Changes 🚨
 * Tipps und Tricks ✅
-## FastAPI auf Twitter folgen
+
+## FastAPI auf Twitter folgen { #follow-fastapi-on-twitter }
 
 <a href="https://twitter.com/fastapi" class="external-link" target="_blank">Folgen Sie @fastapi auf **Twitter**</a>, um die neuesten Nachrichten über **FastAPI** zu erhalten. 🐦
 
-## **FastAPI** auf GitHub einen Stern geben
+## **FastAPI** auf GitHub einen Stern geben { #star-fastapi-in-github }
 
-Sie können FastAPI auf GitHub „starren“ (durch Klicken auf den Stern-Button oben rechts): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. ⭐️
+Sie können FastAPI auf GitHub „starren“ (klicken Sie auf den Stern-Button oben rechts): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. ⭐️
 
 Durch das Hinzufügen eines Sterns können andere Benutzer es leichter finden und sehen, dass es für andere bereits nützlich war.
 
-## Das GitHub-Repository auf Releases beobachten
+## Das GitHub-Repository auf Releases überwachen { #watch-the-github-repository-for-releases }
 
-Sie können FastAPI in GitHub beobachten (Klicken Sie oben rechts auf den Button „watch“): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. 👀
+Sie können FastAPI auf GitHub „beobachten“ (klicken Sie auf den „watch“-Button oben rechts): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. 👀
 
 Dort können Sie „Releases only“ auswählen.
 
-Auf diese Weise erhalten Sie Benachrichtigungen (per E-Mail), wenn es einen neuen Release (eine neue Version) von **FastAPI** mit Fehlerbehebungen und neuen Funktionen gibt.
+Auf diese Weise erhalten Sie Benachrichtigungen (per E-Mail), wenn es ein neues Release (eine neue Version) von **FastAPI** mit Bugfixes und neuen Funktionen gibt.
 
-## Mit dem Autor vernetzen
+## Mit dem Autor vernetzen { #connect-with-the-author }
 
 Sie können sich mit <a href="https://tiangolo.com" class="external-link" target="_blank">mir (Sebastián Ramírez / `tiangolo`)</a>, dem Autor, verbinden.
 
-Insbesondere:
+Sie können:
 
-* <a href="https://github.com/tiangolo" class="external-link" target="_blank"> Folgen Sie mir auf **GitHub**</a>.
-    * Finden Sie andere Open-Source-Projekte, die ich erstellt habe und die Ihnen helfen könnten.
-    * Folgen Sie mir, um mitzubekommen, wenn ich ein neues Open-Source-Projekt erstelle.
-* <a href="https://twitter.com/tiangolo" class="external-link" target="_blank">Folgen Sie mir auf **Twitter**</a> oder <a href="https://fosstodon.org/@tiangolo" class="external-link" target="_blank">Mastodon</a>.
-    * Berichten Sie mir, wie Sie FastAPI verwenden (das höre ich gerne).
-    * Bekommen Sie mit, wenn ich Ankündigungen mache oder neue Tools veröffentliche.
+* <a href="https://github.com/tiangolo" class="external-link" target="_blank">Mir auf **GitHub** folgen</a>.
+    * Andere Open-Source-Projekte sehen, die ich erstellt habe und die Ihnen helfen könnten.
+    * Mir folgen, um zu sehen, wenn ich ein neues Open-Source-Projekt erstelle.
+* <a href="https://twitter.com/tiangolo" class="external-link" target="_blank">Mir auf **Twitter** folgen</a> oder <a href="https://fosstodon.org/@tiangolo" class="external-link" target="_blank">Mastodon</a>.
+    * Mir mitteilen, wie Sie FastAPI verwenden (ich höre das gerne).
+    * Mitbekommen, wenn ich Ankündigungen mache oder neue Tools veröffentliche.
     * Sie können auch <a href="https://twitter.com/fastapi" class="external-link" target="_blank">@fastapi auf Twitter folgen</a> (ein separates Konto).
-* <a href="https://www.linkedin.com/in/tiangolo/" class="external-link" target="_blank">Folgen Sie mir auf **LinkedIn**</a>.
-    * Bekommen Sie mit, wenn ich Ankündigungen mache oder neue Tools veröffentliche (obwohl ich Twitter häufiger verwende 🤷‍♂).
-* Lesen Sie, was ich schreibe (oder folgen Sie mir) auf <a href="https://dev.to/tiangolo" class="external-link" target="_blank">**Dev.to**</a> oder <a href="https://medium.com/@tiangolo" class="external-link" target="_blank">**Medium**</a>.
-    * Lesen Sie andere Ideen, Artikel, und erfahren Sie mehr über die von mir erstellten Tools.
-    * Folgen Sie mir, um zu lesen, wenn ich etwas Neues veröffentliche.
+* <a href="https://www.linkedin.com/in/tiangolo/" class="external-link" target="_blank">Mir auf **LinkedIn** folgen</a>.
+    * Mitbekommen, wenn ich Ankündigungen mache oder neue Tools veröffentliche (obwohl ich Twitter häufiger verwende 🤷‍♂).
+* Lesen, was ich schreibe (oder mir folgen) auf <a href="https://dev.to/tiangolo" class="external-link" target="_blank">**Dev.to**</a> oder <a href="https://medium.com/@tiangolo" class="external-link" target="_blank">**Medium**</a>.
+    * Andere Ideen, Artikel lesen und mehr über die von mir erstellten Tools erfahren.
+    * Mir folgen, um zu lesen, wenn ich etwas Neues veröffentliche.
 
-## Über **FastAPI** tweeten
+## Über **FastAPI** tweeten { #tweet-about-fastapi }
 
-<a href="https://twitter.com/compose/tweet?text=Ich liebe @fastapi, weil ... https://github.com/fastapi/fastapi" class="external-link" target= "_blank">Tweeten Sie über **FastAPI**</a> und teilen Sie mir und anderen mit, warum es Ihnen gefällt. 🎉
+<a href="https://twitter.com/compose/tweet?text=Ich liebe @fastapi, weil ... https://github.com/fastapi/fastapi" class="external-link" target="_blank">Tweeten Sie über **FastAPI**</a> und teilen Sie mir und anderen mit, warum es Ihnen gefällt. 🎉
 
 Ich höre gerne, wie **FastAPI** verwendet wird, was Ihnen daran gefallen hat, in welchem Projekt/Unternehmen Sie es verwenden, usw.
 
-## Für FastAPI abstimmen
+## Für FastAPI abstimmen { #vote-for-fastapi }
 
-* <a href="https://www.slant.co/options/34241/~fastapi-review" class="external-link" target="_blank">Stimmen Sie für **FastAPI** auf Slant</a >.
+* <a href="https://www.slant.co/options/34241/~fastapi-review" class="external-link" target="_blank">Stimmen Sie für **FastAPI** auf Slant</a>.
 * <a href="https://alternativeto.net/software/fastapi/about/" class="external-link" target="_blank">Stimmen Sie für **FastAPI** auf AlternativeTo</a>.
-* <a href="https://stackshare.io/pypi-fastapi" class="external-link" target="_blank">Berichten Sie auf StackShare, dass Sie **FastAPI** verwenden</a>.
+* <a href="https://stackshare.io/pypi-fastapi" class="external-link" target="_blank">Sagen Sie auf StackShare, dass Sie **FastAPI** verwenden</a>.
 
-## Anderen bei Fragen auf GitHub helfen
+## Anderen bei Fragen auf GitHub helfen { #help-others-with-questions-in-github }
 
 Sie können versuchen, anderen bei ihren Fragen zu helfen:
 
@@ -77,19 +78,19 @@ Sie können versuchen, anderen bei ihren Fragen zu helfen:
 
 In vielen Fällen kennen Sie möglicherweise bereits die Antwort auf diese Fragen. 🤓
 
-Wenn Sie vielen Menschen bei ihren Fragen helfen, werden Sie offizieller [FastAPI-Experte](fastapi-people.md#experten){.internal-link target=_blank}. 🎉
+Wenn Sie vielen Menschen bei ihren Fragen helfen, werden Sie offizieller [FastAPI-Experte](fastapi-people.md#fastapi-experts){.internal-link target=_blank}. 🎉
 
-Denken Sie aber daran, der wichtigste Punkt ist: Versuchen Sie, freundlich zu sein. Die Leute bringen ihre Frustrationen mit und fragen in vielen Fällen nicht auf die beste Art und Weise, aber versuchen Sie dennoch so gut wie möglich, freundlich zu sein. 🤗
+Denken Sie daran, der wichtigste Punkt ist: Versuchen Sie, freundlich zu sein. Die Leute bringen ihre Frustrationen mit und fragen in vielen Fällen nicht auf die beste Art und Weise, aber versuchen Sie dennoch so gut wie möglich, freundlich zu sein. 🤗
 
-Die **FastAPI**-Community soll freundlich und einladend sein. Und auch kein Mobbing oder respektloses Verhalten gegenüber anderen akzeptieren. Wir müssen uns umeinander kümmern.
+Die **FastAPI**-Community soll freundlich und einladend sein. Akzeptieren Sie gleichzeitig kein Mobbing oder respektloses Verhalten gegenüber anderen. Wir müssen uns umeinander kümmern.
 
 ---
 
-So helfen Sie anderen bei Fragen (in Diskussionen oder Problemen):
+So helfen Sie anderen bei Fragen (in Diskussionen oder Issues):
 
-### Die Frage verstehen
+### Die Frage verstehen { #understand-the-question }
 
-* Fragen Sie sich, ob Sie verstehen, was das **Ziel** und der Anwendungsfall der fragenden Person ist.
+* Prüfen Sie, ob Sie verstehen können, was der **Zweck** und der Anwendungsfall der fragenden Person ist.
 
 * Überprüfen Sie dann, ob die Frage (die überwiegende Mehrheit sind Fragen) **klar** ist.
 
@@ -97,23 +98,23 @@ So helfen Sie anderen bei Fragen (in Diskussionen oder Problemen):
 
 * Wenn Sie die Frage nicht verstehen können, fragen Sie nach weiteren **Details**.
 
-### Das Problem reproduzieren
+### Das Problem reproduzieren { #reproduce-the-problem }
 
-In den meisten Fällen und bei den meisten Fragen ist etwas mit dem von der Person erstellten **eigenen Quellcode** los.
+In den meisten Fällen und bei den meisten Fragen gibt es etwas in Bezug auf den **Originalcode** der Person.
 
 In vielen Fällen wird nur ein Fragment des Codes gepostet, aber das reicht nicht aus, um **das Problem zu reproduzieren**.
 
-* Sie können die Person darum bitten, ein <a href="https://stackoverflow.com/help/minimal-reproducible-example" class="external-link" target="_blank">minimales, reproduzierbares Beispiel</a> bereitzustellen, welches Sie **kopieren, einfügen** und lokal ausführen können, um den gleichen Fehler oder das gleiche Verhalten zu sehen, das die Person sieht, oder um ihren Anwendungsfall besser zu verstehen.
+* Sie können die Person bitten, ein <a href="https://stackoverflow.com/help/minimal-reproducible-example" class="external-link" target="_blank">minimales, reproduzierbares Beispiel</a> bereitzustellen, welches Sie **kopieren, einfügen** und lokal ausführen können, um den gleichen Fehler oder das gleiche Verhalten zu sehen, das die Person sieht, oder um ihren Anwendungsfall besser zu verstehen.
 
-* Wenn Sie in Geberlaune sind, können Sie versuchen, selbst ein solches Beispiel zu erstellen, nur basierend auf der Beschreibung des Problems. Denken Sie jedoch daran, dass dies viel Zeit in Anspruch nehmen kann und dass es besser sein kann, zunächst um eine Klärung des Problems zu bitten.
+* Wenn Sie in Geberlaune sind, können Sie ein solches Beispiel selbst erstellen, nur basierend auf der Beschreibung des Problems. Denken Sie jedoch daran, dass dies viel Zeit in Anspruch nehmen kann und dass es besser sein kann, zunächst um eine Klärung des Problems zu bitten.
 
-### Lösungen vorschlagen
+### Lösungen vorschlagen { #suggest-solutions }
 
 * Nachdem Sie die Frage verstanden haben, können Sie eine mögliche **Antwort** geben.
 
 * In vielen Fällen ist es besser, das **zugrunde liegende Problem oder den Anwendungsfall** zu verstehen, da es möglicherweise einen besseren Weg zur Lösung gibt als das, was die Person versucht.
 
-### Um Schließung bitten
+### Um Schließung bitten { #ask-to-close }
 
 Wenn die Person antwortet, besteht eine hohe Chance, dass Sie ihr Problem gelöst haben. Herzlichen Glückwunsch, **Sie sind ein Held**! 🦸
 
@@ -122,15 +123,15 @@ Wenn die Person antwortet, besteht eine hohe Chance, dass Sie ihr Problem gelös
     * In GitHub-Diskussionen: den Kommentar als **Antwort** zu markieren.
     * In GitHub-Issues: Das Issue zu **schließen**.
 
-## Das GitHub-Repository beobachten
+## Das GitHub-Repository beobachten { #watch-the-github-repository }
 
-Sie können FastAPI auf GitHub „beobachten“ (Klicken Sie oben rechts auf die Schaltfläche „watch“): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank" >https://github.com/fastapi/fastapi</a>. 👀
+Sie können FastAPI auf GitHub „beobachten“ (klicken Sie auf den „watch“-Button oben rechts): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. 👀
 
-Wenn Sie dann „Watching“ statt „Releases only“ auswählen, erhalten Sie Benachrichtigungen, wenn jemand ein neues Issue eröffnet oder eine neue Frage stellt. Sie können auch spezifizieren, dass Sie nur über neue Issues, Diskussionen, PRs, usw. benachrichtigt werden möchten.
+Wenn Sie dann „Watching“ statt „Releases only“ auswählen, erhalten Sie Benachrichtigungen, wenn jemand ein neues Issue eröffnet oder eine neue Frage stellt. Sie können auch spezifizieren, dass Sie nur über neue Issues, Diskussionen, PRs usw. benachrichtigt werden möchten.
 
 Dann können Sie versuchen, bei der Lösung solcher Fragen zu helfen.
 
-## Fragen stellen
+## Fragen stellen { #ask-questions }
 
 Sie können im GitHub-Repository <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">eine neue Frage erstellen</a>, zum Beispiel:
 
@@ -139,9 +140,9 @@ Sie können im GitHub-Repository <a href="https://github.com/fastapi/fastapi/dis
 
 **Hinweis**: Wenn Sie das tun, bitte ich Sie, auch anderen zu helfen. 😉
 
-## Pull Requests prüfen
+## Pull Requests prüfen { #review-pull-requests }
 
-Sie können mir helfen, Pull Requests von anderen zu überprüfen (Review).
+Sie können mir helfen, Pull Requests von anderen zu überprüfen.
 
 Noch einmal, bitte versuchen Sie Ihr Bestes, freundlich zu sein. 🤗
 
@@ -149,119 +150,106 @@ Noch einmal, bitte versuchen Sie Ihr Bestes, freundlich zu sein. 🤗
 
 Hier ist, was Sie beachten sollten und wie Sie einen Pull Request überprüfen:
 
-### Das Problem verstehen
+### Das Problem verstehen { #understand-the-problem }
 
 * Stellen Sie zunächst sicher, dass Sie **das Problem verstehen**, welches der Pull Request zu lösen versucht. Möglicherweise gibt es eine längere Diskussion dazu in einer GitHub-Diskussion oder einem GitHub-Issue.
 
 * Es besteht auch eine gute Chance, dass der Pull Request nicht wirklich benötigt wird, da das Problem auf **andere Weise** gelöst werden kann. Dann können Sie das vorschlagen oder danach fragen.
 
-### Der Stil ist nicht so wichtig
+### Keine Panik wegen des Stils { #dont-worry-about-style }
 
-* Machen Sie sich nicht zu viele Gedanken über Dinge wie den Stil von Commit-Nachrichten, ich werde den Commit manuell zusammenführen und anpassen.
+* Machen Sie sich keine Sorgen über Dinge wie den Stil von Commit-Nachrichten. Ich werde den Commit zusammenführen und manuell anpassen.
 
-* Machen Sie sich auch keine Sorgen über Stilregeln, es gibt bereits automatisierte Tools, die das überprüfen.
+* Außerdem, keine Sorgen über Stilregeln, es gibt bereits automatisierte Tools, die das überprüfen.
 
-Und wenn es irgendeinen anderen Stil- oder Konsistenz-Bedarf gibt, bitte ich direkt darum oder füge zusätzliche Commits mit den erforderlichen Änderungen hinzu.
+Und wenn es irgendeinen anderen Stil- oder Konsistenzbedarf gibt, werde ich direkt danach fragen oder zusätzliche Commits mit den erforderlichen Änderungen hinzufügen.
 
-### Den Code überprüfen
+### Den Code testen { #check-the-code }
 
 * Prüfen und lesen Sie den Code, fragen Sie sich, ob er Sinn macht, **führen Sie ihn lokal aus** und testen Sie, ob er das Problem tatsächlich löst.
 
 * Schreiben Sie dann einen **Kommentar** und berichten, dass Sie das getan haben. So weiß ich, dass Sie ihn wirklich überprüft haben.
 
-/// info
+/// info | Info
 
-Leider kann ich PRs, nur weil sie von Mehreren gutgeheißen wurden, nicht einfach vertrauen.
+Leider kann ich PRs, nur weil sie von mehreren gutgeheißen wurden, nicht einfach vertrauen.
 
 Es ist mehrmals passiert, dass es PRs mit drei, fünf oder mehr Zustimmungen gibt, wahrscheinlich weil die Beschreibung ansprechend ist, aber wenn ich die PRs überprüfe, sind sie tatsächlich fehlerhaft, haben einen Bug, oder lösen das Problem nicht, welches sie behaupten, zu lösen. 😅
 
-Daher ist es wirklich wichtig, dass Sie den Code tatsächlich lesen und ausführen und mir in den Kommentaren mitteilen, dass Sie dies getan haben. 🤓
+Daher ist es wirklich wichtig, dass Sie den Code wirklich lesen und ausführen und mir in den Kommentaren mitteilen, dass Sie dies getan haben. 🤓
 
 ///
 
-* Wenn der PR irgendwie vereinfacht werden kann, fragen Sie ruhig danach, aber seien Sie nicht zu wählerisch, es gibt viele subjektive Standpunkte (und ich habe auch meinen eigenen 🙈), also ist es besser, wenn man sich auf die wesentlichen Dinge konzentriert.
+* Wenn der PR in irgendeiner Weise vereinfacht werden kann, können Sie danach fragen, aber es gibt keinen Grund, zu wählerisch zu sein. Es gibt viele subjektive Standpunkte (und ich habe auch meinen eigenen 🙈), also ist es besser, wenn man sich auf die grundlegenden Dinge konzentriert.
 
-### Tests
+### Tests { #tests }
 
 * Helfen Sie mir zu überprüfen, dass der PR **Tests** hat.
 
 * Überprüfen Sie, dass diese Tests vor dem PR **fehlschlagen**. 🚨
 
-* Überprüfen Sie, dass diese Tests nach dem PR **bestanden** werden. ✅
+* Überprüfen Sie dann, dass diese Tests nach dem PR **bestanden** werden. ✅
 
-* Viele PRs haben keine Tests. Sie können den Autor daran **erinnern**, Tests hinzuzufügen, oder Sie können sogar selbst einige Tests **vorschlagen**. Das ist eines der Dinge, die die meiste Zeit in Anspruch nehmen, und dabei können Sie viel helfen.
+* Viele PRs haben keine Tests. Sie können den Autor daran **erinnern**, Tests hinzuzufügen, oder Sie können sogar selbst einige Tests **vorschlagen**. Das ist eines der Dinge, die am meisten Zeit in Anspruch nehmen, und Sie können dabei viel helfen.
 
 * Kommentieren Sie auch hier anschließend, was Sie versucht haben, sodass ich weiß, dass Sie es überprüft haben. 🤓
 
-## Einen Pull Request erstellen
+## Einen Pull Request erstellen { #create-a-pull-request }
 
-Sie können zum Quellcode mit Pull Requests [beitragen](contributing.md){.internal-link target=_blank}, zum Beispiel:
+Sie können [zum Quellcode mit Pull Requests beitragen](contributing.md){.internal-link target=_blank}, zum Beispiel:
 
 * Um einen Tippfehler zu beheben, den Sie in der Dokumentation gefunden haben.
 * Um einen Artikel, ein Video oder einen Podcast über FastAPI zu teilen, den Sie erstellt oder gefunden haben, indem Sie <a href="https://github.com/fastapi/fastapi/edit/master/docs/en/data/external_links.yml" class="external-link" target="_blank">diese Datei bearbeiten</a>.
     * Stellen Sie sicher, dass Sie Ihren Link am Anfang des entsprechenden Abschnitts einfügen.
-* Um zu helfen, [die Dokumentation in Ihre Sprache zu übersetzen](contributing.md#ubersetzungen){.internal-link target=_blank}.
+* Um zu helfen, [die Dokumentation in Ihre Sprache zu übersetzen](contributing.md#translations){.internal-link target=_blank}.
     * Sie können auch dabei helfen, die von anderen erstellten Übersetzungen zu überprüfen (Review).
 * Um neue Dokumentationsabschnitte vorzuschlagen.
-* Um ein bestehendes Problem / einen bestehenden Bug zu beheben.
+* Um ein bestehendes Problem/Bug zu beheben.
     * Stellen Sie sicher, dass Sie Tests hinzufügen.
 * Um eine neue Funktionalität hinzuzufügen.
     * Stellen Sie sicher, dass Sie Tests hinzufügen.
     * Stellen Sie sicher, dass Sie Dokumentation hinzufügen, falls das notwendig ist.
 
-## FastAPI pflegen
+## FastAPI pflegen { #help-maintain-fastapi }
 
-Helfen Sie mir, **FastAPI** instand zu halten! 🤓
+Helfen Sie mir, **FastAPI** zu pflegen! 🤓
 
 Es gibt viel zu tun, und das meiste davon können **SIE** tun.
 
 Die Hauptaufgaben, die Sie jetzt erledigen können, sind:
 
-* [Helfen Sie anderen bei Fragen auf GitHub](#anderen-bei-fragen-auf-github-helfen){.internal-link target=_blank} (siehe Abschnitt oben).
-* [Prüfen Sie Pull Requests](#pull-requests-prufen){.internal-link target=_blank} (siehe Abschnitt oben).
+* [Anderen bei Fragen auf GitHub helfen](#help-others-with-questions-in-github){.internal-link target=_blank} (siehe Abschnitt oben).
+* [Pull Requests prüfen](#review-pull-requests){.internal-link target=_blank} (siehe Abschnitt oben).
 
-Diese beiden Dinge sind es, die **die meiste Zeit in Anspruch nehmen**. Das ist die Hauptarbeit bei der Wartung von FastAPI.
+Diese beiden Aufgaben sind die Dinge, die **am meisten Zeit verbrauchen**. Das ist die Hauptarbeit bei der Wartung von FastAPI.
 
-Wenn Sie mir dabei helfen können, **helfen Sie mir, FastAPI am Laufen zu erhalten** und sorgen dafür, dass es weiterhin **schneller und besser voranschreitet**. 🚀
+Wenn Sie mir dabei helfen können, **helfen Sie mir, FastAPI zu pflegen** und Sie stellen sicher, dass es weiterhin **schneller und besser voranschreitet**. 🚀
 
-## Beim Chat mitmachen
+## Am Chat teilnehmen { #join-the-chat }
 
-Treten Sie dem 👥 <a href="https://discord.gg/VQjSZaeJmf" class="external-link" target="_blank">Discord-Chatserver</a> 👥 bei und treffen Sie sich mit anderen Mitgliedern der FastAPI-Community.
+Treten Sie dem 👥 <a href="https://discord.gg/VQjSZaeJmf" class="external-link" target="_blank">Discord-Chat-Server</a> 👥 bei und treffen Sie sich mit anderen Mitgliedern der FastAPI-Community.
 
 /// tip | Tipp
 
-Wenn Sie Fragen haben, stellen Sie sie bei <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">GitHub Diskussionen</a>, es besteht eine viel bessere Chance, dass Sie hier Hilfe von den [FastAPI-Experten](fastapi-people.md#experten){.internal-link target=_blank} erhalten.
+Bei Fragen stellen Sie sie in <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">GitHub-Diskussionen</a>, dort besteht eine viel größere Chance, dass Sie Hilfe von den [FastAPI-Experten](fastapi-people.md#fastapi-experts){.internal-link target=_blank} erhalten.
 
 Nutzen Sie den Chat nur für andere allgemeine Gespräche.
 
 ///
 
-### Den Chat nicht für Fragen verwenden
+### Den Chat nicht für Fragen verwenden { #dont-use-the-chat-for-questions }
 
-Bedenken Sie, da Chats mehr „freie Konversation“ ermöglichen, dass es verlockend ist, Fragen zu stellen, die zu allgemein und schwierig zu beantworten sind, sodass Sie möglicherweise keine Antworten erhalten.
+Bedenken Sie, dass Sie in Chats, die „freie Konversation“ erlauben, leicht Fragen stellen können, die zu allgemein und schwer zu beantworten sind, sodass Sie möglicherweise keine Antworten erhalten.
 
-Auf GitHub hilft Ihnen die Vorlage dabei, die richtige Frage zu schreiben, sodass Sie leichter eine gute Antwort erhalten oder das Problem sogar selbst lösen können, noch bevor Sie fragen. Und auf GitHub kann ich sicherstellen, dass ich immer alles beantworte, auch wenn es einige Zeit dauert. Ich persönlich kann das mit den Chat-Systemen nicht machen. 😅
+Auf GitHub hilft Ihnen die Vorlage dabei, die richtige Frage zu stellen, sodass Sie leichter eine gute Antwort erhalten können, oder sogar das Problem selbst lösen, bevor Sie überhaupt fragen. Und auf GitHub kann ich sicherstellen, dass ich immer alles beantworte, auch wenn es einige Zeit dauert. Persönlich kann ich das mit den Chat-Systemen nicht machen. 😅
 
-Unterhaltungen in den Chat-Systemen sind außerdem nicht so leicht durchsuchbar wie auf GitHub, sodass Fragen und Antworten möglicherweise im Gespräch verloren gehen. Und nur die auf GitHub machen einen [FastAPI-Experten](fastapi-people.md#experten){.internal-link target=_blank}, Sie werden also höchstwahrscheinlich mehr Aufmerksamkeit auf GitHub erhalten.
+Unterhaltungen in den Chat-Systemen sind auch nicht so leicht durchsuchbar wie auf GitHub, sodass Fragen und Antworten möglicherweise im Gespräch verloren gehen. Und nur die auf GitHub machen einen [FastAPI-Experten](fastapi-people.md#fastapi-experts){.internal-link target=_blank}, Sie werden also höchstwahrscheinlich mehr Aufmerksamkeit auf GitHub erhalten.
 
 Auf der anderen Seite gibt es Tausende von Benutzern in den Chat-Systemen, sodass die Wahrscheinlichkeit hoch ist, dass Sie dort fast immer jemanden zum Reden finden. 😄
 
-## Den Autor sponsern
-
-Sie können den Autor (mich) auch über <a href="https://github.com/sponsors/tiangolo" class="external-link" target="_blank">GitHub-Sponsoren</a> finanziell unterstützen.
-
-Dort könnten Sie mir als Dankeschön einen Kaffee spendieren ☕️. 😄
-
-Und Sie können auch Silber- oder Gold-Sponsor für FastAPI werden. 🏅🎉
-
-## Die Tools sponsern, die FastAPI unterstützen
-
-Wie Sie in der Dokumentation gesehen haben, steht FastAPI auf den Schultern von Giganten, Starlette und Pydantic.
-
-Sie können auch sponsern:
+## Den Autor sponsern { #sponsor-the-author }
 
-* <a href="https://github.com/sponsors/samuelcolvin" class="external-link" target="_blank">Samuel Colvin (Pydantic)</a>
-* <a href="https://github.com/sponsors/encode" class="external-link" target="_blank">Encode (Starlette, Uvicorn)</a>
+Wenn Ihr **Produkt/Firma** auf **FastAPI** angewiesen ist oder in Zusammenhang steht und Sie seine Benutzer erreichen möchten, können Sie den Autor (mich) über <a href="https://github.com/sponsors/tiangolo" class="external-link" target="_blank">GitHub-Sponsoren</a> unterstützen. Je nach Stufe können Sie einige zusätzliche Vorteile erhalten, wie z. B. ein Abzeichen in der Dokumentation. 🎁
 
 ---
 

docs/de/docs/history-design-future.md

@@ -1,12 +1,12 @@
-# Geschichte, Design und Zukunft
+# Geschichte, Design und Zukunft { #history-design-and-future }
 
 Vor einiger Zeit fragte <a href="https://github.com/fastapi/fastapi/issues/3#issuecomment-454956920" class="external-link" target="_blank">ein **FastAPI**-Benutzer</a>:
 
-> Was ist die Geschichte dieses Projekts? Es scheint, als wäre es in ein paar Wochen aus dem Nichts zu etwas Großartigem geworden [...]
+> Was ist die Geschichte dieses Projekts? Es scheint aus dem Nichts in ein paar Wochen zu etwas Großartigem geworden zu sein [...]
 
 Hier ist ein wenig über diese Geschichte.
 
-## Alternativen
+## Alternativen { #alternatives }
 
 Ich habe seit mehreren Jahren APIs mit komplexen Anforderungen (maschinelles Lernen, verteilte Systeme, asynchrone Jobs, NoSQL-Datenbanken, usw.) erstellt und leitete mehrere Entwicklerteams.
 
@@ -28,7 +28,7 @@ Aber irgendwann gab es keine andere Möglichkeit, als etwas zu schaffen, das all
 
 </blockquote>
 
-## Investigation
+## Untersuchung { #investigation }
 
 Durch die Nutzung all dieser vorherigen Alternativen hatte ich die Möglichkeit, von allen zu lernen, Ideen aufzunehmen und sie auf die beste Weise zu kombinieren, die ich für mich und die Entwicklerteams, mit denen ich zusammengearbeitet habe, finden konnte.
 
@@ -38,13 +38,13 @@ Der beste Ansatz bestand außerdem darin, bereits bestehende Standards zu nutzen
 
 Bevor ich also überhaupt angefangen habe, **FastAPI** zu schreiben, habe ich mehrere Monate damit verbracht, die Spezifikationen für OpenAPI, JSON Schema, OAuth2, usw. zu studieren und deren Beziehungen, Überschneidungen und Unterschiede zu verstehen.
 
-## Design
+## Design { #design }
 
 Dann habe ich einige Zeit damit verbracht, die Entwickler-„API“ zu entwerfen, die ich als Benutzer haben wollte (als Entwickler, welcher FastAPI verwendet).
 
 Ich habe mehrere Ideen in den beliebtesten Python-Editoren getestet: PyCharm, VS Code, Jedi-basierte Editoren.
 
-Laut der letzten <a href="https://www.jetbrains.com/research/python-developers-survey-2018/#development-tools" class="external-link" target="_blank">Python-Entwickler-Umfrage</a>, deckt das etwa 80 % der Benutzer ab.
+Laut der letzten <a href="https://www.jetbrains.com/research/python-developers-survey-2018/#development-tools" class="external-link" target="_blank">Python-Entwickler-Umfrage</a> deckt das etwa 80 % der Benutzer ab.
 
 Das bedeutet, dass **FastAPI** speziell mit den Editoren getestet wurde, die von 80 % der Python-Entwickler verwendet werden. Und da die meisten anderen Editoren in der Regel ähnlich funktionieren, sollten alle diese Vorteile für praktisch alle Editoren funktionieren.
 
@@ -52,19 +52,19 @@ Auf diese Weise konnte ich die besten Möglichkeiten finden, die Codeverdoppelun
 
 Alles auf eine Weise, die allen Entwicklern das beste Entwicklungserlebnis bot.
 
-## Anforderungen
+## Anforderungen { #requirements }
 
-Nachdem ich mehrere Alternativen getestet hatte, entschied ich, dass ich <a href="https://pydantic-docs.helpmanual.io/" class="external-link" target="_blank">**Pydantic**</a> wegen seiner Vorteile verwenden würde.
+Nachdem ich mehrere Alternativen getestet hatte, entschied ich, dass ich <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">**Pydantic**</a> wegen seiner Vorteile verwenden würde.
 
 Dann habe ich zu dessen Code beigetragen, um es vollständig mit JSON Schema kompatibel zu machen, und so verschiedene Möglichkeiten zum Definieren von einschränkenden Deklarationen (Constraints) zu unterstützen, und die Editorunterstützung (Typprüfungen, Codevervollständigung) zu verbessern, basierend auf den Tests in mehreren Editoren.
 
 Während der Entwicklung habe ich auch zu <a href="https://www.starlette.io/" class="external-link" target="_blank">**Starlette**</a> beigetragen, der anderen Schlüsselanforderung.
 
-## Entwicklung
+## Entwicklung { #development }
 
 Als ich mit der Erstellung von **FastAPI** selbst begann, waren die meisten Teile bereits vorhanden, das Design definiert, die Anforderungen und Tools bereit und das Wissen über die Standards und Spezifikationen klar und frisch.
 
-## Zukunft
+## Zukunft { #future }
 
 Zu diesem Zeitpunkt ist bereits klar, dass **FastAPI** mit seinen Ideen für viele Menschen nützlich ist.
 

docs/de/docs/how-to/conditional-openapi.md

@@ -1,8 +1,8 @@
-# Bedingte OpenAPI
+# Bedingte OpenAPI { #conditional-openapi }
 
 Bei Bedarf können Sie OpenAPI mithilfe von Einstellungen und Umgebungsvariablen abhängig von der Umgebung bedingt konfigurieren und sogar vollständig deaktivieren.
 
-## Über Sicherheit, APIs und Dokumentation
+## Über Sicherheit, APIs und Dokumentation { #about-security-apis-and-docs }
 
 Das Verstecken Ihrer Dokumentationsoberflächen in der Produktion *sollte nicht* die Methode sein, Ihre API zu schützen.
 
@@ -10,11 +10,11 @@ Dadurch wird Ihrer API keine zusätzliche Sicherheit hinzugefügt, die *Pfadoper
 
 Wenn Ihr Code eine Sicherheitslücke aufweist, ist diese weiterhin vorhanden.
 
-Das Verstecken der Dokumentation macht es nur schwieriger zu verstehen, wie mit Ihrer API interagiert werden kann, und könnte es auch schwieriger machen, diese in der Produktion zu debuggen. Man könnte es einfach als eine Form von <a href="https://de.wikipedia.org/wiki/Security_through_obscurity" class="external-link" target="_blank">Security through obscurity</a> betrachten.
+Das Verstecken der Dokumentation macht es nur schwieriger zu verstehen, wie mit Ihrer API interagiert werden kann, und könnte es auch schwieriger machen, diese in der Produktion zu debuggen. Man könnte es einfach als eine Form von <a href="https://en.wikipedia.org/wiki/Security_through_obscurity" class="external-link" target="_blank"><abbr title="Sicherheit durch Verschleierung">Security through Obscurity</abbr></a> betrachten.
 
 Wenn Sie Ihre API sichern möchten, gibt es mehrere bessere Dinge, die Sie tun können, zum Beispiel:
 
-* Stellen Sie sicher, dass Sie über gut definierte Pydantic-Modelle für Ihre Requestbodys und Responses verfügen.
+* Stellen Sie sicher, dass Sie über gut definierte Pydantic-Modelle für Ihre <abbr title="Anfragekörper">Requestbodys</abbr> und <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Responses</abbr> verfügen.
 * Konfigurieren Sie alle erforderlichen Berechtigungen und Rollen mithilfe von Abhängigkeiten.
 * Speichern Sie niemals Klartext-Passwörter, sondern nur Passwort-Hashes.
 * Implementieren und verwenden Sie gängige kryptografische Tools wie Passlib und JWT-Tokens, usw.
@@ -23,7 +23,7 @@ Wenn Sie Ihre API sichern möchten, gibt es mehrere bessere Dinge, die Sie tun k
 
 Dennoch kann es sein, dass Sie einen ganz bestimmten Anwendungsfall haben, bei dem Sie die API-Dokumentation für eine bestimmte Umgebung (z. B. für die Produktion) oder abhängig von Konfigurationen aus Umgebungsvariablen wirklich deaktivieren müssen.
 
-## Bedingte OpenAPI aus Einstellungen und Umgebungsvariablen
+## Bedingte OpenAPI aus Einstellungen und Umgebungsvariablen { #conditional-openapi-from-settings-and-env-vars }
 
 Sie können problemlos dieselben Pydantic-Einstellungen verwenden, um Ihre generierte OpenAPI und die Dokumentationsoberflächen zu konfigurieren.
 
@@ -33,7 +33,7 @@ Zum Beispiel:
 
 Hier deklarieren wir die Einstellung `openapi_url` mit dem gleichen Defaultwert `"/openapi.json"`.
 
-Und dann verwenden wir das beim Erstellen der `FastAPI`-App.
+Und dann verwenden wir es beim Erstellen der `FastAPI`-App.
 
 Dann könnten Sie OpenAPI (einschließlich der Dokumentationsoberflächen) deaktivieren, indem Sie die Umgebungsvariable `OPENAPI_URL` auf einen leeren String setzen, wie zum Beispiel:
 

docs/de/docs/how-to/configure-swagger-ui.md

@@ -1,14 +1,14 @@
-# Swagger-Oberfläche konfigurieren
+# Swagger-Oberfläche konfigurieren { #configure-swagger-ui }
 
 Sie können einige zusätzliche <a href="https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/" class="external-link" target="_blank">Parameter der Swagger-Oberfläche</a> konfigurieren.
 
 Um diese zu konfigurieren, übergeben Sie das Argument `swagger_ui_parameters` beim Erstellen des `FastAPI()`-App-Objekts oder an die Funktion `get_swagger_ui_html()`.
 
-`swagger_ui_parameters` empfängt ein Dict mit den Konfigurationen, die direkt an die Swagger-Oberfläche übergeben werden.
+`swagger_ui_parameters` empfängt ein <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">Dictionary</abbr> mit den Konfigurationen, die direkt an die Swagger-Oberfläche übergeben werden.
 
 FastAPI konvertiert die Konfigurationen nach **JSON**, um diese mit JavaScript kompatibel zu machen, da die Swagger-Oberfläche das benötigt.
 
-## Syntaxhervorhebung deaktivieren
+## Syntaxhervorhebung deaktivieren { #disable-syntax-highlighting }
 
 Sie könnten beispielsweise die Syntaxhervorhebung in der Swagger-Oberfläche deaktivieren.
 
@@ -24,9 +24,9 @@ Sie können sie jedoch deaktivieren, indem Sie `syntaxHighlight` auf `False` set
 
 <img src="/img/tutorial/extending-openapi/image03.png">
 
-## Das Theme ändern
+## Das Theme ändern { #change-the-theme }
 
-Auf die gleiche Weise könnten Sie das Theme der Syntaxhervorhebung mit dem Schlüssel `syntaxHighlight.theme` festlegen (beachten Sie, dass er einen Punkt in der Mitte hat):
+Auf die gleiche Weise könnten Sie das Theme der Syntaxhervorhebung mit dem Schlüssel `"syntaxHighlight.theme"` festlegen (beachten Sie, dass er einen Punkt in der Mitte hat):
 
 {* ../../docs_src/configure_swagger_ui/tutorial002.py hl[3] *}
 
@@ -34,13 +34,13 @@ Obige Konfiguration würde das Theme für die Farbe der Syntaxhervorhebung ände
 
 <img src="/img/tutorial/extending-openapi/image04.png">
 
-## Defaultparameter der Swagger-Oberfläche ändern
+## Defaultparameter der Swagger-Oberfläche ändern { #change-default-swagger-ui-parameters }
 
 FastAPI enthält einige Defaultkonfigurationsparameter, die für die meisten Anwendungsfälle geeignet sind.
 
 Es umfasst die folgenden Defaultkonfigurationen:
 
-{* ../../fastapi/openapi/docs.py ln[7:23] *}
+{* ../../fastapi/openapi/docs.py ln[8:23] hl[17:23] *}
 
 Sie können jede davon überschreiben, indem Sie im Argument `swagger_ui_parameters` einen anderen Wert festlegen.
 
@@ -48,13 +48,13 @@ Um beispielsweise `deepLinking` zu deaktivieren, könnten Sie folgende Einstellu
 
 {* ../../docs_src/configure_swagger_ui/tutorial003.py hl[3] *}
 
-## Andere Parameter der Swagger-Oberfläche
+## Andere Parameter der Swagger-Oberfläche { #other-swagger-ui-parameters }
 
 Um alle anderen möglichen Konfigurationen zu sehen, die Sie verwenden können, lesen Sie die offizielle <a href="https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/" class="external-link" target="_blank">Dokumentation für die Parameter der Swagger-Oberfläche</a>.
 
-## JavaScript-basierte Einstellungen
+## Nur-JavaScript-Einstellungen { #javascript-only-settings }
 
-Die Swagger-Oberfläche erlaubt, dass andere Konfigurationen auch **JavaScript**-Objekte sein können (z. B. JavaScript-Funktionen).
+Die Swagger-Oberfläche erlaubt, dass andere Konfigurationen auch **Nur-JavaScript**-Objekte sein können (z. B. JavaScript-Funktionen).
 
 FastAPI umfasst auch diese Nur-JavaScript-`presets`-Einstellungen:
 

docs/de/docs/how-to/custom-docs-ui-assets.md

@@ -1,18 +1,18 @@
-# Statische Assets der Dokumentationsoberfläche (selbst hosten)
+# Statische Assets der Dokumentationsoberfläche (Selbst-Hosting) { #custom-docs-ui-static-assets-self-hosting }
 
 Die API-Dokumentation verwendet **Swagger UI** und **ReDoc**, und jede dieser Dokumentationen benötigt einige JavaScript- und CSS-Dateien.
 
-Standardmäßig werden diese Dateien von einem <abbr title="Content Delivery Network – Inhalte-Auslieferungs-Netzwerk: Ein Dienst, der normalerweise aus mehreren Servern besteht und statische Dateien wie JavaScript und CSS bereitstellt. Er wird normalerweise verwendet, um diese Dateien von einem Server bereitzustellen, der näher am Client liegt, wodurch die Leistung verbessert wird.">CDN</abbr> bereitgestellt.
+Standardmäßig werden diese Dateien von einem <abbr title="Content Delivery Network – Inhalte auslieferndes Netzwerk: Ein Dienst, der normalerweise aus mehreren Servern besteht und statische Dateien wie JavaScript und CSS bereitstellt. Er wird häufig verwendet, um diese Dateien vom Server bereitzustellen, der näher am Client liegt, wodurch die Leistung verbessert wird.">CDN</abbr> bereitgestellt.
 
 Es ist jedoch möglich, das anzupassen, ein bestimmtes CDN festzulegen oder die Dateien selbst bereitzustellen.
 
-## Benutzerdefiniertes CDN für JavaScript und CSS
+## Benutzerdefiniertes CDN für JavaScript und CSS { #custom-cdn-for-javascript-and-css }
 
-Nehmen wir an, Sie möchten ein anderes <abbr title="Content Delivery Network">CDN</abbr> verwenden, zum Beispiel möchten Sie `https://unpkg.com/` verwenden.
+Nehmen wir an, Sie möchten ein anderes <abbr title="Content Delivery Network – Inhalte auslieferndes Netzwerk">CDN</abbr> verwenden, zum Beispiel möchten Sie `https://unpkg.com/` verwenden.
 
 Das kann nützlich sein, wenn Sie beispielsweise in einem Land leben, in dem bestimmte URLs eingeschränkt sind.
 
-### Die automatischen Dokumentationen deaktivieren
+### Die automatischen Dokumentationen deaktivieren { #disable-the-automatic-docs }
 
 Der erste Schritt besteht darin, die automatischen Dokumentationen zu deaktivieren, da diese standardmäßig das Standard-CDN verwenden.
 
@@ -20,7 +20,7 @@ Um diese zu deaktivieren, setzen Sie deren URLs beim Erstellen Ihrer `FastAPI`-A
 
 {* ../../docs_src/custom_docs_ui/tutorial001.py hl[8] *}
 
-### Die benutzerdefinierten Dokumentationen hinzufügen
+### Die benutzerdefinierten Dokumentationen hinzufügen { #include-the-custom-docs }
 
 Jetzt können Sie die *Pfadoperationen* für die benutzerdefinierten Dokumentationen erstellen.
 
@@ -32,7 +32,7 @@ Sie können die internen Funktionen von FastAPI wiederverwenden, um die HTML-Sei
 * `swagger_js_url`: die URL, unter welcher der HTML-Code für Ihre Swagger-UI-Dokumentation die **JavaScript**-Datei abrufen kann. Dies ist die benutzerdefinierte CDN-URL.
 * `swagger_css_url`: die URL, unter welcher der HTML-Code für Ihre Swagger-UI-Dokumentation die **CSS**-Datei abrufen kann. Dies ist die benutzerdefinierte CDN-URL.
 
-Und genau so für ReDoc ...
+Und ähnlich für ReDoc ...
 
 {* ../../docs_src/custom_docs_ui/tutorial001.py hl[2:6,11:19,22:24,27:33] *}
 
@@ -46,23 +46,23 @@ Swagger UI erledigt das hinter den Kulissen für Sie, benötigt aber diesen „U
 
 ///
 
-### Eine *Pfadoperation* erstellen, um es zu testen
+### Eine *Pfadoperation* erstellen, um es zu testen { #create-a-path-operation-to-test-it }
 
 Um nun testen zu können, ob alles funktioniert, erstellen Sie eine *Pfadoperation*:
 
 {* ../../docs_src/custom_docs_ui/tutorial001.py hl[36:38] *}
 
-### Es ausprobieren
+### Es testen { #test-it }
 
-Jetzt sollten Sie in der Lage sein, zu Ihrer Dokumentation auf <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> zu gehen und die Seite neu zuladen, die Assets werden nun vom neuen CDN geladen.
+Jetzt sollten Sie in der Lage sein, zu Ihrer Dokumentation auf <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> zu gehen und die Seite neu zu laden, die Assets werden nun vom neuen CDN geladen.
 
-## JavaScript und CSS für die Dokumentation selbst hosten
+## JavaScript und CSS für die Dokumentation selbst hosten { #self-hosting-javascript-and-css-for-docs }
 
-Das Selbst Hosten von JavaScript und CSS kann nützlich sein, wenn Sie beispielsweise möchten, dass Ihre Anwendung auch offline, ohne bestehenden Internetzugang oder in einem lokalen Netzwerk weiter funktioniert.
+Das Selbst-Hosting von JavaScript und CSS kann nützlich sein, wenn Sie beispielsweise möchten, dass Ihre Anwendung auch offline, ohne bestehenden Internetzugang oder in einem lokalen Netzwerk weiter funktioniert.
 
 Hier erfahren Sie, wie Sie diese Dateien selbst in derselben FastAPI-App bereitstellen und die Dokumentation für deren Verwendung konfigurieren.
 
-### Projektdateistruktur
+### Projektdateistruktur { #project-file-structure }
 
 Nehmen wir an, die Dateistruktur Ihres Projekts sieht folgendermaßen aus:
 
@@ -85,11 +85,11 @@ Ihre neue Dateistruktur könnte so aussehen:
 └── static/
 ```
 
-### Die Dateien herunterladen
+### Die Dateien herunterladen { #download-the-files }
 
 Laden Sie die für die Dokumentation benötigten statischen Dateien herunter und legen Sie diese im Verzeichnis `static/` ab.
 
-Sie können wahrscheinlich mit der rechten Maustaste auf jeden Link klicken und eine Option wie etwa `Link speichern unter...` auswählen.
+Sie können wahrscheinlich mit der rechten Maustaste auf jeden Link klicken und eine Option wie etwa „Link speichern unter ...“ auswählen.
 
 **Swagger UI** verwendet folgende Dateien:
 
@@ -113,14 +113,14 @@ Danach könnte Ihre Dateistruktur wie folgt aussehen:
     └── swagger-ui.css
 ```
 
-### Die statischen Dateien bereitstellen
+### Die statischen Dateien bereitstellen { #serve-the-static-files }
 
 * Importieren Sie `StaticFiles`.
 * „Mounten“ Sie eine `StaticFiles()`-Instanz in einem bestimmten Pfad.
 
 {* ../../docs_src/custom_docs_ui/tutorial002.py hl[7,11] *}
 
-### Die statischen Dateien testen
+### Die statischen Dateien testen { #test-the-static-files }
 
 Starten Sie Ihre Anwendung und gehen Sie auf <a href="http://127.0.0.1:8000/static/redoc.standalone.js" class="external-link" target="_blank">http://127.0.0.1:8000/static/redoc.standalone.js</a>.
 
@@ -138,19 +138,19 @@ Das zeigt, dass Sie statische Dateien aus Ihrer Anwendung bereitstellen können
 
 Jetzt können wir die Anwendung so konfigurieren, dass sie diese statischen Dateien für die Dokumentation verwendet.
 
-### Die automatischen Dokumentationen deaktivieren, für statische Dateien
+### Die automatischen Dokumentationen für statische Dateien deaktivieren { #disable-the-automatic-docs-for-static-files }
 
 Wie bei der Verwendung eines benutzerdefinierten CDN besteht der erste Schritt darin, die automatischen Dokumentationen zu deaktivieren, da diese standardmäßig das CDN verwenden.
 
-Um diese zu deaktivieren, setzen Sie deren URLs beim Erstellen Ihrer `FastAPI`-App auf `None`:
+Um sie zu deaktivieren, setzen Sie deren URLs beim Erstellen Ihrer `FastAPI`-App auf `None`:
 
 {* ../../docs_src/custom_docs_ui/tutorial002.py hl[9] *}
 
-### Die benutzerdefinierten Dokumentationen, mit statischen Dateien, hinzufügen
+### Die benutzerdefinierten Dokumentationen für statische Dateien hinzufügen { #include-the-custom-docs-for-static-files }
 
 Und genau wie bei einem benutzerdefinierten CDN können Sie jetzt die *Pfadoperationen* für die benutzerdefinierten Dokumentationen erstellen.
 
-Auch hier können Sie die internen Funktionen von FastAPI wiederverwenden, um die HTML-Seiten für die Dokumentationen zu erstellen, und diesen die erforderlichen Argumente übergeben:
+Auch hier können Sie die internen Funktionen von FastAPI wiederverwenden, um die HTML-Seiten für die Dokumentationen zu erstellen und ihnen die erforderlichen Argumente zu übergeben:
 
 * `openapi_url`: die URL, unter der die HTML-Seite für die Dokumentation das OpenAPI-Schema für Ihre API abrufen kann. Sie können hier das Attribut `app.openapi_url` verwenden.
 * `title`: der Titel Ihrer API.
@@ -158,7 +158,7 @@ Auch hier können Sie die internen Funktionen von FastAPI wiederverwenden, um di
 * `swagger_js_url`: die URL, unter welcher der HTML-Code für Ihre Swagger-UI-Dokumentation die **JavaScript**-Datei abrufen kann. **Das ist die, welche jetzt von Ihrer eigenen Anwendung bereitgestellt wird**.
 * `swagger_css_url`: die URL, unter welcher der HTML-Code für Ihre Swagger-UI-Dokumentation die **CSS**-Datei abrufen kann. **Das ist die, welche jetzt von Ihrer eigenen Anwendung bereitgestellt wird**.
 
-Und genau so für ReDoc ...
+Und ähnlich für ReDoc ...
 
 {* ../../docs_src/custom_docs_ui/tutorial002.py hl[2:6,14:22,25:27,30:36] *}
 
@@ -172,14 +172,14 @@ Swagger UI erledigt das hinter den Kulissen für Sie, benötigt aber diesen „U
 
 ///
 
-### Eine *Pfadoperation* erstellen, um statische Dateien zu testen
+### Eine *Pfadoperation* erstellen, um statische Dateien zu testen { #create-a-path-operation-to-test-static-files }
 
 Um nun testen zu können, ob alles funktioniert, erstellen Sie eine *Pfadoperation*:
 
 {* ../../docs_src/custom_docs_ui/tutorial002.py hl[39:41] *}
 
-### Benutzeroberfläche, mit statischen Dateien, testen
+### Benutzeroberfläche mit statischen Dateien testen { #test-static-files-ui }
 
 Jetzt sollten Sie in der Lage sein, Ihr WLAN zu trennen, gehen Sie zu Ihrer Dokumentation unter <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> und laden Sie die Seite neu.
 
-Und selbst ohne Internet könnten Sie die Dokumentation für Ihre API sehen und damit interagieren.
+Und selbst ohne Internet können Sie die Dokumentation für Ihre API sehen und mit ihr interagieren.

docs/de/docs/how-to/custom-request-and-route.md

@@ -1,10 +1,10 @@
-# Benutzerdefinierte Request- und APIRoute-Klasse
+# Benutzerdefinierte Request- und APIRoute-Klasse { #custom-request-and-apiroute-class }
 
 In einigen Fällen möchten Sie möglicherweise die von den Klassen `Request` und `APIRoute` verwendete Logik überschreiben.
 
 Das kann insbesondere eine gute Alternative zur Logik in einer Middleware sein.
 
-Wenn Sie beispielsweise den Requestbody lesen oder manipulieren möchten, bevor er von Ihrer Anwendung verarbeitet wird.
+Wenn Sie beispielsweise den <abbr title="Anfragekörper">Requestbody</abbr> lesen oder manipulieren möchten, bevor er von Ihrer Anwendung verarbeitet wird.
 
 /// danger | Gefahr
 
@@ -14,7 +14,7 @@ Wenn Sie gerade erst mit **FastAPI** beginnen, möchten Sie diesen Abschnitt vie
 
 ///
 
-## Anwendungsfälle
+## Anwendungsfälle { #use-cases }
 
 Einige Anwendungsfälle sind:
 
@@ -22,13 +22,13 @@ Einige Anwendungsfälle sind:
 * Dekomprimierung gzip-komprimierter Requestbodys.
 * Automatisches Loggen aller Requestbodys.
 
-## Handhaben von benutzerdefinierten Requestbody-Kodierungen
+## Handhaben von benutzerdefinierten Requestbody-Kodierungen { #handling-custom-request-body-encodings }
 
 Sehen wir uns an, wie Sie eine benutzerdefinierte `Request`-Unterklasse verwenden, um gzip-Requests zu dekomprimieren.
 
 Und eine `APIRoute`-Unterklasse zur Verwendung dieser benutzerdefinierten Requestklasse.
 
-### Eine benutzerdefinierte `GzipRequest`-Klasse erstellen
+### Eine benutzerdefinierte `GzipRequest`-Klasse erstellen { #create-a-custom-gziprequest-class }
 
 /// tip | Tipp
 
@@ -44,13 +44,13 @@ Auf diese Weise kann dieselbe Routenklasse gzip-komprimierte oder unkomprimierte
 
 {* ../../docs_src/custom_request_and_route/tutorial001.py hl[8:15] *}
 
-### Eine benutzerdefinierte `GzipRoute`-Klasse erstellen
+### Eine benutzerdefinierte `GzipRoute`-Klasse erstellen { #create-a-custom-gziproute-class }
 
 Als Nächstes erstellen wir eine benutzerdefinierte Unterklasse von `fastapi.routing.APIRoute`, welche `GzipRequest` nutzt.
 
 Dieses Mal wird die Methode `APIRoute.get_route_handler()` überschrieben.
 
-Diese Methode gibt eine Funktion zurück. Und diese Funktion empfängt einen Request und gibt eine Response zurück.
+Diese Methode gibt eine Funktion zurück. Und diese Funktion empfängt einen <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> und gibt eine <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> zurück.
 
 Hier verwenden wir sie, um aus dem ursprünglichen Request einen `GzipRequest` zu erstellen.
 
@@ -58,7 +58,7 @@ Hier verwenden wir sie, um aus dem ursprünglichen Request einen `GzipRequest` z
 
 /// note | Technische Details
 
-Ein `Request` hat ein `request.scope`-Attribut, welches einfach ein Python-`dict` ist, welches die mit dem Request verbundenen Metadaten enthält.
+Ein `Request` hat ein `request.scope`-Attribut, welches einfach ein Python-<abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">`dict`</abbr> ist, welches die mit dem Request verbundenen Metadaten enthält.
 
 Ein `Request` hat auch ein `request.receive`, welches eine Funktion ist, die den Hauptteil des Requests empfängt.
 
@@ -78,11 +78,11 @@ Danach ist die gesamte Verarbeitungslogik dieselbe.
 
 Aufgrund unserer Änderungen in `GzipRequest.body` wird der Requestbody jedoch bei Bedarf automatisch dekomprimiert, wenn er von **FastAPI** geladen wird.
 
-## Zugriff auf den Requestbody in einem Exceptionhandler
+## Zugriff auf den Requestbody in einem Exceptionhandler { #accessing-the-request-body-in-an-exception-handler }
 
 /// tip | Tipp
 
-Um dasselbe Problem zu lösen, ist es wahrscheinlich viel einfacher, den `body` in einem benutzerdefinierten Handler für `RequestValidationError` zu verwenden ([Fehlerbehandlung](../tutorial/handling-errors.md#den-requestvalidationerror-body-verwenden){.internal-link target=_blank}).
+Um dasselbe Problem zu lösen, ist es wahrscheinlich viel einfacher, den `body` in einem benutzerdefinierten Handler für `RequestValidationError` zu verwenden ([Fehlerbehandlung](../tutorial/handling-errors.md#use-the-requestvalidationerror-body){.internal-link target=_blank}).
 
 Dieses Beispiel ist jedoch immer noch gültig und zeigt, wie mit den internen Komponenten interagiert wird.
 
@@ -98,7 +98,7 @@ Wenn eine Exception auftritt, befindet sich die `Request`-Instanz weiterhin im G
 
 {* ../../docs_src/custom_request_and_route/tutorial002.py hl[16:18] *}
 
-## Benutzerdefinierte `APIRoute`-Klasse in einem Router
+## Benutzerdefinierte `APIRoute`-Klasse in einem Router { #custom-apiroute-class-in-a-router }
 
 Sie können auch den Parameter `route_class` eines `APIRouter` festlegen:
 

docs/de/docs/how-to/extending-openapi.md

@@ -1,24 +1,24 @@
-# OpenAPI erweitern
+# OpenAPI erweitern { #extending-openapi }
 
-In einigen Fällen müssen Sie möglicherweise das generierte OpenAPI-Schema ändern.
+Es gibt einige Fälle, in denen Sie das generierte OpenAPI-Schema ändern müssen.
 
 In diesem Abschnitt erfahren Sie, wie.
 
-## Der normale Vorgang
+## Der normale Vorgang { #the-normal-process }
 
 Der normale (Standard-)Prozess ist wie folgt.
 
-Eine `FastAPI`-Anwendung (-Instanz) verfügt über eine `.openapi()`-Methode, von der erwartet wird, dass sie das OpenAPI-Schema zurückgibt.
+Eine `FastAPI`-Anwendung (Instanz) verfügt über eine `.openapi()`-Methode, von der erwartet wird, dass sie das OpenAPI-Schema zurückgibt.
 
 Als Teil der Erstellung des Anwendungsobjekts wird eine *Pfadoperation* für `/openapi.json` (oder welcher Wert für den Parameter `openapi_url` gesetzt wurde) registriert.
 
-Diese gibt lediglich eine JSON-Response zurück, mit dem Ergebnis der Methode `.openapi()` der Anwendung.
+Diese gibt lediglich eine JSON-<abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> zurück, mit dem Ergebnis der Methode `.openapi()` der Anwendung.
 
 Standardmäßig überprüft die Methode `.openapi()` die Eigenschaft `.openapi_schema`, um zu sehen, ob diese Inhalt hat, und gibt diesen zurück.
 
 Ist das nicht der Fall, wird der Inhalt mithilfe der Hilfsfunktion unter `fastapi.openapi.utils.get_openapi` generiert.
 
-Und diese Funktion `get_openapi()` erhält als Parameter:
+Diese Funktion `get_openapi()` erhält als Parameter:
 
 * `title`: Der OpenAPI-Titel, der in der Dokumentation angezeigt wird.
 * `version`: Die Version Ihrer API, z. B. `2.5.0`.
@@ -27,53 +27,53 @@ Und diese Funktion `get_openapi()` erhält als Parameter:
 * `description`: Die Beschreibung Ihrer API. Dies kann Markdown enthalten und wird in der Dokumentation angezeigt.
 * `routes`: Eine Liste von Routen, dies sind alle registrierten *Pfadoperationen*. Sie stammen von `app.routes`.
 
-/// info
+/// info | Info
 
 Der Parameter `summary` ist in OpenAPI 3.1.0 und höher verfügbar und wird von FastAPI 0.99.0 und höher unterstützt.
 
 ///
 
-## Überschreiben der Standardeinstellungen
+## Überschreiben der Standardeinstellungen { #overriding-the-defaults }
 
 Mithilfe der oben genannten Informationen können Sie dieselbe Hilfsfunktion verwenden, um das OpenAPI-Schema zu generieren und jeden benötigten Teil zu überschreiben.
 
-Fügen wir beispielsweise <a href="https://github.com/Rebilly/ReDoc/blob/master/docs/redoc-vendor-extensions.md#x-logo" class="external-link" target="_blank">ReDocs OpenAPI-Erweiterung</a> zum Einbinden eines benutzerdefinierten Logos hinzu.
+Fügen wir beispielsweise <a href="https://github.com/Rebilly/ReDoc/blob/master/docs/redoc-vendor-extensions.md#x-logo" class="external-link" target="_blank">ReDocs OpenAPI-Erweiterung zum Einbinden eines benutzerdefinierten Logos</a> hinzu.
 
-### Normales **FastAPI**
+### Normales **FastAPI** { #normal-fastapi }
 
 Schreiben Sie zunächst wie gewohnt Ihre ganze **FastAPI**-Anwendung:
 
 {* ../../docs_src/extending_openapi/tutorial001.py hl[1,4,7:9] *}
 
-### Das OpenAPI-Schema generieren
+### Das OpenAPI-Schema generieren { #generate-the-openapi-schema }
 
 Verwenden Sie dann dieselbe Hilfsfunktion, um das OpenAPI-Schema innerhalb einer `custom_openapi()`-Funktion zu generieren:
 
 {* ../../docs_src/extending_openapi/tutorial001.py hl[2,15:21] *}
 
-### Das OpenAPI-Schema ändern
+### Das OpenAPI-Schema ändern { #modify-the-openapi-schema }
 
 Jetzt können Sie die ReDoc-Erweiterung hinzufügen und dem `info`-„Objekt“ im OpenAPI-Schema ein benutzerdefiniertes `x-logo` hinzufügen:
 
 {* ../../docs_src/extending_openapi/tutorial001.py hl[22:24] *}
 
-### Zwischenspeichern des OpenAPI-Schemas
+### Zwischenspeichern des OpenAPI-Schemas { #cache-the-openapi-schema }
 
 Sie können die Eigenschaft `.openapi_schema` als „Cache“ verwenden, um Ihr generiertes Schema zu speichern.
 
 Auf diese Weise muss Ihre Anwendung das Schema nicht jedes Mal generieren, wenn ein Benutzer Ihre API-Dokumentation öffnet.
 
-Es wird nur einmal generiert und dann wird dasselbe zwischengespeicherte Schema für die nächsten Requests verwendet.
+Es wird nur einmal generiert und dann wird dasselbe zwischengespeicherte Schema für die nächsten <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Requests</abbr> verwendet.
 
 {* ../../docs_src/extending_openapi/tutorial001.py hl[13:14,25:26] *}
 
-### Die Methode überschreiben
+### Die Methode überschreiben { #override-the-method }
 
 Jetzt können Sie die Methode `.openapi()` durch Ihre neue Funktion ersetzen.
 
 {* ../../docs_src/extending_openapi/tutorial001.py hl[29] *}
 
-### Testen
+### Es testen { #check-it }
 
 Sobald Sie auf <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a> gehen, werden Sie sehen, dass Ihr benutzerdefiniertes Logo verwendet wird (in diesem Beispiel das Logo von **FastAPI**):
 

docs/de/docs/how-to/general.md

@@ -1,39 +1,39 @@
-# Allgemeines – How-To – Rezepte
+# Allgemeines – How-To – Rezepte { #general-how-to-recipes }
 
 Hier finden Sie mehrere Verweise auf andere Stellen in der Dokumentation, für allgemeine oder häufige Fragen.
 
-## Daten filtern – Sicherheit
+## Daten filtern – Sicherheit { #filter-data-security }
 
 Um sicherzustellen, dass Sie nicht mehr Daten zurückgeben, als Sie sollten, lesen Sie die Dokumentation unter [Tutorial – Responsemodell – Rückgabetyp](../tutorial/response-model.md){.internal-link target=_blank}.
 
-## Dokumentations-Tags – OpenAPI
+## Dokumentations-Tags – OpenAPI { #documentation-tags-openapi }
 
 Um Tags zu Ihren *Pfadoperationen* hinzuzufügen und diese in der Oberfläche der Dokumentation zu gruppieren, lesen Sie die Dokumentation unter [Tutorial – Pfadoperation-Konfiguration – Tags](../tutorial/path-operation-configuration.md#tags){.internal-link target=_blank}.
 
-## Zusammenfassung und Beschreibung in der Dokumentation – OpenAPI
+## Zusammenfassung und Beschreibung in der Dokumentation – OpenAPI { #documentation-summary-and-description-openapi }
 
-Um Ihren *Pfadoperationen* eine Zusammenfassung und Beschreibung hinzuzufügen und diese in der Oberfläche der Dokumentation anzuzeigen, lesen Sie die Dokumentation unter [Tutorial – Pfadoperation-Konfiguration – Zusammenfassung und Beschreibung](../tutorial/path-operation-configuration.md#zusammenfassung-und-beschreibung){.internal-link target=_blank}.
+Um Ihren *Pfadoperationen* eine Zusammenfassung und Beschreibung hinzuzufügen und diese in der Oberfläche der Dokumentation anzuzeigen, lesen Sie die Dokumentation unter [Tutorial – Pfadoperation-Konfiguration – Zusammenfassung und Beschreibung](../tutorial/path-operation-configuration.md#summary-and-description){.internal-link target=_blank}.
 
-## Beschreibung der Response in der Dokumentation – OpenAPI
+## Beschreibung der Response in der Dokumentation – OpenAPI { #documentation-response-description-openapi }
 
-Um die Beschreibung der Response zu definieren, welche in der Oberfläche der Dokumentation angezeigt wird, lesen Sie die Dokumentation unter [Tutorial – Pfadoperation-Konfiguration – Beschreibung der Response](../tutorial/path-operation-configuration.md#beschreibung-der-response){.internal-link target=_blank}.
+Um die Beschreibung der Response zu definieren, welche in der Oberfläche der Dokumentation angezeigt wird, lesen Sie die Dokumentation unter [Tutorial – Pfadoperation-Konfiguration – Beschreibung der Response](../tutorial/path-operation-configuration.md#response-description){.internal-link target=_blank}.
 
-## *Pfadoperation* in der Dokumentation deprecaten – OpenAPI
+## *Pfadoperation* in der Dokumentation deprecaten – OpenAPI { #documentation-deprecate-a-path-operation-openapi }
 
-Um eine *Pfadoperation* zu deprecaten – sie als veraltet zu markieren – und das in der Oberfläche der Dokumentation anzuzeigen, lesen Sie die Dokumentation unter [Tutorial – Pfadoperation-Konfiguration – Deprecaten](../tutorial/path-operation-configuration.md#eine-pfadoperation-deprecaten){.internal-link target=_blank}.
+Um eine *Pfadoperation* zu <abbr title="veraltet, obsolet: Es soll nicht mehr verwendet werden">deprecaten</abbr> und das in der Oberfläche der Dokumentation anzuzeigen, lesen Sie die Dokumentation unter [Tutorial – Pfadoperation-Konfiguration – Deprecaten](../tutorial/path-operation-configuration.md#deprecate-a-path-operation){.internal-link target=_blank}.
 
-## Daten in etwas JSON-kompatibles konvertieren
+## Daten in etwas JSON-kompatibles konvertieren { #convert-any-data-to-json-compatible }
 
 Um Daten in etwas JSON-kompatibles zu konvertieren, lesen Sie die Dokumentation unter [Tutorial – JSON-kompatibler Encoder](../tutorial/encoder.md){.internal-link target=_blank}.
 
-## OpenAPI-Metadaten – Dokumentation
+## OpenAPI-Metadaten – Dokumentation { #openapi-metadata-docs }
 
-Um Metadaten zu Ihrem OpenAPI-Schema hinzuzufügen, einschließlich einer Lizenz, Version, Kontakt, usw., lesen Sie die Dokumentation unter [Tutorial – Metadaten und URLs der Dokumentationen](../tutorial/metadata.md){.internal-link target=_blank}.
+Um Metadaten zu Ihrem OpenAPI-Schema hinzuzufügen, einschließlich einer Lizenz, Version, Kontakt, usw., lesen Sie die Dokumentation unter [Tutorial – Metadaten und URLs der Dokumentation](../tutorial/metadata.md){.internal-link target=_blank}.
 
-## Benutzerdefinierte OpenAPI-URL
+## Benutzerdefinierte OpenAPI-URL { #openapi-custom-url }
 
-Um die OpenAPI-URL anzupassen (oder zu entfernen), lesen Sie die Dokumentation unter [Tutorial – Metadaten und URLs der Dokumentationen](../tutorial/metadata.md#openapi-url){.internal-link target=_blank}.
+Um die OpenAPI-URL anzupassen (oder zu entfernen), lesen Sie die Dokumentation unter [Tutorial – Metadaten und URLs der Dokumentation](../tutorial/metadata.md#openapi-url){.internal-link target=_blank}.
 
-## URLs der OpenAPI-Dokumentationen
+## URLs der OpenAPI-Dokumentationen { #openapi-docs-urls }
 
-Um die URLs zu aktualisieren, die für die automatisch generierten Dokumentations-Oberflächen verwendet werden, lesen Sie die Dokumentation unter [Tutorial – Metadaten und URLs der Dokumentationen](../tutorial/metadata.md#urls-der-dokumentationen){.internal-link target=_blank}.
+Um die URLs zu aktualisieren, die für die automatisch generierten Dokumentations-Oberflächen verwendet werden, lesen Sie die Dokumentation unter [Tutorial – Metadaten und URLs der Dokumentation](../tutorial/metadata.md#docs-urls){.internal-link target=_blank}.

docs/de/docs/how-to/graphql.md

@@ -1,4 +1,4 @@
-# GraphQL
+# GraphQL { #graphql }
 
 Da **FastAPI** auf dem **ASGI**-Standard basiert, ist es sehr einfach, jede **GraphQL**-Bibliothek zu integrieren, die auch mit ASGI kompatibel ist.
 
@@ -10,42 +10,42 @@ Sie können normale FastAPI-*Pfadoperationen* mit GraphQL in derselben Anwendung
 
 Es hat **Vorteile** und **Nachteile** im Vergleich zu gängigen **Web-APIs**.
 
-Wiegen Sie ab, ob die **Vorteile** für Ihren Anwendungsfall die **Nachteile** ausgleichen. 🤓
+Stellen Sie sicher, dass Sie prüfen, ob die **Vorteile** für Ihren Anwendungsfall die **Nachteile** ausgleichen. 🤓
 
 ///
 
-## GraphQL-Bibliotheken
+## GraphQL-Bibliotheken { #graphql-libraries }
 
-Hier sind einige der **GraphQL**-Bibliotheken, welche **ASGI** unterstützen. Diese könnten Sie mit **FastAPI** verwenden:
+Hier sind einige der **GraphQL**-Bibliotheken, die **ASGI**-Unterstützung haben. Sie könnten sie mit **FastAPI** verwenden:
 
 * <a href="https://strawberry.rocks/" class="external-link" target="_blank">Strawberry</a> 🍓
     * Mit <a href="https://strawberry.rocks/docs/integrations/fastapi" class="external-link" target="_blank">Dokumentation für FastAPI</a>
 * <a href="https://ariadnegraphql.org/" class="external-link" target="_blank">Ariadne</a>
     * Mit <a href="https://ariadnegraphql.org/docs/fastapi-integration" class="external-link" target="_blank">Dokumentation für FastAPI</a>
 * <a href="https://tartiflette.io/" class="external-link" target="_blank">Tartiflette</a>
-    * Mit <a href="https://tartiflette.github.io/tartiflette-asgi/" class="external-link" target="_blank">Tartiflette ASGI</a>, für ASGI-Integration
+    * Mit <a href="https://tartiflette.github.io/tartiflette-asgi/" class="external-link" target="_blank">Tartiflette ASGI</a> für ASGI-Integration
 * <a href="https://graphene-python.org/" class="external-link" target="_blank">Graphene</a>
     * Mit <a href="https://github.com/ciscorn/starlette-graphene3" class="external-link" target="_blank">starlette-graphene3</a>
 
-## GraphQL mit Strawberry
+## GraphQL mit Strawberry { #graphql-with-strawberry }
 
-Wenn Sie mit **GraphQL** arbeiten möchten oder müssen, ist <a href="https://strawberry.rocks/" class="external-link" target="_blank">**Strawberry**</a> die **empfohlene** Bibliothek, da deren Design dem Design von **FastAPI** am nächsten kommt und alles auf **Typannotationen** basiert.
+Wenn Sie mit **GraphQL** arbeiten möchten oder müssen, ist <a href="https://strawberry.rocks/" class="external-link" target="_blank">**Strawberry**</a> die **empfohlene** Bibliothek, da deren Design **FastAPIs** Design am nächsten kommt und alles auf **Typannotationen** basiert.
 
-Abhängig von Ihrem Anwendungsfall bevorzugen Sie vielleicht eine andere Bibliothek, aber wenn Sie mich fragen würden, würde ich Ihnen wahrscheinlich empfehlen, **Strawberry** auszuprobieren.
+Abhängig von Ihrem Anwendungsfall könnten Sie eine andere Bibliothek vorziehen, aber wenn Sie mich fragen würden, würde ich Ihnen wahrscheinlich empfehlen, **Strawberry** auszuprobieren.
 
 Hier ist eine kleine Vorschau, wie Sie Strawberry mit FastAPI integrieren können:
 
-{* ../../docs_src/graphql/tutorial001.py hl[3,22,25:26] *}
+{* ../../docs_src/graphql/tutorial001.py hl[3,22,25] *}
 
 Weitere Informationen zu Strawberry finden Sie in der <a href="https://strawberry.rocks/" class="external-link" target="_blank">Strawberry-Dokumentation</a>.
 
-Und auch die Dokumentation zu <a href="https://strawberry.rocks/docs/integrations/fastapi" class="external-link" target="_blank">Strawberry mit FastAPI</a>.
+Und auch in der Dokumentation zu <a href="https://strawberry.rocks/docs/integrations/fastapi" class="external-link" target="_blank">Strawberry mit FastAPI</a>.
 
-## Ältere `GraphQLApp` von Starlette
+## Ältere `GraphQLApp` von Starlette { #older-graphqlapp-from-starlette }
 
 Frühere Versionen von Starlette enthielten eine `GraphQLApp`-Klasse zur Integration mit <a href="https://graphene-python.org/" class="external-link" target="_blank">Graphene</a>.
 
-Das wurde von Starlette deprecated, aber wenn Sie Code haben, der das verwendet, können Sie einfach zu <a href="https://github.com/ciscorn/starlette-graphene3" class="external-link" target="_blank">starlette-graphene3</a> **migrieren**, welches denselben Anwendungsfall abdeckt und über eine **fast identische Schnittstelle** verfügt.
+Das wurde von Starlette <abbr title="veraltet, obsolet: Es soll nicht mehr verwendet werden">deprecatet</abbr>, aber wenn Sie Code haben, der das verwendet, können Sie einfach zu <a href="https://github.com/ciscorn/starlette-graphene3" class="external-link" target="_blank">starlette-graphene3</a> **migrieren**, das denselben Anwendungsfall abdeckt und eine **fast identische Schnittstelle** hat.
 
 /// tip | Tipp
 
@@ -53,7 +53,7 @@ Wenn Sie GraphQL benötigen, würde ich Ihnen trotzdem empfehlen, sich <a href="
 
 ///
 
-## Mehr darüber lernen
+## Mehr darüber lernen { #learn-more }
 
 Weitere Informationen zu **GraphQL** finden Sie in der <a href="https://graphql.org/" class="external-link" target="_blank">offiziellen GraphQL-Dokumentation</a>.
 

docs/de/docs/how-to/index.md

@@ -1,4 +1,4 @@
-# How-To – Rezepte
+# How-To – Rezepte { #how-to-recipes }
 
 Hier finden Sie verschiedene Rezepte und „How-To“-Anleitungen zu **verschiedenen Themen**.
 

docs/de/docs/how-to/separate-openapi-schemas.md

@@ -1,18 +1,18 @@
-# Separate OpenAPI-Schemas für Eingabe und Ausgabe oder nicht
+# Separate OpenAPI-Schemas für Eingabe und Ausgabe oder nicht { #separate-openapi-schemas-for-input-and-output-or-not }
 
 Bei Verwendung von **Pydantic v2** ist die generierte OpenAPI etwas genauer und **korrekter** als zuvor. 😎
 
-Tatsächlich gibt es in einigen Fällen sogar **zwei JSON-Schemas** in OpenAPI für dasselbe Pydantic-Modell für Eingabe und Ausgabe, je nachdem, ob sie **Defaultwerte** haben.
+Tatsächlich gibt es in einigen Fällen sogar **zwei JSON-Schemas** in OpenAPI für dasselbe Pydantic-Modell, für Eingabe und Ausgabe, je nachdem, ob sie **Defaultwerte** haben.
 
 Sehen wir uns an, wie das funktioniert und wie Sie es bei Bedarf ändern können.
 
-## Pydantic-Modelle für Eingabe und Ausgabe
+## Pydantic-Modelle für Eingabe und Ausgabe { #pydantic-models-for-input-and-output }
 
 Nehmen wir an, Sie haben ein Pydantic-Modell mit Defaultwerten wie dieses:
 
 {* ../../docs_src/separate_openapi_schemas/tutorial001_py310.py ln[1:7] hl[7] *}
 
-### Modell für Eingabe
+### Modell für Eingabe { #model-for-input }
 
 Wenn Sie dieses Modell wie hier als Eingabe verwenden:
 
@@ -20,7 +20,7 @@ Wenn Sie dieses Modell wie hier als Eingabe verwenden:
 
 ... dann ist das Feld `description` **nicht erforderlich**. Weil es den Defaultwert `None` hat.
 
-### Eingabemodell in der Dokumentation
+### Eingabemodell in der Dokumentation { #input-model-in-docs }
 
 Sie können überprüfen, dass das Feld `description` in der Dokumentation kein **rotes Sternchen** enthält, es ist nicht als erforderlich markiert:
 
@@ -28,17 +28,17 @@ Sie können überprüfen, dass das Feld `description` in der Dokumentation kein
 <img src="/img/tutorial/separate-openapi-schemas/image01.png">
 </div>
 
-### Modell für die Ausgabe
+### Modell für die Ausgabe { #model-for-output }
 
 Wenn Sie jedoch dasselbe Modell als Ausgabe verwenden, wie hier:
 
 {* ../../docs_src/separate_openapi_schemas/tutorial001_py310.py hl[19] *}
 
-... dann, weil  `description` einen Defaultwert hat, wird es, wenn Sie für dieses Feld **nichts zurückgeben**, immer noch diesen **Defaultwert** haben.
+... dann, weil `description` einen Defaultwert hat, wird es, wenn Sie für dieses Feld **nichts zurückgeben**, immer noch diesen **Defaultwert** haben.
 
-### Modell für Ausgabe-Responsedaten
+### Modell für Ausgabe-Responsedaten { #model-for-output-response-data }
 
-Wenn Sie mit der Dokumentation interagieren und die Response überprüfen, enthält die JSON-Response den Defaultwert (`null`), obwohl der Code nichts in eines der `description`-Felder geschrieben hat:
+Wenn Sie mit der Dokumentation interagieren und die <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> überprüfen, enthält die JSON-Response den Defaultwert (`null`), obwohl der Code nichts in eines der `description`-Felder geschrieben hat:
 
 <div class="screenshot">
 <img src="/img/tutorial/separate-openapi-schemas/image02.png">
@@ -55,7 +55,7 @@ Aus diesem Grund kann das JSON-Schema für ein Modell unterschiedlich sein, je n
 * für die **Eingabe** ist `description` **nicht erforderlich**
 * für die **Ausgabe** ist es **erforderlich** (und möglicherweise `None` oder, in JSON-Begriffen, `null`)
 
-### Ausgabemodell in der Dokumentation
+### Ausgabemodell in der Dokumentation { #model-for-output-in-docs }
 
 Sie können das Ausgabemodell auch in der Dokumentation überprüfen. **Sowohl** `name` **als auch** `description` sind mit einem **roten Sternchen** als **erforderlich** markiert:
 
@@ -63,7 +63,7 @@ Sie können das Ausgabemodell auch in der Dokumentation überprüfen. **Sowohl**
 <img src="/img/tutorial/separate-openapi-schemas/image03.png">
 </div>
 
-### Eingabe- und Ausgabemodell in der Dokumentation
+### Eingabe- und Ausgabemodell in der Dokumentation { #model-for-input-and-output-in-docs }
 
 Und wenn Sie alle verfügbaren Schemas (JSON-Schemas) in OpenAPI überprüfen, werden Sie feststellen, dass es zwei gibt, ein `Item-Input` und ein `Item-Output`.
 
@@ -77,7 +77,7 @@ Aber für `Item-Output` ist `description` **erforderlich**, es hat ein rotes Ste
 
 Mit dieser Funktion von **Pydantic v2** ist Ihre API-Dokumentation **präziser**, und wenn Sie über automatisch generierte Clients und SDKs verfügen, sind diese auch präziser, mit einer besseren **Entwicklererfahrung** und Konsistenz. 🎉
 
-## Schemas nicht trennen
+## Schemas nicht trennen { #do-not-separate-schemas }
 
 Nun gibt es einige Fälle, in denen Sie möglicherweise **dasselbe Schema für Eingabe und Ausgabe** haben möchten.
 
@@ -85,7 +85,7 @@ Der Hauptanwendungsfall hierfür besteht wahrscheinlich darin, dass Sie das mal
 
 In diesem Fall können Sie diese Funktion in **FastAPI** mit dem Parameter `separate_input_output_schemas=False` deaktivieren.
 
-/// info
+/// info | Info
 
 Unterstützung für `separate_input_output_schemas` wurde in FastAPI `0.102.0` hinzugefügt. 🤓
 
@@ -93,7 +93,7 @@ Unterstützung für `separate_input_output_schemas` wurde in FastAPI `0.102.0` h
 
 {* ../../docs_src/separate_openapi_schemas/tutorial002_py310.py hl[10] *}
 
-### Gleiches Schema für Eingabe- und Ausgabemodelle in der Dokumentation
+### Gleiches Schema für Eingabe- und Ausgabemodelle in der Dokumentation { #same-schema-for-input-and-output-models-in-docs }
 
 Und jetzt wird es ein einziges Schema für die Eingabe und Ausgabe des Modells geben, nur `Item`, und es wird `description` als **nicht erforderlich** kennzeichnen:
 

docs/de/docs/how-to/testing-database.md

@@ -0,0 +1,7 @@
+# Eine Datenbank testen { #testing-a-database }
+
+Sie können sich über Datenbanken, SQL und SQLModel in der <a href="https://sqlmodel.tiangolo.com/" class="external-link" target="_blank">SQLModel-Dokumentation</a> informieren. 🤓
+
+Es gibt ein kurzes <a href="https://sqlmodel.tiangolo.com/tutorial/fastapi/" class="external-link" target="_blank">Tutorial zur Verwendung von SQLModel mit FastAPI</a>. ✨
+
+Dieses Tutorial enthält einen Abschnitt über das <a href="https://sqlmodel.tiangolo.com/tutorial/fastapi/tests/" class="external-link" target="_blank">Testen von SQL-Datenbanken</a>. 😎

docs/de/docs/index.md

@@ -1,14 +1,14 @@
-# FastAPI
+# FastAPI { #fastapi }
 
 <style>
 .md-content .md-typeset h1 { display: none; }
 </style>
 
 <p align="center">
-  <a href="https://fastapi.tiangolo.com"><img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" alt="FastAPI"></a>
+  <a href="https://fastapi.tiangolo.com/de"><img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" alt="FastAPI"></a>
 </p>
 <p align="center">
-    <em>FastAPI Framework, hochperformant, leicht zu erlernen, schnell zu programmieren, einsatzbereit</em>
+    <em>FastAPI-Framework, hochperformant, leicht zu erlernen, schnell zu programmieren, einsatzbereit</em>
 </p>
 <p align="center">
 <a href="https://github.com/fastapi/fastapi/actions?query=workflow%3ATest+event%3Apush+branch%3Amaster" target="_blank">
@@ -27,7 +27,7 @@
 
 ---
 
-**Dokumentation**: <a href="https://fastapi.tiangolo.com" target="_blank">https://fastapi.tiangolo.com</a>
+**Dokumentation**: <a href="https://fastapi.tiangolo.com/de" target="_blank">https://fastapi.tiangolo.com/de</a>
 
 **Quellcode**: <a href="https://github.com/fastapi/fastapi" target="_blank">https://github.com/fastapi/fastapi</a>
 
@@ -37,8 +37,7 @@ FastAPI ist ein modernes, schnelles (hoch performantes) Webframework zur Erstell
 
 Seine Schlüssel-Merkmale sind:
 
-* **Schnell**: Sehr hohe Leistung, auf Augenhöhe mit **NodeJS** und **Go** (Dank Starlette und Pydantic). [Eines der schnellsten verfügbaren Python-Frameworks](#performanz).
-
+* **Schnell**: Sehr hohe Leistung, auf Augenhöhe mit **NodeJS** und **Go** (dank Starlette und Pydantic). [Eines der schnellsten verfügbaren Python-Frameworks](#performance).
 * **Schnell zu programmieren**: Erhöhen Sie die Geschwindigkeit bei der Entwicklung von Funktionen um etwa 200 % bis 300 %. *
 * **Weniger Bugs**: Verringern Sie die von Menschen (Entwicklern) verursachten Fehler um etwa 40 %. *
 * **Intuitiv**: Exzellente Editor-Unterstützung. <abbr title="auch bekannt als Autovervollständigung, Autocompletion, IntelliSense">Code-Vervollständigung</abbr> überall. Weniger Debuggen.
@@ -47,9 +46,9 @@ Seine Schlüssel-Merkmale sind:
 * **Robust**: Erhalten Sie produktionsreifen Code. Mit automatischer, interaktiver Dokumentation.
 * **Standards-basiert**: Basierend auf (und vollständig kompatibel mit) den offenen Standards für APIs: <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> (früher bekannt als Swagger) und <a href="https://json-schema.org/" class="external-link" target="_blank">JSON Schema</a>.
 
-<small>* Schätzung auf Basis von Tests in einem internen Entwicklungsteam, das Produktionsanwendungen erstellt.</small>
+<small>* Schätzung basierend auf Tests in einem internen Entwicklungsteam, das Produktionsanwendungen erstellt.</small>
 
-## Sponsoren
+## Sponsoren { #sponsors }
 
 <!-- sponsors -->
 
@@ -64,9 +63,9 @@ Seine Schlüssel-Merkmale sind:
 
 <!-- /sponsors -->
 
-<a href="https://fastapi.tiangolo.com/de/fastapi-people/#sponsoren" class="external-link" target="_blank">Andere Sponsoren</a>
+<a href="https://fastapi.tiangolo.com/de/fastapi-people/#sponsors" class="external-link" target="_blank">Andere Sponsoren</a>
 
-## Meinungen
+## Meinungen { #opinions }
 
 „_[...] Ich verwende **FastAPI** heutzutage sehr oft. [...] Ich habe tatsächlich vor, es für alle **ML-Dienste meines Teams bei Microsoft** zu verwenden. Einige davon werden in das Kernprodukt **Windows** und einige **Office**-Produkte integriert._“
 
@@ -74,7 +73,7 @@ Seine Schlüssel-Merkmale sind:
 
 ---
 
-„_Wir haben die **FastAPI**-Bibliothek genommen, um einen **REST**-Server zu erstellen, der abgefragt werden kann, um **Vorhersagen** zu erhalten. [für Ludwig]_“
+„_Wir haben die **FastAPI**-Bibliothek übernommen, um einen **REST**-Server zu erstellen, der für **Vorhersagen** abgefragt werden kann. [für Ludwig]_“
 
 <div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin, und Sai Sumanth Miryala - <strong>Uber</strong> <a href="https://eng.uber.com/ludwig-v0-2/" target="_blank"><small>(Ref)</small></a></div>
 
@@ -88,13 +87,13 @@ Seine Schlüssel-Merkmale sind:
 
 „_Ich bin überglücklich mit **FastAPI**. Es macht so viel Spaß!_“
 
-<div style="text-align: right; margin-right: 10%;">Brian Okken - <strong>Host des <a href="https://pythonbytes.fm/episodes/show/123/time-to-right-the-py-wrongs?time_in_sec=855" target="_blank">Python Bytes</a> Podcast</strong> <a href="https://twitter.com/brianokken/status/1112220079972728832" target="_blank"><small>(Ref)</small></a></div>
+<div style="text-align: right; margin-right: 10%;">Brian Okken - <strong><a href="https://pythonbytes.fm/episodes/show/123/time-to-right-the-py-wrongs?time_in_sec=855" target="_blank">Python Bytes</a> Podcast-Host</strong> <a href="https://twitter.com/brianokken/status/1112220079972728832" target="_blank"><small>(Ref)</small></a></div>
 
 ---
 
 „_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._“
 
-<div style="text-align: right; margin-right: 10%;">Timothy Crosley - <strong>Autor von <a href="https://github.com/hugapi/hug" target="_blank">Hug</a></strong> <a href="https://news.ycombinator.com/item?id=19455465" target="_blank"><small>(Ref)</small></a></div>
+<div style="text-align: right; margin-right: 10%;">Timothy Crosley - <strong><a href="https://github.com/hugapi/hug" target="_blank">Hug</a>-Autor</strong> <a href="https://news.ycombinator.com/item?id=19455465" target="_blank"><small>(Ref)</small></a></div>
 
 ---
 
@@ -102,7 +101,7 @@ Seine Schlüssel-Merkmale sind:
 
 „_Wir haben zu **FastAPI** für unsere **APIs** gewechselt [...] Ich denke, es wird Ihnen gefallen [...]_“
 
-<div style="text-align: right; margin-right: 10%;">Ines Montani - Matthew Honnibal - <strong>Gründer von <a href="https://explosion.ai" target="_blank">Explosion AI</a> - Autoren von <a href="https://spacy.io" target="_blank">spaCy</a></strong> <a href="https://twitter.com/_inesmontani/status/1144173225322143744" target="_blank"><small>(Ref)</small></a> - <a href="https://twitter.com/honnibal/status/1144031421859655680" target="_blank"><small>(Ref)</small></a></div>
+<div style="text-align: right; margin-right: 10%;">Ines Montani - Matthew Honnibal - <strong><a href="https://explosion.ai" target="_blank">Explosion AI</a>-Gründer - <a href="https://spacy.io" target="_blank">spaCy</a>-Autoren</strong> <a href="https://twitter.com/_inesmontani/status/1144173225322143744" target="_blank"><small>(Ref)</small></a> - <a href="https://twitter.com/honnibal/status/1144031421859655680" target="_blank"><small>(Ref)</small></a></div>
 
 ---
 
@@ -112,7 +111,7 @@ Seine Schlüssel-Merkmale sind:
 
 ---
 
-## **Typer**, das FastAPI der CLIs
+## **Typer**, das FastAPI der CLIs { #typer-the-fastapi-of-clis }
 
 <a href="https://typer.tiangolo.com" target="_blank"><img src="https://typer.tiangolo.com/img/logo-margin/logo-margin-vector.svg" style="width: 20%;"></a>
 
@@ -120,42 +119,34 @@ Wenn Sie eine <abbr title="Command Line Interface – Kommandozeilen-Schnittstel
 
 **Typer** ist die kleine Schwester von FastAPI. Und es soll das **FastAPI der CLIs** sein. ⌨️ 🚀
 
-## Anforderungen
+## Anforderungen { #requirements }
 
 FastAPI steht auf den Schultern von Giganten:
 
 * <a href="https://www.starlette.io/" class="external-link" target="_blank">Starlette</a> für die Webanteile.
-* <a href="https://pydantic-docs.helpmanual.io/" class="external-link" target="_blank">Pydantic</a> für die Datenanteile.
-
-## Installation
-
-<div class="termy">
-
-```console
-$ pip install fastapi
-
----> 100%
-```
+* <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> für die Datenanteile.
 
-</div>
+## Installation { #installation }
 
-Sie benötigen außerdem einen <abbr title="Asynchronous Server Gateway Interface – Asynchrone Server-Verbindungsschnittstelle">ASGI</abbr>-Server. Für die Produktumgebung beispielsweise <a href="https://www.uvicorn.org" class="external-link" target="_blank">Uvicorn</a> oder <a href="https://github.com/pgjones/hypercorn" class="external-link" target="_blank">Hypercorn</a>.
+Erstellen und aktivieren Sie eine <a href="https://fastapi.tiangolo.com/de/virtual-environments/" class="external-link" target="_blank">virtuelle Umgebung</a> und installieren Sie dann FastAPI:
 
 <div class="termy">
 
 ```console
-$ pip install "uvicorn[standard]"
+$ pip install "fastapi[standard]"
 
 ---> 100%
 ```
 
 </div>
 
-## Beispiel
+**Hinweis**: Stellen Sie sicher, dass Sie `"fastapi[standard]"` in Anführungszeichen setzen, damit es in allen Terminals funktioniert.
 
-### Erstellung
+## Beispiel { #example }
 
-* Erstellen Sie eine Datei `main.py` mit:
+### Erstellung { #create-it }
+
+Erstellen Sie eine Datei `main.py` mit dem folgenden Inhalt:
 
 ```Python
 from typing import Union
@@ -198,23 +189,37 @@ async def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 
-**Anmerkung**:
+**Hinweis**:
+
+Wenn Sie das nicht kennen, schauen Sie sich den Abschnitt _„In Eile?“_ über <a href="https://fastapi.tiangolo.com/de/async/#in-a-hurry" target="_blank">`async` und `await` in der Dokumentation</a> an.
 
-Wenn Sie das nicht kennen, schauen Sie sich den Abschnitt _„In Eile?“_ über <a href="https://fastapi.tiangolo.com/de/async/#in-eile" target="_blank">`async` und `await` in der Dokumentation</a> an.
 </details>
 
-### Starten
+### Starten { #run-it }
 
-Führen Sie den Server aus:
+Starten Sie den Server mit:
 
 <div class="termy">
 
 ```console
-$ uvicorn main:app --reload
-
+$ 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 [28720]
-INFO:     Started server process [28722]
+INFO:     Started reloader process [2248755] using WatchFiles
+INFO:     Started server process [2248757]
 INFO:     Waiting for application startup.
 INFO:     Application startup complete.
 ```
@@ -222,34 +227,34 @@ INFO:     Application startup complete.
 </div>
 
 <details markdown="1">
-<summary>Was macht der Befehl <code>uvicorn main:app --reload</code> ...</summary>
+<summary>Was der Befehl <code>fastapi dev main.py</code> macht ...</summary>
+
+Der Befehl `fastapi dev` liest Ihre `main.py`-Datei, erkennt die **FastAPI**-App darin und startet einen Server mit <a href="https://www.uvicorn.org" class="external-link" target="_blank">Uvicorn</a>.
 
-Der Befehl `uvicorn main:app` bezieht sich auf:
+Standardmäßig wird `fastapi dev` mit aktiviertem Auto-Reload für die lokale Entwicklung gestartet.
 
-* `main`: die Datei `main.py` (das Python-„Modul“).
-* `app`: das Objekt, das innerhalb von `main.py` mit der Zeile `app = FastAPI()` erzeugt wurde.
-* `--reload`: lässt den Server nach Codeänderungen neu starten. Tun Sie das nur während der Entwicklung.
+Sie können mehr darüber in der <a href="https://fastapi.tiangolo.com/de/fastapi-cli/" target="_blank">FastAPI CLI-Dokumentation</a> lesen.
 
 </details>
 
-### Testen
+### Es testen { #check-it }
 
 Öffnen Sie Ihren Browser unter <a href="http://127.0.0.1:8000/items/5?q=somequery" class="external-link" target="_blank">http://127.0.0.1:8000/items/5?q=somequery</a>.
 
-Sie erhalten die JSON-Response:
+Sie sehen die JSON-<abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> als:
 
 ```JSON
 {"item_id": 5, "q": "somequery"}
 ```
 
-Damit haben Sie bereits eine API erstellt, welche:
+Sie haben bereits eine API erstellt, welche:
 
-* HTTP-Anfragen auf den _Pfaden_ `/` und `/items/{item_id}` entgegennimmt.
+* HTTP-<abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Requests</abbr> auf den _Pfaden_ `/` und `/items/{item_id}` entgegennimmt.
 * Beide _Pfade_ erhalten `GET` <em>Operationen</em> (auch bekannt als HTTP _Methoden_).
-* Der _Pfad_ `/items/{item_id}` hat einen _Pfadparameter_ `item_id`, der ein `int` sein sollte.
-* Der _Pfad_ `/items/{item_id}` hat einen optionalen `str` _Query Parameter_ `q`.
+* 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
+### Interaktive API-Dokumentation { #interactive-api-docs }
 
 Gehen Sie nun auf <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 
@@ -257,17 +262,17 @@ Sie sehen die automatische interaktive API-Dokumentation (bereitgestellt von <a
 
 ![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)
 
-### Alternative API-Dokumentation
+### Alternative API-Dokumentation { #alternative-api-docs }
 
-Gehen Sie jetzt auf <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
+Und jetzt gehen Sie auf <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
 
 Sie sehen die alternative automatische Dokumentation (bereitgestellt von <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>):
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
 
-## Beispiel Aktualisierung
+## Beispiel Aktualisierung { #example-upgrade }
 
-Ändern Sie jetzt die Datei `main.py`, um den <abbr title="Body – Körper, Inhalt: Der eigentliche Inhalt einer Nachricht, nicht die Metadaten">Body</abbr> einer `PUT`-Anfrage zu empfangen.
+Ändern Sie jetzt die Datei `main.py`, um den <abbr title="Body – Körper, Inhalt: Der eigentliche Inhalt einer Nachricht, nicht die Metadaten">Body</abbr> eines `PUT`-Requests zu empfangen.
 
 Deklarieren Sie den Body mithilfe von Standard-Python-Typen, dank Pydantic.
 
@@ -301,9 +306,9 @@ def update_item(item_id: int, item: Item):
     return {"item_name": item.name, "item_id": item_id}
 ```
 
-Der Server sollte automatisch neu geladen werden (weil Sie oben `--reload` zum Befehl `uvicorn` hinzugefügt haben).
+Der `fastapi dev` Server sollte automatisch neu laden.
 
-### Aktualisierung der interaktiven API-Dokumentation
+### Aktualisierung der interaktiven API-Dokumentation { #interactive-api-docs-upgrade }
 
 Gehen Sie jetzt auf <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 
@@ -319,23 +324,23 @@ Gehen Sie jetzt auf <a href="http://127.0.0.1:8000/docs" class="external-link" t
 
 ![Swagger UI Interaktion](https://fastapi.tiangolo.com/img/index/index-05-swagger-04.png)
 
-### Aktualisierung der alternativen API-Dokumentation
+### Aktualisierung der alternativen API-Dokumentation { #alternative-api-docs-upgrade }
 
 Und nun gehen Sie auf <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
 
-* Die alternative Dokumentation wird ebenfalls den neuen Abfrageparameter und -inhalt widerspiegeln:
+* Die alternative Dokumentation wird ebenfalls den neuen Query-Parameter und Body widerspiegeln:
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)
 
-### Zusammenfassung
+### Zusammenfassung { #recap }
 
-Zusammengefasst deklarieren Sie **einmal** die Typen von Parametern, Body, etc. als Funktionsparameter.
+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+**.
+Nur Standard-**Python**.
 
 Zum Beispiel für ein `int`:
 
@@ -360,14 +365,14 @@ item: Item
 * <abbr title="auch bekannt als: Serialisierung, Parsen, Marshalling">Konvertierung</abbr> von Eingabedaten: Aus dem Netzwerk kommend, zu Python-Daten und -Typen. Lesen von:
     * JSON.
     * Pfad-Parametern.
-    * Abfrage-Parametern.
+    * Query-Parametern.
     * Cookies.
     * Header-Feldern.
     * Formularen.
     * Dateien.
 * <abbr title="auch bekannt als: Serialisierung, Parsen, Marshalling">Konvertierung</abbr> von Ausgabedaten: Konvertierung von Python-Daten und -Typen zu Netzwerkdaten (als JSON):
     * Konvertieren von Python-Typen (`str`, `int`, `float`, `bool`, `list`, usw.).
-    * `Datetime`-Objekte.
+    * `datetime`-Objekte.
     * `UUID`-Objekte.
     * Datenbankmodelle.
     * ... und viele mehr.
@@ -379,13 +384,13 @@ item: Item
 
 Um auf das vorherige Codebeispiel zurückzukommen, **FastAPI** wird:
 
-* Überprüfen, dass es eine `item_id` im Pfad für `GET`- und `PUT`-Anfragen gibt.
-* Überprüfen, ob die `item_id` vom Typ `int` für `GET`- und `PUT`-Anfragen ist.
+* Überprüfen, dass es eine `item_id` im Pfad für `GET`- und `PUT`-Requests gibt.
+* Überprüfen, ob die `item_id` vom Typ `int` für `GET`- und `PUT`-Requests ist.
     * Falls nicht, wird dem Client ein nützlicher, eindeutiger Fehler angezeigt.
-* Prüfen, ob es einen optionalen Abfrageparameter namens `q` (wie in `http://127.0.0.1:8000/items/foo?q=somequery`) für `GET`-Anfragen gibt.
+* 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`-Anfragen an `/items/{item_id}` den Body als JSON lesen:
+* 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.
@@ -422,9 +427,9 @@ Versuchen Sie, diese Zeile zu ändern:
 
 ![Editor Unterstützung](https://fastapi.tiangolo.com/img/vscode-completion.png)
 
-Für ein vollständigeres Beispiel, mit weiteren Funktionen, siehe das <a href="https://fastapi.tiangolo.com/tutorial/">Tutorial - Benutzerhandbuch</a>.
+Für ein vollständigeres Beispiel, mit weiteren Funktionen, siehe das <a href="https://fastapi.tiangolo.com/de/tutorial/">Tutorial – Benutzerhandbuch</a>.
 
-**Spoiler-Alarm**: Das Tutorial - Benutzerhandbuch enthält:
+**Spoiler-Alarm**: Das Tutorial – Benutzerhandbuch enthält:
 
 * Deklaration von **Parametern** von anderen verschiedenen Stellen wie: **Header-Felder**, **Cookies**, **Formularfelder** und **Dateien**.
 * Wie man **Validierungseinschränkungen** wie `maximum_length` oder `regex` setzt.
@@ -434,41 +439,63 @@ Für ein vollständigeres Beispiel, mit weiteren Funktionen, siehe das <a href="
 * **GraphQL** Integration mit <a href="https://strawberry.rocks" class="external-link" target="_blank">Strawberry</a> und anderen Bibliotheken.
 * Viele zusätzliche Funktionen (dank Starlette) wie:
     * **WebSockets**
-    * extrem einfache Tests auf Basis von `httpx` und `pytest`
+    * extrem einfache Tests auf Basis von HTTPX und `pytest`
     * **CORS**
     * **Cookie Sessions**
     * ... und mehr.
 
-## Performanz
+## Performanz { #performance }
+
+Unabhängige TechEmpower-Benchmarks zeigen **FastAPI**-Anwendungen, die unter Uvicorn laufen, als <a href="https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7" class="external-link" target="_blank">eines der schnellsten verfügbaren Python-Frameworks</a>, nur hinter Starlette und Uvicorn selbst (intern von FastAPI verwendet). (*)
+
+Um mehr darüber zu erfahren, siehe den Abschnitt <a href="https://fastapi.tiangolo.com/de/benchmarks/" class="internal-link" target="_blank">Benchmarks</a>.
 
-Unabhängige TechEmpower-Benchmarks zeigen **FastAPI**-Anwendungen, die unter Uvicorn laufen, als <a href="https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7" class="external-link" target="_blank">eines der schnellsten verfügbaren Python-Frameworks</a>, nur noch hinter Starlette und Uvicorn selbst (intern von FastAPI verwendet).
+## Abhängigkeiten { #dependencies }
 
-Um mehr darüber zu erfahren, siehe den Abschnitt <a href="https://fastapi.tiangolo.com/benchmarks/" class="internal-link" target="_blank">Benchmarks</a>.
+FastAPI hängt von Pydantic und Starlette ab.
 
-## Optionale Abhängigkeiten
+### `standard` Abhängigkeiten { #standard-dependencies }
+
+Wenn Sie FastAPI mit `pip install "fastapi[standard]"` installieren, kommt es mit der `standard` Gruppe von optionalen Abhängigkeiten:
 
 Wird von Pydantic verwendet:
 
 * <a href="https://github.com/JoshData/python-email-validator" target="_blank"><code>email-validator</code></a> - für E-Mail-Validierung.
-* <a href="https://docs.pydantic.dev/latest/usage/pydantic_settings/" target="_blank"><code>pydantic-settings</code></a> - für die Verwaltung von Einstellungen.
-* <a href="https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/" target="_blank"><code>pydantic-extra-types</code></a> - für zusätzliche Typen, mit Pydantic zu verwenden.
 
 Wird von Starlette verwendet:
 
 * <a href="https://www.python-httpx.org" target="_blank"><code>httpx</code></a> - erforderlich, wenn Sie den `TestClient` verwenden möchten.
 * <a href="https://jinja.palletsprojects.com" target="_blank"><code>jinja2</code></a> - erforderlich, wenn Sie die Standardkonfiguration für Templates verwenden möchten.
-* <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a> - erforderlich, wenn Sie Formulare mittels `request.form()` <abbr title="Konvertieren des Strings, der aus einer HTTP-Anfrage stammt, nach Python-Daten">„parsen“</abbr> möchten.
-* <a href="https://pythonhosted.org/itsdangerous/" target="_blank"><code>itsdangerous</code></a> - erforderlich für `SessionMiddleware` Unterstützung.
-* <a href="https://pyyaml.org/wiki/PyYAMLDocumentation" target="_blank"><code>pyyaml</code></a> - erforderlich für Starlette's `SchemaGenerator` Unterstützung (Sie brauchen das wahrscheinlich nicht mit FastAPI).
-* <a href="https://github.com/esnme/ultrajson" target="_blank"><code>ujson</code></a> - erforderlich, wenn Sie `UJSONResponse` verwenden möchten.
+* <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a> - erforderlich, wenn Sie Formulare mittels `request.form()` <abbr title="Konvertieren des Strings, der aus einem HTTP-Request stammt, nach Python-Daten">„parsen“</abbr> möchten.
 
-Wird von FastAPI / Starlette verwendet:
+Wird von FastAPI verwendet:
 
-* <a href="https://www.uvicorn.org" target="_blank"><code>uvicorn</code></a> - für den Server, der Ihre Anwendung lädt und serviert.
-* <a href="https://github.com/ijl/orjson" target="_blank"><code>orjson</code></a> - erforderlich, wenn Sie `ORJSONResponse` verwenden möchten.
+* <a href="https://www.uvicorn.org" target="_blank"><code>uvicorn</code></a> - für den Server, der Ihre Anwendung lädt und bereitstellt. Dies beinhaltet `uvicorn[standard]`, das einige Abhängigkeiten (z. B. `uvloop`) enthält, die für hoch performantes Bereitstellen 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 <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a> 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.
 
-Sie können diese alle mit `pip install "fastapi[all]"` 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:
+
+* <a href="https://docs.pydantic.dev/latest/usage/pydantic_settings/" target="_blank"><code>pydantic-settings</code></a> - für die Verwaltung von Einstellungen.
+* <a href="https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/" target="_blank"><code>pydantic-extra-types</code></a> - für zusätzliche Typen, die mit Pydantic verwendet werden sollen.
+
+Zusätzliche optionale FastAPI-Abhängigkeiten:
+
+* <a href="https://github.com/ijl/orjson" target="_blank"><code>orjson</code></a> - erforderlich, wenn Sie `ORJSONResponse` verwenden möchten.
+* <a href="https://github.com/esnme/ultrajson" target="_blank"><code>ujson</code></a> - erforderlich, wenn Sie `UJSONResponse` verwenden möchten.
 
-## Lizenz
+## Lizenz { #license }
 
 Dieses Projekt ist unter den Bedingungen der MIT-Lizenz lizenziert.

docs/de/docs/learn/index.md

@@ -1,5 +1,5 @@
-# Lernen
+# Lernen { #learn }
 
-Hier finden Sie die einführenden Kapitel und Tutorials zum Erlernen von **FastAPI**.
+Hier sind die einführenden Abschnitte und Tutorials, um **FastAPI** zu lernen.
 
 Sie könnten dies als **Buch**, als **Kurs**, als **offizielle** und empfohlene Methode zum Erlernen von FastAPI betrachten. 😎

docs/de/docs/project-generation.md

@@ -1,84 +1,28 @@
-# Projektgenerierung – Vorlage
-
-Sie können einen Projektgenerator für den Einstieg verwenden, welcher einen Großteil der Ersteinrichtung, Sicherheit, Datenbank und einige API-Endpunkte bereits für Sie erstellt.
-
-Ein Projektgenerator verfügt immer über ein sehr spezifisches Setup, das Sie aktualisieren und an Ihre eigenen Bedürfnisse anpassen sollten, aber es könnte ein guter Ausgangspunkt für Ihr Projekt sein.
-
-## Full Stack FastAPI PostgreSQL
-
-GitHub: <a href="https://github.com/tiangolo/full-stack-fastapi-postgresql" class="external-link" target="_blank">https://github.com/tiangolo/full-stack-fastapi-postgresql</a>
-
-### Full Stack FastAPI PostgreSQL – Funktionen
-
-* Vollständige **Docker**-Integration (Docker-basiert).
-* Docker-Schwarmmodus-Deployment.
-* **Docker Compose**-Integration und Optimierung für die lokale Entwicklung.
-* **Produktionsbereit** Python-Webserver, verwendet Uvicorn und Gunicorn.
-* Python <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">**FastAPI**</a>-Backend:
-    * **Schnell**: Sehr hohe Leistung, auf Augenhöhe mit **NodeJS** und **Go** (dank Starlette und Pydantic).
-    * **Intuitiv**: Hervorragende Editor-Unterstützung. <abbr title="Auch bekannt als automatische Vervollständigung, IntelliSense">Codevervollständigung</abbr> überall. Weniger Zeitaufwand für das Debuggen.
-    * **Einfach**: Einfach zu bedienen und zu erlernen. Weniger Zeit für das Lesen von Dokumentationen.
-    * **Kurz**: Codeverdoppelung minimieren. Mehrere Funktionalitäten aus jeder Parameterdeklaration.
-    * **Robust**: Erhalten Sie produktionsbereiten Code. Mit automatischer, interaktiver Dokumentation.
-    * **Standards-basiert**: Basierend auf (und vollständig kompatibel mit) den offenen Standards für APIs: <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> und <a href="https://json-schema.org/" class="external-link" target="_blank">JSON Schema</a>.
-    * <a href="https://fastapi.tiangolo.com/features/" class="external-link" target="_blank">**Viele weitere Funktionen**</a>, einschließlich automatischer Validierung, Serialisierung, interaktiver Dokumentation, Authentifizierung mit OAuth2-JWT-Tokens, usw.
-* **Sicheres Passwort**-Hashing standardmäßig.
-* **JWT-Token**-Authentifizierung.
-* **SQLAlchemy**-Modelle (unabhängig von Flask-Erweiterungen, sodass sie direkt mit Celery-Workern verwendet werden können).
-* Grundlegende Startmodelle für Benutzer (ändern und entfernen Sie nach Bedarf).
-* **Alembic**-Migrationen.
-* **CORS** (Cross Origin Resource Sharing).
-* **Celery**-Worker, welche Modelle und Code aus dem Rest des Backends selektiv importieren und verwenden können.
-* REST-Backend-Tests basierend auf **Pytest**, integriert in Docker, sodass Sie die vollständige API-Interaktion unabhängig von der Datenbank testen können. Da es in Docker ausgeführt wird, kann jedes Mal ein neuer Datenspeicher von Grund auf erstellt werden (Sie können also ElasticSearch, MongoDB, CouchDB oder was auch immer Sie möchten verwenden und einfach testen, ob die API funktioniert).
-* Einfache Python-Integration mit **Jupyter-Kerneln** für Remote- oder In-Docker-Entwicklung mit Erweiterungen wie Atom Hydrogen oder Visual Studio Code Jupyter.
-* **Vue**-Frontend:
-    * Mit Vue CLI generiert.
-    * Handhabung der **JWT-Authentifizierung**.
-    * Login-View.
-    * Nach der Anmeldung Hauptansicht des Dashboards.
-    * Haupt-Dashboard mit Benutzererstellung und -bearbeitung.
-    * Bearbeitung des eigenen Benutzers.
-    * **Vuex**.
-    * **Vue-Router**.
-    * **Vuetify** für schöne Material-Designkomponenten.
-    * **TypeScript**.
-    * Docker-Server basierend auf **Nginx** (konfiguriert, um gut mit Vue-Router zu funktionieren).
-    * Mehrstufigen Docker-Erstellung, sodass Sie kompilierten Code nicht speichern oder committen müssen.
-    * Frontend-Tests, welche zur Erstellungszeit ausgeführt werden (können auch deaktiviert werden).
-    * So modular wie möglich gestaltet, sodass es sofort einsatzbereit ist. Sie können es aber mit Vue CLI neu generieren oder es so wie Sie möchten erstellen und wiederverwenden, was Sie möchten.
-* **PGAdmin** für die PostgreSQL-Datenbank, können Sie problemlos ändern, sodass PHPMyAdmin und MySQL verwendet wird.
-* **Flower** für die Überwachung von Celery-Jobs.
-* Load Balancing zwischen Frontend und Backend mit **Traefik**, sodass Sie beide unter derselben Domain haben können, getrennt durch den Pfad, aber von unterschiedlichen Containern ausgeliefert.
-* Traefik-Integration, einschließlich automatischer Generierung von Let's Encrypt-**HTTPS**-Zertifikaten.
-* GitLab **CI** (kontinuierliche Integration), einschließlich Frontend- und Backend-Testen.
-
-## Full Stack FastAPI Couchbase
-
-GitHub: <a href="https://github.com/tiangolo/full-stack-fastapi-couchbase" class="external-link" target="_blank">https://github.com/tiangolo/full-stack-fastapi-couchbase</a>
-
-⚠️ **WARNUNG** ⚠️
-
-Wenn Sie ein neues Projekt von Grund auf starten, prüfen Sie die Alternativen hier.
-
-Zum Beispiel könnte der Projektgenerator <a href="https://github.com/tiangolo/full-stack-fastapi-postgresql" class="external-link" target="_blank">Full Stack FastAPI PostgreSQL</a> eine bessere Alternative sein, da er aktiv gepflegt und genutzt wird. Und er enthält alle neuen Funktionen und Verbesserungen.
-
-Es steht Ihnen weiterhin frei, den Couchbase-basierten Generator zu verwenden, wenn Sie möchten. Er sollte wahrscheinlich immer noch gut funktionieren, und wenn Sie bereits ein Projekt damit erstellt haben, ist das auch in Ordnung (und Sie haben es wahrscheinlich bereits an Ihre Bedürfnisse angepasst).
-
-Weitere Informationen hierzu finden Sie in der Dokumentation des Repos.
-
-## Full Stack FastAPI MongoDB
-
-... könnte später kommen, abhängig von meiner verfügbaren Zeit und anderen Faktoren. 😅 🎉
-
-## Modelle für maschinelles Lernen mit spaCy und FastAPI
-
-GitHub: <a href="https://github.com/microsoft/cookiecutter-spacy-fastapi" class="external-link" target="_blank">https://github.com/microsoft/cookiecutter-spacy-fastapi</a>
-
-### Modelle für maschinelles Lernen mit spaCy und FastAPI – Funktionen
-
-* **spaCy** NER-Modellintegration.
-* **Azure Cognitive Search**-Anforderungsformat integriert.
-* **Produktionsbereit** Python-Webserver, verwendet Uvicorn und Gunicorn.
-* **Azure DevOps** Kubernetes (AKS) CI/CD-Deployment integriert.
-* **Mehrsprachig** Wählen Sie bei der Projekteinrichtung ganz einfach eine der integrierten Sprachen von spaCy aus.
-* **Einfach erweiterbar** auf andere Modellframeworks (Pytorch, Tensorflow), nicht nur auf SpaCy.
+# Full Stack FastAPI Template { #full-stack-fastapi-template }
+
+Vorlagen, die normalerweise mit einem bestimmten Setup geliefert werden, sind so konzipiert, dass sie flexibel und anpassbar sind. Dies ermöglicht es Ihnen, sie zu ändern und an die Anforderungen Ihres Projekts anzupassen und sie somit zu einem hervorragenden Ausgangspunkt zu machen. 🏁
+
+Sie können diese Vorlage verwenden, um loszulegen, da sie bereits vieles der anfänglichen Einrichtung, Sicherheit, Datenbank und einige API-Endpunkte für Sie eingerichtet hat.
+
+GitHub-Repository: <a href="https://github.com/tiangolo/full-stack-fastapi-template" class="external-link" target="_blank">Full Stack FastAPI Template</a>
+
+## Full Stack FastAPI Template – Technologiestack und Funktionen { #full-stack-fastapi-template-technology-stack-and-features }
+
+- ⚡ [**FastAPI**](https://fastapi.tiangolo.com/de) für die Python-Backend-API.
+    - 🧰 [SQLModel](https://sqlmodel.tiangolo.com) für die Interaktion mit der Python-SQL-Datenbank (ORM).
+    - 🔍 [Pydantic](https://docs.pydantic.dev), verwendet von FastAPI, für die Datenvalidierung und das Einstellungsmanagement.
+    - 💾 [PostgreSQL](https://www.postgresql.org) als SQL-Datenbank.
+- 🚀 [React](https://react.dev) für das Frontend.
+    - 💃 Verwendung von TypeScript, Hooks, [Vite](https://vitejs.dev) und anderen Teilen eines modernen Frontend-Stacks.
+    - 🎨 [Chakra UI](https://chakra-ui.com) für die Frontend-Komponenten.
+    - 🤖 Ein automatisch generierter Frontend-Client.
+    - 🧪 [Playwright](https://playwright.dev) für End-to-End-Tests.
+    - 🦇 Unterstützung des Dunkelmodus.
+- 🐋 [Docker Compose](https://www.docker.com) für Entwicklung und Produktion.
+- 🔒 Sicheres Passwort-Hashing standardmäßig.
+- 🔑 JWT-Token-Authentifizierung.
+- 📫 E-Mail-basierte Passwortwiederherstellung.
+- ✅ Tests mit [Pytest](https://pytest.org).
+- 📞 [Traefik](https://traefik.io) als Reverse-Proxy / Load Balancer.
+- 🚢 Deployment-Anleitungen unter Verwendung von Docker Compose, einschließlich der Einrichtung eines Frontend-Traefik-Proxys zur Handhabung automatischer HTTPS-Zertifikate.
+- 🏭 CI (kontinuierliche Integration) und CD (kontinuierliche Bereitstellung) basierend auf GitHub Actions.

docs/de/docs/python-types.md

@@ -1,8 +1,8 @@
-# Einführung in Python-Typen
+# Einführung in Python-Typen { #python-types-intro }
 
-Python hat Unterstützung für optionale „Typhinweise“ (Englisch: „Type Hints“). Auch „Typ Annotationen“ genannt.
+Python hat Unterstützung für optionale <abbr title="englisch: Type hints">„Typhinweise“</abbr> (auch <abbr title="englisch: Type annotations">„Typannotationen“</abbr> genannt).
 
-Diese **„Typhinweise“** oder -Annotationen sind eine spezielle Syntax, die es erlaubt, den <abbr title="Zum Beispiel: str, int, float, bool">Typ</abbr> einer Variablen zu deklarieren.
+Diese **„Typhinweise“** oder -annotationen sind eine spezielle Syntax, die es erlaubt, den <abbr title="zum Beispiel: str, int, float, bool">Typ</abbr> einer Variablen zu deklarieren.
 
 Durch das Deklarieren von Typen für Ihre Variablen können Editoren und Tools bessere Unterstützung bieten.
 
@@ -18,7 +18,7 @@ Wenn Sie ein Python-Experte sind und bereits alles über Typhinweise wissen, üb
 
 ///
 
-## Motivation
+## Motivation { #motivation }
 
 Fangen wir mit einem einfachen Beispiel an:
 
@@ -38,7 +38,7 @@ Die Funktion macht Folgendes:
 
 {* ../../docs_src/python_types/tutorial001.py hl[2] *}
 
-### Bearbeiten Sie es
+### Es bearbeiten { #edit-it }
 
 Es ist ein sehr einfaches Programm.
 
@@ -58,7 +58,7 @@ Aber leider erhalten Sie nichts Nützliches:
 
 <img src="/img/python-types/image01.png">
 
-### Typen hinzufügen
+### Typen hinzufügen { #add-types }
 
 Lassen Sie uns eine einzelne Zeile aus der vorherigen Version ändern.
 
@@ -102,7 +102,7 @@ Hier können Sie durch die Optionen blättern, bis Sie diejenige finden, bei der
 
 <img src="/img/python-types/image03.png">
 
-## Mehr Motivation
+## Mehr Motivation { #more-motivation }
 
 Sehen Sie sich diese Funktion an, sie hat bereits Typhinweise:
 
@@ -116,13 +116,13 @@ Jetzt, da Sie wissen, dass Sie das reparieren müssen, konvertieren Sie `age` mi
 
 {* ../../docs_src/python_types/tutorial004.py hl[2] *}
 
-## Deklarieren von Typen
+## Deklarieren von Typen { #declaring-types }
 
 Sie haben gerade den Haupt-Einsatzort für die Deklaration von Typhinweisen gesehen. Als Funktionsparameter.
 
 Das ist auch meistens, wie sie in **FastAPI** verwendet werden.
 
-### Einfache Typen
+### Einfache Typen { #simple-types }
 
 Sie können alle Standard-Python-Typen deklarieren, nicht nur `str`.
 
@@ -135,7 +135,7 @@ Zum Beispiel diese:
 
 {* ../../docs_src/python_types/tutorial005.py hl[1] *}
 
-### Generische Typen mit Typ-Parametern
+### Generische Typen mit Typ-Parametern { #generic-types-with-type-parameters }
 
 Es gibt Datenstrukturen, die andere Werte enthalten können, wie etwa `dict`, `list`, `set` und `tuple`. Die inneren Werte können auch ihren eigenen Typ haben.
 
@@ -143,7 +143,7 @@ Diese Typen mit inneren Typen werden „**generische**“ Typen genannt. Es ist
 
 Um diese Typen und die inneren Typen zu deklarieren, können Sie Pythons Standardmodul `typing` verwenden. Es existiert speziell für die Unterstützung dieser Typhinweise.
 
-#### Neuere Python-Versionen
+#### Neuere Python-Versionen { #newer-versions-of-python }
 
 Die Syntax, welche `typing` verwendet, ist **kompatibel** mit allen Versionen, von Python 3.6 aufwärts zu den neuesten, inklusive Python 3.9, Python 3.10, usw.
 
@@ -157,7 +157,7 @@ Zum Beispiel bedeutet „**Python 3.6+**“, dass das Beispiel kompatibel mit Py
 
 Wenn Sie über die **neueste Version von Python** verfügen, verwenden Sie die Beispiele für die neueste Version, diese werden die **beste und einfachste Syntax** haben, zum Beispiel, „**Python 3.10+**“.
 
-#### Liste
+#### Liste { #list }
 
 Definieren wir zum Beispiel eine Variable, die eine `list` von `str` – eine Liste von Strings – sein soll.
 
@@ -195,7 +195,7 @@ Da die Liste ein Typ ist, welcher innere Typen enthält, werden diese von eckige
 
 ////
 
-/// tip | Tipp
+/// info | Info
 
 Die inneren Typen in den eckigen Klammern werden als „Typ-Parameter“ bezeichnet.
 
@@ -221,7 +221,7 @@ Beachten Sie, dass die Variable `item` eines der Elemente in der Liste `items` i
 
 Und trotzdem weiß der Editor, dass es sich um ein `str` handelt, und bietet entsprechende Unterstützung.
 
-#### Tupel und Menge
+#### Tupel und Menge { #tuple-and-set }
 
 Das Gleiche gilt für die Deklaration eines Tupels – `tuple` – und einer Menge – `set`:
 
@@ -246,7 +246,7 @@ Das bedeutet:
 * Die Variable `items_t` ist ein `tuple` mit 3 Elementen, einem `int`, einem weiteren `int` und einem `str`.
 * Die Variable `items_s` ist ein `set`, und jedes seiner Elemente ist vom Typ `bytes`.
 
-#### Dict
+#### Dict { #dict }
 
 Um ein `dict` zu definieren, übergeben Sie zwei Typ-Parameter, getrennt durch Kommas.
 
@@ -276,7 +276,7 @@ Das bedeutet:
     * Die Schlüssel dieses `dict` sind vom Typ `str` (z. B. die Namen der einzelnen Artikel).
     * Die Werte dieses `dict` sind vom Typ `float` (z. B. der Preis jedes Artikels).
 
-#### <abbr title="Union – Verbund, Einheit‚ Vereinigung: Eines von Mehreren">Union</abbr>
+#### <abbr title="Union – Verbund, Einheit‚ Vereinigung: Eines von Mehreren">Union</abbr> { #union }
 
 Sie können deklarieren, dass eine Variable einer von **verschiedenen Typen** sein kann, zum Beispiel ein `int` oder ein `str`.
 
@@ -302,13 +302,15 @@ In Python 3.10 gibt es zusätzlich eine **neue Syntax**, die es erlaubt, die mö
 
 In beiden Fällen bedeutet das, dass `item` ein `int` oder ein `str` sein kann.
 
-#### Vielleicht `None`
+#### Vielleicht `None` { #possibly-none }
 
 Sie können deklarieren, dass ein Wert ein `str`, aber vielleicht auch `None` sein kann.
 
 In Python 3.6 und darüber (inklusive Python 3.10) können Sie das deklarieren, indem Sie `Optional` vom `typing` Modul importieren und verwenden.
 
-{* ../../docs_src/python_types/tutorial009.py hl[1,4] *}
+```Python hl_lines="1  4"
+{!../../docs_src/python_types/tutorial009.py!}
+```
 
 Wenn Sie `Optional[str]` anstelle von nur `str` verwenden, wird Ihr Editor Ihnen dabei helfen, Fehler zu erkennen, bei denen Sie annehmen könnten, dass ein Wert immer eine String (`str`) ist, obwohl er auch `None` sein könnte.
 
@@ -340,7 +342,7 @@ Das bedeutet auch, dass Sie in Python 3.10 `Something | None` verwenden können:
 
 ////
 
-#### `Union` oder `Optional` verwenden?
+#### `Union` oder `Optional` verwenden? { #using-union-or-optional }
 
 Wenn Sie eine Python-Version unterhalb 3.10 verwenden, hier ist mein sehr **subjektiver** Standpunkt dazu:
 
@@ -366,7 +368,7 @@ say_hi()  # Oh, nein, das löst einen Fehler aus! 😱
 Der `name` Parameter wird **immer noch benötigt** (nicht *optional*), weil er keinen Default-Wert hat. `name` akzeptiert aber dennoch `None` als Wert:
 
 ```Python
-say_hi(name=None)  # Das funktioniert, None is gültig 🎉
+say_hi(name=None)  # Das funktioniert, None ist gültig 🎉
 ```
 
 Die gute Nachricht ist, dass Sie sich darüber keine Sorgen mehr machen müssen, wenn Sie Python 3.10 verwenden, da Sie einfach `|` verwenden können, um Vereinigungen von Typen zu definieren:
@@ -375,7 +377,7 @@ Die gute Nachricht ist, dass Sie sich darüber keine Sorgen mehr machen müssen,
 
 Und dann müssen Sie sich nicht mehr um Namen wie `Optional` und `Union` kümmern. 😎
 
-#### Generische Typen
+#### Generische Typen { #generic-types }
 
 Diese Typen, die Typ-Parameter in eckigen Klammern akzeptieren, werden **generische Typen** oder **Generics** genannt.
 
@@ -427,7 +429,7 @@ Verwenden Sie für den Rest, wie unter Python 3.8, das `typing`-Modul:
 
 ////
 
-### Klassen als Typen
+### Klassen als Typen { #classes-as-types }
 
 Sie können auch eine Klasse als Typ einer Variablen deklarieren.
 
@@ -447,9 +449,9 @@ Beachten Sie, das bedeutet: „`one_person` ist eine **Instanz** der Klasse `Per
 
 Es bedeutet nicht: „`one_person` ist die **Klasse** genannt `Person`“.
 
-## Pydantic Modelle
+## Pydantic-Modelle { #pydantic-models }
 
-<a href="https://pydantic-docs.helpmanual.io/" class="external-link" target="_blank">Pydantic</a> ist eine Python-Bibliothek für die Validierung von Daten.
+<a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> ist eine Python-Bibliothek für die Validierung von Daten.
 
 Sie deklarieren die „Form“ der Daten als Klassen mit Attributen.
 
@@ -485,25 +487,25 @@ Ein Beispiel aus der offiziellen Pydantic Dokumentation:
 
 ////
 
-/// info
+/// info | Info
 
-Um mehr über <a href="https://pydantic-docs.helpmanual.io/" class="external-link" target="_blank">Pydantic zu erfahren, schauen Sie sich dessen Dokumentation an</a>.
+Um mehr über <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic zu erfahren, schauen Sie sich dessen Dokumentation an</a>.
 
 ///
 
 **FastAPI** basiert vollständig auf Pydantic.
 
-Viel mehr von all dem werden Sie in praktischer Anwendung im [Tutorial - Benutzerhandbuch](tutorial/index.md){.internal-link target=_blank} sehen.
+Viel mehr von all dem werden Sie in praktischer Anwendung im [Tutorial – Benutzerhandbuch](tutorial/index.md){.internal-link target=_blank} sehen.
 
 /// tip | Tipp
 
-Pydantic verhält sich speziell, wenn Sie `Optional` oder `Union[Etwas, None]` ohne einen Default-Wert verwenden. Sie können darüber in der Pydantic Dokumentation unter <a href="https://docs.pydantic.dev/2.3/usage/models/#required-fields" class="external-link" target="_blank">Required fields</a> mehr erfahren.
+Pydantic verhält sich speziell, wenn Sie `Optional` oder `Union[Something, None]` ohne einen Defaultwert verwenden. Sie können darüber in der Pydantic Dokumentation unter <a href="https://docs.pydantic.dev/2.3/usage/models/#required-fields" class="external-link" target="_blank">Erforderliche optionale Felder</a> mehr erfahren.
 
 ///
 
-## Typhinweise mit Metadaten-Annotationen
+## Typhinweise mit Metadaten-Annotationen { #type-hints-with-metadata-annotations }
 
-Python bietet auch die Möglichkeit, **zusätzliche Metadaten** in Typhinweisen unterzubringen, mittels `Annotated`.
+Python bietet auch die Möglichkeit, **zusätzliche <abbr title="Daten über die Daten, in diesem Fall Informationen über den Typ, z. B. eine Beschreibung.">Metadaten</abbr>** in Typhinweisen unterzubringen, mittels `Annotated`.
 
 //// tab | Python 3.9+
 
@@ -545,7 +547,7 @@ Und ebenfalls, dass Ihr Code sehr kompatibel mit vielen anderen Python-Tools und
 
 ///
 
-## Typhinweise in **FastAPI**
+## Typhinweise in **FastAPI** { #type-hints-in-fastapi }
 
 **FastAPI** macht sich diese Typhinweise zunutze, um mehrere Dinge zu tun.
 
@@ -556,18 +558,18 @@ Mit **FastAPI** deklarieren Sie Parameter mit Typhinweisen, und Sie erhalten:
 
 ... und **FastAPI** verwendet dieselben Deklarationen, um:
 
-* **Anforderungen** zu definieren: aus Anfrage-Pfadparametern, Abfrageparametern, Header-Feldern, Bodys, Abhängigkeiten, usw.
-* **Daten umzuwandeln**: aus der Anfrage in den erforderlichen Typ.
-* **Daten zu validieren**: aus jeder Anfrage:
+* **Anforderungen** zu definieren: aus <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr>-Pfadparametern, Query-Parametern, Header-Feldern, Bodys, Abhängigkeiten, usw.
+* **Daten umzuwandeln**: aus dem Request in den erforderlichen Typ.
+* **Daten zu validieren**: aus jedem Request:
     * **Automatische Fehler** generieren, die an den Client zurückgegeben werden, wenn die Daten ungültig sind.
 * Die API mit OpenAPI zu **dokumentieren**:
     * Die dann von den Benutzeroberflächen der automatisch generierten interaktiven Dokumentation verwendet wird.
 
-Das mag alles abstrakt klingen. Machen Sie sich keine Sorgen. Sie werden all das in Aktion sehen im [Tutorial - Benutzerhandbuch](tutorial/index.md){.internal-link target=_blank}.
+Das mag alles abstrakt klingen. Machen Sie sich keine Sorgen. Sie werden all das in Aktion sehen im [Tutorial – Benutzerhandbuch](tutorial/index.md){.internal-link target=_blank}.
 
 Das Wichtigste ist, dass **FastAPI** durch die Verwendung von Standard-Python-Typen an einer einzigen Stelle (anstatt weitere Klassen, Dekoratoren usw. hinzuzufügen) einen Großteil der Arbeit für Sie erledigt.
 
-/// info
+/// info | Info
 
 Wenn Sie bereits das ganze Tutorial durchgearbeitet haben und mehr über Typen erfahren wollen, dann ist eine gute Ressource <a href="https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html" class="external-link" target="_blank">der „Cheat Sheet“ von `mypy`</a>.
 

docs/de/docs/resources/index.md

@@ -1,3 +1,3 @@
-# Ressourcen
+# Ressourcen { #resources }
 
 Zusätzliche Ressourcen, externe Links, Artikel und mehr. ✈️

docs/de/docs/tutorial/background-tasks.md

@@ -1,8 +1,8 @@
-# Hintergrundtasks
+# Hintergrundtasks { #background-tasks }
 
-Sie können Hintergrundtasks (Hintergrund-Aufgaben) definieren, die *nach* der Rückgabe einer Response ausgeführt werden sollen.
+Sie können <abbr title="Hintergrund-Aufgaben">Hintergrundtasks</abbr> definieren, die *nach* der Rückgabe einer <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> ausgeführt werden sollen.
 
-Das ist nützlich für Vorgänge, die nach einem Request ausgeführt werden müssen, bei denen der Client jedoch nicht unbedingt auf den Abschluss des Vorgangs warten muss, bevor er die Response erhält.
+Das ist nützlich für Vorgänge, die nach einem <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> ausgeführt werden müssen, bei denen der Client jedoch nicht unbedingt auf den Abschluss des Vorgangs warten muss, bevor er die Response erhält.
 
 Hierzu zählen beispielsweise:
 
@@ -11,7 +11,7 @@ Hierzu zählen beispielsweise:
 * Daten verarbeiten:
     * Angenommen, Sie erhalten eine Datei, die einen langsamen Prozess durchlaufen muss. Sie können als Response „Accepted“ (HTTP 202) zurückgeben und die Datei im Hintergrund verarbeiten.
 
-## `BackgroundTasks` verwenden
+## `BackgroundTasks` verwenden { #using-backgroundtasks }
 
 Importieren Sie zunächst `BackgroundTasks` und definieren Sie einen Parameter in Ihrer *Pfadoperation-Funktion* mit der Typdeklaration `BackgroundTasks`:
 
@@ -19,7 +19,7 @@ Importieren Sie zunächst `BackgroundTasks` und definieren Sie einen Parameter i
 
 **FastAPI** erstellt für Sie das Objekt vom Typ `BackgroundTasks` und übergibt es als diesen Parameter.
 
-## Eine Taskfunktion erstellen
+## Eine Taskfunktion erstellen { #create-a-task-function }
 
 Erstellen Sie eine Funktion, die als Hintergrundtask ausgeführt werden soll.
 
@@ -33,7 +33,7 @@ Und da der Schreibvorgang nicht `async` und `await` verwendet, definieren wir di
 
 {* ../../docs_src/background_tasks/tutorial001.py hl[6:9] *}
 
-## Den Hintergrundtask hinzufügen
+## Den Hintergrundtask hinzufügen { #add-the-background-task }
 
 Übergeben Sie innerhalb Ihrer *Pfadoperation-Funktion* Ihre Taskfunktion mit der Methode `.add_task()` an das *Hintergrundtasks*-Objekt:
 
@@ -45,21 +45,23 @@ Und da der Schreibvorgang nicht `async` und `await` verwendet, definieren wir di
 * Eine beliebige Folge von Argumenten, die der Reihe nach an die Taskfunktion übergeben werden sollen (`email`).
 * Alle Schlüsselwort-Argumente, die an die Taskfunktion übergeben werden sollen (`message="some notification"`).
 
-## Dependency Injection
+## Dependency Injection { #dependency-injection }
 
 Die Verwendung von `BackgroundTasks` funktioniert auch mit dem <abbr title="Einbringen von Abhängigkeiten">Dependency Injection</abbr> System. Sie können einen Parameter vom Typ `BackgroundTasks` auf mehreren Ebenen deklarieren: in einer *Pfadoperation-Funktion*, in einer Abhängigkeit (Dependable), in einer Unterabhängigkeit usw.
 
 **FastAPI** weiß, was jeweils zu tun ist und wie dasselbe Objekt wiederverwendet werden kann, sodass alle Hintergrundtasks zusammengeführt und anschließend im Hintergrund ausgeführt werden:
 
+
 {* ../../docs_src/background_tasks/tutorial002_an_py310.py hl[13,15,22,25] *}
 
+
 In obigem Beispiel werden die Nachrichten, *nachdem* die Response gesendet wurde, in die Datei `log.txt` geschrieben.
 
 Wenn im Request ein Query-Parameter enthalten war, wird dieser in einem Hintergrundtask in das Log geschrieben.
 
 Und dann schreibt ein weiterer Hintergrundtask, der in der *Pfadoperation-Funktion* erstellt wird, eine Nachricht unter Verwendung des Pfad-Parameters `email`.
 
-## Technische Details
+## Technische Details { #technical-details }
 
 Die Klasse `BackgroundTasks` stammt direkt von <a href="https://www.starlette.io/background/" class="external-link" target="_blank">`starlette.background`</a>.
 
@@ -69,16 +71,16 @@ Indem Sie nur `BackgroundTasks` (und nicht `BackgroundTask`) verwenden, ist es d
 
 Es ist immer noch möglich, `BackgroundTask` allein in FastAPI zu verwenden, aber Sie müssen das Objekt in Ihrem Code erstellen und eine Starlette-`Response` zurückgeben, die es enthält.
 
-Weitere Details finden Sie in der <a href="https://www.starlette.io/background/" class="external-link" target="_blank">offiziellen Starlette-Dokumentation für Hintergrundtasks</a>.
+Weitere Details finden Sie in <a href="https://www.starlette.io/background/" class="external-link" target="_blank">Starlettes offizieller Dokumentation für Hintergrundtasks</a>.
 
-## Vorbehalt
+## Vorbehalt { #caveat }
 
 Wenn Sie umfangreiche Hintergrundberechnungen durchführen müssen und diese nicht unbedingt vom selben Prozess ausgeführt werden müssen (z. B. müssen Sie Speicher, Variablen, usw. nicht gemeinsam nutzen), könnte die Verwendung anderer größerer Tools wie z. B. <a href="https://docs.celeryq.dev" class="external-link" target="_blank">Celery</a> von Vorteil sein.
 
 Sie erfordern in der Regel komplexere Konfigurationen und einen Nachrichten-/Job-Queue-Manager wie RabbitMQ oder Redis, ermöglichen Ihnen jedoch die Ausführung von Hintergrundtasks in mehreren Prozessen und insbesondere auf mehreren Servern.
 
-Wenn Sie jedoch über dieselbe **FastAPI**-Anwendung auf Variablen und Objekte zugreifen oder kleine Hintergrundtasks ausführen müssen (z. B. das Senden einer E-Mail-Benachrichtigung), können Sie einfach `BackgroundTasks` verwenden.
+Wenn Sie jedoch über dieselbe **FastAPI**-App auf Variablen und Objekte zugreifen oder kleine Hintergrundtasks ausführen müssen (z. B. das Senden einer E-Mail-Benachrichtigung), können Sie einfach `BackgroundTasks` verwenden.
 
-## Zusammenfassung
+## Zusammenfassung { #recap }
 
 Importieren und verwenden Sie `BackgroundTasks` mit Parametern in *Pfadoperation-Funktionen* und Abhängigkeiten, um Hintergrundtasks hinzuzufügen.

docs/de/docs/tutorial/bigger-applications.md

@@ -1,16 +1,16 @@
-# Größere Anwendungen – mehrere Dateien
+# Größere Anwendungen – mehrere Dateien { #bigger-applications-multiple-files }
 
 Wenn Sie eine Anwendung oder eine Web-API erstellen, ist es selten der Fall, dass Sie alles in einer einzigen Datei unterbringen können.
 
 **FastAPI** bietet ein praktisches Werkzeug zur Strukturierung Ihrer Anwendung bei gleichzeitiger Wahrung der Flexibilität.
 
-/// info
+/// info | Info
 
 Wenn Sie von Flask kommen, wäre dies das Äquivalent zu Flasks Blueprints.
 
 ///
 
-## Eine Beispiel-Dateistruktur
+## Eine Beispiel-Dateistruktur { #an-example-file-structure }
 
 Nehmen wir an, Sie haben eine Dateistruktur wie diese:
 
@@ -71,7 +71,7 @@ Die gleiche Dateistruktur mit Kommentaren:
 │       └── admin.py     # „admin“-Submodul, z. B. import app.internal.admin
 ```
 
-## `APIRouter`
+## `APIRouter` { #apirouter }
 
 Nehmen wir an, die Datei, die nur für die Verwaltung von Benutzern zuständig ist, ist das Submodul unter `/app/routers/users.py`.
 
@@ -81,7 +81,7 @@ Aber es ist immer noch Teil derselben **FastAPI**-Anwendung/Web-API (es ist Teil
 
 Sie können die *Pfadoperationen* für dieses Modul mit `APIRouter` erstellen.
 
-### `APIRouter` importieren
+### `APIRouter` importieren { #import-apirouter }
 
 Sie importieren ihn und erstellen eine „Instanz“ auf die gleiche Weise wie mit der Klasse `FastAPI`:
 
@@ -89,7 +89,7 @@ Sie importieren ihn und erstellen eine „Instanz“ auf die gleiche Weise wie m
 {!../../docs_src/bigger_applications/app/routers/users.py!}
 ```
 
-### *Pfadoperationen* mit `APIRouter`
+### *Pfadoperationen* mit `APIRouter` { #path-operations-with-apirouter }
 
 Und dann verwenden Sie ihn, um Ihre *Pfadoperationen* zu deklarieren.
 
@@ -113,7 +113,7 @@ In diesem Beispiel heißt die Variable `router`, aber Sie können ihr einen beli
 
 Wir werden diesen `APIRouter` in die Hauptanwendung `FastAPI` einbinden, aber zuerst kümmern wir uns um die Abhängigkeiten und einen anderen `APIRouter`.
 
-## Abhängigkeiten
+## Abhängigkeiten { #dependencies }
 
 Wir sehen, dass wir einige Abhängigkeiten benötigen, die an mehreren Stellen der Anwendung verwendet werden.
 
@@ -159,7 +159,7 @@ Aber in der Praxis werden Sie mit den integrierten [Sicherheits-Werkzeugen](secu
 
 ///
 
-## Ein weiteres Modul mit `APIRouter`.
+## Ein weiteres Modul mit `APIRouter` { #another-module-with-apirouter }
 
 Nehmen wir an, Sie haben im Modul unter `app/routers/items.py` auch die Endpunkte, die für die Verarbeitung von Artikeln („Items“) aus Ihrer Anwendung vorgesehen sind.
 
@@ -199,7 +199,7 @@ Das Präfix lautet in diesem Fall also `/items`.
 
 Wir können auch eine Liste von `tags` und zusätzliche `responses` hinzufügen, die auf alle in diesem Router enthaltenen *Pfadoperationen* angewendet werden.
 
-Und wir können eine Liste von `dependencies` hinzufügen, die allen *Pfadoperationen* im Router hinzugefügt und für jeden an sie gerichteten Request ausgeführt/aufgelöst werden.
+Und wir können eine Liste von `dependencies` hinzufügen, die allen *Pfadoperationen* im Router hinzugefügt und für jeden an sie gerichteten <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> ausgeführt/aufgelöst werden.
 
 /// tip | Tipp
 
@@ -228,13 +228,13 @@ Das Endergebnis ist, dass die Pfade für diese Artikel jetzt wie folgt lauten:
 
 ///
 
-/// check
+/// check | Testen
 
 Die Parameter `prefix`, `tags`, `responses` und `dependencies` sind (wie in vielen anderen Fällen) nur ein Feature von **FastAPI**, um Ihnen dabei zu helfen, Codeverdoppelung zu vermeiden.
 
 ///
 
-### Die Abhängigkeiten importieren
+### Die Abhängigkeiten importieren { #import-the-dependencies }
 
 Der folgende Code befindet sich im Modul `app.routers.items`, also in der Datei `app/routers/items.py`.
 
@@ -246,7 +246,7 @@ Daher verwenden wir einen relativen Import mit `..` für die Abhängigkeiten:
 {!../../docs_src/bigger_applications/app/routers/items.py!}
 ```
 
-#### Wie relative Importe funktionieren
+#### Wie relative Importe funktionieren { #how-relative-imports-work }
 
 /// tip | Tipp
 
@@ -309,7 +309,7 @@ Das würde sich auf ein Paket oberhalb von `app/` beziehen, mit seiner eigenen D
 
 Aber jetzt wissen Sie, wie es funktioniert, sodass Sie relative Importe in Ihren eigenen Anwendungen verwenden können, egal wie komplex diese sind. 🤓
 
-### Einige benutzerdefinierte `tags`, `responses`, und `dependencies` hinzufügen
+### Einige benutzerdefinierte `tags`, `responses`, und `dependencies` hinzufügen { #add-some-custom-tags-responses-and-dependencies }
 
 Wir fügen weder das Präfix `/items` noch `tags=["items"]` zu jeder *Pfadoperation* hinzu, da wir sie zum `APIRouter` hinzugefügt haben.
 
@@ -323,21 +323,21 @@ Aber wir können immer noch _mehr_ `tags` hinzufügen, die auf eine bestimmte *P
 
 Diese letzte Pfadoperation wird eine Kombination von Tags haben: `["items", "custom"]`.
 
-Und sie wird auch beide Responses in der Dokumentation haben, eine für `404` und eine für `403`.
+Und sie wird auch beide <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Responses</abbr> in der Dokumentation haben, eine für `404` und eine für `403`.
 
 ///
 
-## Das Haupt-`FastAPI`.
+## Das Haupt-`FastAPI` { #the-main-fastapi }
 
 Sehen wir uns nun das Modul unter `app/main.py` an.
 
 Hier importieren und verwenden Sie die Klasse `FastAPI`.
 
-Dies ist die Hauptdatei Ihrer Anwendung, die alles zusammen bindet.
+Dies ist die Hauptdatei Ihrer Anwendung, die alles zusammenfügt.
 
 Und da sich der Großteil Ihrer Logik jetzt in seinem eigenen spezifischen Modul befindet, wird die Hauptdatei recht einfach sein.
 
-### `FastAPI` importieren
+### `FastAPI` importieren { #import-fastapi }
 
 Sie importieren und erstellen wie gewohnt eine `FastAPI`-Klasse.
 
@@ -347,7 +347,7 @@ Und wir können sogar [globale Abhängigkeiten](dependencies/global-dependencies
 {!../../docs_src/bigger_applications/app/main.py!}
 ```
 
-### Den `APIRouter` importieren
+### Den `APIRouter` importieren { #import-the-apirouter }
 
 Jetzt importieren wir die anderen Submodule, die `APIRouter` haben:
 
@@ -357,7 +357,7 @@ Jetzt importieren wir die anderen Submodule, die `APIRouter` haben:
 
 Da es sich bei den Dateien `app/routers/users.py` und `app/routers/items.py` um Submodule handelt, die Teil desselben Python-Packages `app` sind, können wir einen einzelnen Punkt `.` verwenden, um sie mit „relativen Imports“ zu importieren.
 
-### Wie das Importieren funktioniert
+### Wie das Importieren funktioniert { #how-the-importing-works }
 
 Die Sektion:
 
@@ -381,7 +381,7 @@ Wir könnten sie auch wie folgt importieren:
 from app.routers import items, users
 ```
 
-/// info
+/// info | Info
 
 Die erste Version ist ein „relativer Import“:
 
@@ -399,7 +399,7 @@ Um mehr über Python-Packages und -Module zu erfahren, lesen Sie <a href="https:
 
 ///
 
-### Namenskollisionen vermeiden
+### Namenskollisionen vermeiden { #avoid-name-collisions }
 
 Wir importieren das Submodul `items` direkt, anstatt nur seine Variable `router` zu importieren.
 
@@ -420,8 +420,7 @@ Um also beide in derselben Datei verwenden zu können, importieren wir die Submo
 {!../../docs_src/bigger_applications/app/main.py!}
 ```
 
-
-### Die `APIRouter` für `users` und `items` inkludieren
+### Die `APIRouter` für `users` und `items` inkludieren { #include-the-apirouters-for-users-and-items }
 
 Inkludieren wir nun die `router` aus diesen Submodulen `users` und `items`:
 
@@ -429,7 +428,7 @@ Inkludieren wir nun die `router` aus diesen Submodulen `users` und `items`:
 {!../../docs_src/bigger_applications/app/main.py!}
 ```
 
-/// info
+/// info | Info
 
 `users.router` enthält den `APIRouter` in der Datei `app/routers/users.py`.
 
@@ -449,7 +448,7 @@ Hinter den Kulissen wird es also tatsächlich so funktionieren, als ob alles die
 
 ///
 
-/// check
+/// check | Testen
 
 Bei der Einbindung von Routern müssen Sie sich keine Gedanken über die Performanz machen.
 
@@ -459,7 +458,7 @@ Es hat also keinen Einfluss auf die Leistung. ⚡
 
 ///
 
-### Einen `APIRouter` mit benutzerdefinierten `prefix`, `tags`, `responses` und `dependencies` einfügen
+### Einen `APIRouter` mit benutzerdefinierten `prefix`, `tags`, `responses` und `dependencies` einfügen { #include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies }
 
 Stellen wir uns nun vor, dass Ihre Organisation Ihnen die Datei `app/internal/admin.py` gegeben hat.
 
@@ -492,7 +491,7 @@ Dies wirkt sich jedoch nur auf diesen `APIRouter` in unserer Anwendung aus, nich
 
 So könnten beispielsweise andere Projekte denselben `APIRouter` mit einer anderen Authentifizierungsmethode verwenden.
 
-### Eine *Pfadoperation* hinzufügen
+### Eine *Pfadoperation* hinzufügen { #include-a-path-operation }
 
 Wir können *Pfadoperationen* auch direkt zur `FastAPI`-App hinzufügen.
 
@@ -518,14 +517,14 @@ Da wir sie nicht einfach isolieren und unabhängig vom Rest „mounten“ könne
 
 ///
 
-## Es in der automatischen API-Dokumentation ansehen
+## Es in der automatischen API-Dokumentation testen { #check-the-automatic-api-docs }
 
-Führen Sie nun `uvicorn` aus, indem Sie das Modul `app.main` und die Variable `app` verwenden:
+Führen Sie nun Ihre App aus:
 
 <div class="termy">
 
 ```console
-$ uvicorn app.main:app --reload
+$ fastapi dev app/main.py
 
 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -538,7 +537,7 @@ Sie sehen die automatische API-Dokumentation, einschließlich der Pfade aller Su
 
 <img src="/img/tutorial/bigger-applications/image01.png">
 
-## Den gleichen Router mehrmals mit unterschiedlichem `prefix` inkludieren
+## Den gleichen Router mehrmals mit unterschiedlichem `prefix` inkludieren { #include-the-same-router-multiple-times-with-different-prefix }
 
 Sie können `.include_router()` auch mehrmals mit *demselben* Router und unterschiedlichen Präfixen verwenden.
 
@@ -546,7 +545,7 @@ Dies könnte beispielsweise nützlich sein, um dieselbe API unter verschiedenen
 
 Dies ist eine fortgeschrittene Verwendung, die Sie möglicherweise nicht wirklich benötigen, aber für den Fall, dass Sie sie benötigen, ist sie vorhanden.
 
-## Einen `APIRouter` in einen anderen einfügen
+## Einen `APIRouter` in einen anderen einfügen { #include-an-apirouter-in-another }
 
 Auf die gleiche Weise, wie Sie einen `APIRouter` in eine `FastAPI`-Anwendung einbinden können, können Sie einen `APIRouter` in einen anderen `APIRouter` einbinden, indem Sie Folgendes verwenden:
 

docs/de/docs/tutorial/body-fields.md

@@ -1,8 +1,8 @@
-# Body – Felder
+# Body – Felder { #body-fields }
 
-So wie Sie zusätzliche Validation und Metadaten in Parametern der **Pfadoperation-Funktion** mittels `Query`, `Path` und `Body` deklarieren, können Sie auch innerhalb von Pydantic-Modellen zusätzliche Validation und Metadaten deklarieren, mittels Pydantics `Field`.
+So wie Sie zusätzliche Validierung und Metadaten in Parametern der *Pfadoperation-Funktion* mittels `Query`, `Path` und `Body` deklarieren, können Sie auch innerhalb von Pydantic-Modellen zusätzliche Validierung und Metadaten deklarieren, mittels Pydantics `Field`.
 
-## `Field` importieren
+## `Field` importieren { #import-field }
 
 Importieren Sie es zuerst:
 
@@ -14,7 +14,7 @@ Beachten Sie, dass `Field` direkt von `pydantic` importiert wird, nicht von `fas
 
 ///
 
-## Modellattribute deklarieren
+## Modellattribute deklarieren { #declare-model-attributes }
 
 Dann können Sie `Field` mit Modellattributen deklarieren:
 
@@ -24,23 +24,23 @@ Dann können Sie `Field` mit Modellattributen deklarieren:
 
 /// note | Technische Details
 
-Tatsächlich erstellen `Query`, `Path` und andere, die sie kennenlernen werden, Instanzen von Unterklassen einer allgemeinen Klasse `Param`, die ihrerseits eine Unterklasse von Pydantics `FieldInfo`-Klasse ist.
+Tatsächlich erstellen `Query`, `Path` und andere, die Sie als nächstes sehen werden, Instanzen von Unterklassen einer allgemeinen Klasse `Param`, welche selbst eine Unterklasse von Pydantics `FieldInfo`-Klasse ist.
 
 Und Pydantics `Field` gibt ebenfalls eine Instanz von `FieldInfo` zurück.
 
-`Body` gibt auch Instanzen einer Unterklasse von `FieldInfo` zurück. Und später werden Sie andere sehen, die Unterklassen der `Body`-Klasse sind.
+`Body` gibt auch direkt Instanzen einer Unterklasse von `FieldInfo` zurück. Später werden Sie andere sehen, die Unterklassen der `Body`-Klasse sind.
 
-Denken Sie daran, dass `Query`, `Path` und andere von `fastapi` tatsächlich Funktionen sind, die spezielle Klassen zurückgeben.
+Denken Sie daran, dass `Query`, `Path` und andere, wenn Sie sie von `fastapi` importieren, tatsächlich Funktionen sind, die spezielle Klassen zurückgeben.
 
 ///
 
 /// tip | Tipp
 
-Beachten Sie, dass jedes Modellattribut mit einem Typ, Defaultwert und `Field` die gleiche Struktur hat wie ein Parameter einer Pfadoperation-Funktion, nur mit `Field` statt `Path`, `Query`, `Body`.
+Beachten Sie, wie jedes Attribut eines Modells mit einem Typ, Defaultwert und `Field` die gleiche Struktur hat wie ein Parameter einer *Pfadoperation-Funktion*, nur mit `Field` statt `Path`, `Query`, `Body`.
 
 ///
 
-## Zusätzliche Information hinzufügen
+## Zusätzliche Information hinzufügen { #add-extra-information }
 
 Sie können zusätzliche Information in `Field`, `Query`, `Body`, usw. deklarieren. Und es wird im generierten JSON-Schema untergebracht.
 
@@ -48,12 +48,12 @@ Sie werden später mehr darüber lernen, wie man zusätzliche Information unterb
 
 /// warning | Achtung
 
-Extra-Schlüssel, die `Field` überreicht werden, werden auch im resultierenden OpenAPI-Schema Ihrer Anwendung gelistet. Da diese Schlüssel nicht notwendigerweise Teil der OpenAPI-Spezifikation sind, könnten einige OpenAPI-Tools, wie etwa [der OpenAPI-Validator](https://validator.swagger.io/), nicht mit Ihrem generierten Schema funktionieren.
+Extra-Schlüssel, die `Field` überreicht werden, werden auch im resultierenden OpenAPI-Schema Ihrer Anwendung gelistet. Da diese Schlüssel möglicherweise nicht Teil der OpenAPI-Spezifikation sind, könnten einige OpenAPI-Tools, wie etwa [der OpenAPI-Validator](https://validator.swagger.io/), nicht mit Ihrem generierten Schema funktionieren.
 
 ///
 
-## Zusammenfassung
+## Zusammenfassung { #recap }
 
 Sie können Pydantics `Field` verwenden, um zusätzliche Validierungen und Metadaten für Modellattribute zu deklarieren.
 
-Sie können auch Extra-Schlüssel verwenden, um zusätzliche JSON-Schema-Metadaten zu überreichen.
+Sie können auch die zusätzlichen Schlüsselwortargumente verwenden, um zusätzliche JSON-Schema-Metadaten zu übergeben.

docs/de/docs/tutorial/body-multiple-params.md

@@ -1,8 +1,8 @@
-# Body – Mehrere Parameter
+# Body – Mehrere Parameter { #body-multiple-parameters }
 
-Jetzt, da wir gesehen haben, wie `Path` und `Query` verwendet werden, schauen wir uns fortgeschrittenere Verwendungsmöglichkeiten von Requestbody-Deklarationen an.
+Nun, da wir gesehen haben, wie `Path` und `Query` verwendet werden, schauen wir uns fortgeschrittenere Verwendungsmöglichkeiten von <abbr title="Anfragekörper">Requestbody</abbr>-Deklarationen an.
 
-## `Path`-, `Query`- und Body-Parameter vermischen
+## `Path`-, `Query`- und Body-Parameter vermischen { #mix-path-query-and-body-parameters }
 
 Zuerst einmal, Sie können `Path`-, `Query`- und Requestbody-Parameter-Deklarationen frei mischen und **FastAPI** wird wissen, was zu tun ist.
 
@@ -16,9 +16,9 @@ Beachten Sie, dass in diesem Fall das `item`, welches vom Body genommen wird, op
 
 ///
 
-## Mehrere Body-Parameter
+## Mehrere Body-Parameter { #multiple-body-parameters }
 
-Im vorherigen Beispiel erwartete die *Pfadoperation* einen JSON-Body mit den Attributen eines `Item`s, etwa:
+Im vorherigen Beispiel erwarteten die *Pfadoperationen* einen JSON-Body mit den Attributen eines `Item`s, etwa:
 
 ```JSON
 {
@@ -35,7 +35,7 @@ Aber Sie können auch mehrere Body-Parameter deklarieren, z. B. `item` und `user
 
 In diesem Fall wird **FastAPI** bemerken, dass es mehr als einen Body-Parameter in der Funktion gibt (zwei Parameter, die Pydantic-Modelle sind).
 
-Es wird deshalb die Parameternamen als Schlüssel (Feldnamen) im Body verwenden, und erwartet einen Body wie folgt:
+Es wird deshalb die Parameternamen als Schlüssel (Feldnamen) im Body verwenden und erwartet einen Body wie folgt:
 
 ```JSON
 {
@@ -58,17 +58,17 @@ Beachten Sie, dass, obwohl `item` wie zuvor deklariert wurde, es nun unter einem
 
 ///
 
-**FastAPI** wird die automatische Konvertierung des Requests übernehmen, sodass der Parameter `item` seinen spezifischen Inhalt bekommt, genau so wie der Parameter `user`.
+**FastAPI** wird die automatische Konvertierung des Requests übernehmen, sodass der Parameter `item` seinen spezifischen Inhalt bekommt, und das Gleiche gilt für den Parameter `user`.
 
-Es wird die Validierung dieser zusammengesetzten Daten übernehmen, und sie im OpenAPI-Schema und der automatischen Dokumentation dokumentieren.
+Es wird die Validierung dieser zusammengesetzten Daten übernehmen, und diese im OpenAPI-Schema und der automatischen Dokumentation dokumentieren.
 
-## Einzelne Werte im Body
+## Einzelne Werte im Body { #singular-values-in-body }
 
-So wie `Query` und `Path` für Query- und Pfad-Parameter, hat **FastAPI** auch das Äquivalent `Body`, um Extra-Daten für Body-Parameter zu definieren.
+So wie `Query` und `Path` für Query- und Pfad-Parameter, stellt **FastAPI** das Äquivalent `Body` zur Verfügung, um Extra-Daten für Body-Parameter zu definieren.
 
-Zum Beispiel, das vorherige Modell erweiternd, könnten Sie entscheiden, dass Sie einen weiteren Schlüssel <abbr title="Wichtigkeit">`importance`</abbr> haben möchten, im selben Body, Seite an Seite mit `item` und `user`.
+Zum Beispiel, das vorherige Modell erweiternd, könnten Sie entscheiden, dass Sie einen weiteren Schlüssel `importance` im selben Body haben möchten, neben `item` und `user`.
 
-Wenn Sie diesen Parameter einfach so hinzufügen, wird **FastAPI** annehmen, dass es ein Query-Parameter ist.
+Wenn Sie diesen Parameter einfach so hinzufügen, wird **FastAPI** annehmen, dass es ein Query-Parameter ist, da er ein einzelner Wert ist.
 
 Aber Sie können **FastAPI** instruieren, ihn als weiteren Body-Schlüssel zu erkennen, indem Sie `Body` verwenden:
 
@@ -92,9 +92,9 @@ In diesem Fall erwartet **FastAPI** einen Body wie:
 }
 ```
 
-Wiederum wird es die Daten konvertieren, validieren, dokumentieren, usw.
+Wiederum wird es die Datentypen konvertieren, validieren, dokumentieren, usw.
 
-## Mehrere Body-Parameter und Query-Parameter
+## Mehrere Body-Parameter und Query-Parameter { #multiple-body-params-and-query }
 
 Natürlich können Sie auch, wann immer Sie das brauchen, weitere Query-Parameter hinzufügen, zusätzlich zu den Body-Parametern.
 
@@ -112,21 +112,21 @@ q: str | None = None
 
 Zum Beispiel:
 
-{* ../../docs_src/body_multiple_params/tutorial004_an_py310.py hl[27] *}
+{* ../../docs_src/body_multiple_params/tutorial004_an_py310.py hl[28] *}
 
-/// info
+/// info | Info
 
-`Body` hat die gleichen zusätzlichen Validierungs- und Metadaten-Parameter wie `Query` und `Path` und andere, die Sie später kennenlernen.
+`Body` hat die gleichen zusätzlichen Validierungs- und Metadaten-Parameter wie `Query`, `Path` und andere, die Sie später kennenlernen werden.
 
 ///
 
-## Einen einzelnen Body-Parameter einbetten
+## Einen einzelnen Body-Parameter einbetten { #embed-a-single-body-parameter }
 
-Nehmen wir an, Sie haben nur einen einzelnen `item`-Body-Parameter, ein Pydantic-Modell `Item`.
+Nehmen wir an, Sie haben nur einen einzelnen `item`-Body-Parameter von einem Pydantic-Modell `Item`.
 
-Normalerweise wird **FastAPI** dann seinen JSON-Body direkt erwarten.
+Standardmäßig wird **FastAPI** dann seinen Body direkt erwarten.
 
-Aber wenn Sie möchten, dass es einen JSON-Body erwartet, mit einem Schlüssel `item` und darin den Inhalt des Modells, so wie es das tut, wenn Sie mehrere Body-Parameter deklarieren, dann können Sie den speziellen `Body`-Parameter `embed` setzen:
+Aber wenn Sie möchten, dass es einen JSON-Body mit einem Schlüssel `item` erwartet, und darin den Inhalt des Modells, so wie es das tut, wenn Sie mehrere Body-Parameter deklarieren, dann können Sie den speziellen `Body`-Parameter `embed` setzen:
 
 ```Python
 item: Item = Body(embed=True)
@@ -160,11 +160,11 @@ statt:
 }
 ```
 
-## Zusammenfassung
+## Zusammenfassung { #recap }
 
-Sie können mehrere Body-Parameter zu ihrer *Pfadoperation-Funktion* hinzufügen, obwohl ein Request nur einen einzigen Body enthalten kann.
+Sie können mehrere Body-Parameter zu Ihrer *Pfadoperation-Funktion* hinzufügen, obwohl ein Request nur einen einzigen Body enthalten kann.
 
-**FastAPI** wird sich darum kümmern, Ihnen korrekte Daten in Ihrer Funktion zu überreichen, und das korrekte Schema in der *Pfadoperation* zu validieren und zu dokumentieren.
+Aber **FastAPI** wird sich darum kümmern, Ihnen korrekte Daten in Ihrer Funktion zu überreichen, und das korrekte Schema in der *Pfadoperation* zu validieren und zu dokumentieren.
 
 Sie können auch einzelne Werte deklarieren, die als Teil des Bodys empfangen werden.
 

docs/de/docs/tutorial/body-nested-models.md

@@ -1,20 +1,20 @@
-# Body – Verschachtelte Modelle
+# Body – Verschachtelte Modelle { #body-nested-models }
 
-Mit **FastAPI** können Sie (dank Pydantic) beliebig tief verschachtelte Modelle definieren, validieren und dokumentieren.
+Mit **FastAPI** können Sie (dank Pydantic) beliebig tief verschachtelte Modelle definieren, validieren, dokumentieren und verwenden.
 
-## Listen als Felder
+## Listen als Felder { #list-fields }
 
-Sie können ein Attribut als Kindtyp definieren, zum Beispiel eine Python-`list`e.
+Sie können ein Attribut als Kindtyp definieren, zum Beispiel eine Python-`list`.
 
 {* ../../docs_src/body_nested_models/tutorial001_py310.py hl[12] *}
 
 Das bewirkt, dass `tags` eine Liste ist, wenngleich es nichts über den Typ der Elemente der Liste aussagt.
 
-## Listen mit Typ-Parametern als Felder
+## Listen mit Typ-Parametern als Felder { #list-fields-with-type-parameter }
 
 Aber Python erlaubt es, Listen mit inneren Typen, auch „Typ-Parameter“ genannt, zu deklarieren.
 
-### `List` von `typing` importieren
+### `List` von `typing` importieren { #import-typings-list }
 
 In Python 3.9 oder darüber können Sie einfach `list` verwenden, um diese Typannotationen zu deklarieren, wie wir unten sehen werden. 💡
 
@@ -22,7 +22,7 @@ In Python-Versionen vor 3.9 (3.6 und darüber), müssen Sie zuerst `List` von Py
 
 {* ../../docs_src/body_nested_models/tutorial002.py hl[1] *}
 
-### Eine `list`e mit einem Typ-Parameter deklarieren
+### Eine `list` mit einem Typ-Parameter deklarieren { #declare-a-list-with-a-type-parameter }
 
 Um Typen wie `list`, `dict`, `tuple` mit inneren Typ-Parametern (inneren Typen) zu deklarieren:
 
@@ -51,7 +51,7 @@ In unserem Beispiel können wir also bewirken, dass `tags` spezifisch eine „Li
 
 {* ../../docs_src/body_nested_models/tutorial002_py310.py hl[12] *}
 
-## Set-Typen
+## Set-Typen { #set-types }
 
 Aber dann denken wir darüber nach und stellen fest, dass sich die Tags nicht wiederholen sollen, es sollen eindeutige Strings sein.
 
@@ -61,13 +61,13 @@ Deklarieren wir also `tags` als Set von Strings.
 
 {* ../../docs_src/body_nested_models/tutorial003_py310.py hl[12] *}
 
-Jetzt, selbst wenn Sie einen Request mit duplizierten Daten erhalten, werden diese zu einem Set eindeutiger Dinge konvertiert.
+Jetzt, selbst wenn Sie einen <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> mit duplizierten Daten erhalten, werden diese zu einem Set eindeutiger Dinge konvertiert.
 
 Und wann immer Sie diese Daten ausgeben, selbst wenn die Quelle Duplikate hatte, wird es als Set von eindeutigen Dingen ausgegeben.
 
 Und es wird entsprechend annotiert/dokumentiert.
 
-## Verschachtelte Modelle
+## Verschachtelte Modelle { #nested-models }
 
 Jedes Attribut eines Pydantic-Modells hat einen Typ.
 
@@ -77,19 +77,19 @@ Sie können also tief verschachtelte JSON-„Objekte“ deklarieren, mit spezifi
 
 Alles das beliebig tief verschachtelt.
 
-### Ein Kindmodell definieren
+### Ein Kindmodell definieren { #define-a-submodel }
 
-Wir können zum Beispiel ein `Image`-Modell definieren.
+Für ein Beispiel können wir ein `Image`-Modell definieren.
 
 {* ../../docs_src/body_nested_models/tutorial004_py310.py hl[7:9] *}
 
-### Das Kindmodell als Typ verwenden
+### Das Kindmodell als Typ verwenden { #use-the-submodel-as-a-type }
 
-Und dann können wir es als Typ eines Attributes verwenden.
+Und dann können wir es als Typ eines Attributes verwenden:
 
 {* ../../docs_src/body_nested_models/tutorial004_py310.py hl[18] *}
 
-Das würde bedeuten, dass **FastAPI** einen Body erwartet wie:
+Das würde bedeuten, dass **FastAPI** einen Body wie folgt erwartet:
 
 ```JSON
 {
@@ -112,25 +112,25 @@ Wiederum, nur mit dieser Deklaration erhalten Sie von **FastAPI**:
 * Datenvalidierung
 * Automatische Dokumentation
 
-## Spezielle Typen und Validierungen
+## Spezielle Typen und Validierungen { #special-types-and-validation }
 
-Abgesehen von normalen einfachen Typen, wie `str`, `int`, `float`, usw. können Sie komplexere einfache Typen verwenden, die von `str` erben.
+Abgesehen von normalen einfachen Typen wie `str`, `int`, `float`, usw. können Sie komplexere einfache Typen verwenden, die von `str` erben.
 
-Um alle Optionen kennenzulernen, die Sie haben, schauen Sie sich <a href="https://docs.pydantic.dev/latest/concepts/types/" class="external-link" target="_blank">Pydantics Typübersicht</a> an. Sie werden im nächsten Kapitel ein paar Beispiele kennenlernen.
+Um alle Optionen kennenzulernen, die Sie haben, schauen Sie sich <a href="https://docs.pydantic.dev/latest/concepts/types/" class="external-link" target="_blank">Pydantics Typübersicht</a> an. Sie werden einige Beispiele im nächsten Kapitel kennenlernen.
 
-Da wir zum Beispiel im `Image`-Modell ein Feld `url` haben, können wir deklarieren, dass das eine Instanz von Pydantics `HttpUrl` sein soll, anstelle eines `str`:
+Zum Beispiel, da wir im `Image`-Modell ein Feld `url` haben, können wir deklarieren, dass das eine Instanz von Pydantics `HttpUrl` sein soll, anstelle eines `str`:
 
 {* ../../docs_src/body_nested_models/tutorial005_py310.py hl[2,8] *}
 
 Es wird getestet, ob der String eine gültige URL ist, und als solche wird er in JSON Schema / OpenAPI dokumentiert.
 
-## Attribute mit Listen von Kindmodellen
+## Attribute mit Listen von Kindmodellen { #attributes-with-lists-of-submodels }
 
 Sie können Pydantic-Modelle auch als Typen innerhalb von `list`, `set`, usw. verwenden:
 
 {* ../../docs_src/body_nested_models/tutorial006_py310.py hl[18] *}
 
-Das wird einen JSON-Body erwarten (konvertieren, validieren, dokumentieren), wie:
+Das wird einen JSON-Body erwarten (konvertieren, validieren, dokumentieren, usw.) wie:
 
 ```JSON hl_lines="11"
 {
@@ -156,27 +156,27 @@ Das wird einen JSON-Body erwarten (konvertieren, validieren, dokumentieren), wie
 }
 ```
 
-/// info
+/// info | Info
 
 Beachten Sie, dass der `images`-Schlüssel jetzt eine Liste von Bild-Objekten hat.
 
 ///
 
-## Tief verschachtelte Modelle
+## Tief verschachtelte Modelle { #deeply-nested-models }
 
 Sie können beliebig tief verschachtelte Modelle definieren:
 
 {* ../../docs_src/body_nested_models/tutorial007_py310.py hl[7,12,18,21,25] *}
 
-/// info
+/// info | Info
 
-Beachten Sie, wie `Offer` eine Liste von `Item`s hat, von denen jedes seinerseits eine optionale Liste von `Image`s hat.
+Beachten Sie, wie `Offer` eine Liste von `Item`s hat, die ihrerseits eine optionale Liste von `Image`s haben.
 
 ///
 
-## Bodys aus reinen Listen
+## Bodys aus reinen Listen { #bodies-of-pure-lists }
 
-Wenn Sie möchten, dass das äußerste Element des JSON-Bodys ein JSON-`array` (eine Python-`list`e) ist, können Sie den Typ im Funktionsparameter deklarieren, mit der gleichen Syntax wie in Pydantic-Modellen:
+Wenn das äußerste Element des JSON-Bodys, das Sie erwarten, ein JSON-`array` (eine Python-`list`) ist, können Sie den Typ im Funktionsparameter deklarieren, mit der gleichen Syntax wie in Pydantic-Modellen:
 
 ```Python
 images: List[Image]
@@ -192,7 +192,7 @@ so wie in:
 
 {* ../../docs_src/body_nested_models/tutorial008_py39.py hl[13] *}
 
-## Editor-Unterstützung überall
+## Editor-Unterstützung überall { #editor-support-everywhere }
 
 Und Sie erhalten Editor-Unterstützung überall.
 
@@ -204,11 +204,11 @@ Sie würden diese Editor-Unterstützung nicht erhalten, wenn Sie direkt mit `dic
 
 Aber Sie müssen sich auch nicht weiter um die Modelle kümmern, hereinkommende Dicts werden automatisch in sie konvertiert. Und was Sie zurückgeben, wird automatisch nach JSON konvertiert.
 
-## Bodys mit beliebigen `dict`s
+## Bodys mit beliebigen `dict`s { #bodies-of-arbitrary-dicts }
 
 Sie können einen Body auch als `dict` deklarieren, mit Schlüsseln eines Typs und Werten eines anderen Typs.
 
-So brauchen Sie vorher nicht zu wissen, wie die Feld-/Attribut-Namen lauten (wie es bei Pydantic-Modellen der Fall wäre).
+So brauchen Sie vorher nicht zu wissen, wie die Feld-/Attributnamen lauten (wie es bei Pydantic-Modellen der Fall wäre).
 
 Das ist nützlich, wenn Sie Schlüssel empfangen, deren Namen Sie nicht bereits kennen.
 
@@ -218,7 +218,7 @@ Ein anderer nützlicher Anwendungsfall ist, wenn Sie Schlüssel eines anderen Ty
 
 Das schauen wir uns mal an.
 
-Im folgenden Beispiel akzeptieren Sie irgendein `dict`, solange es `int`-Schlüssel und `float`-Werte hat.
+Im folgenden Beispiel akzeptieren Sie irgendein `dict`, solange es `int`-Schlüssel und `float`-Werte hat:
 
 {* ../../docs_src/body_nested_models/tutorial009_py39.py hl[7] *}
 
@@ -230,11 +230,11 @@ Aber Pydantic hat automatische Datenkonvertierung.
 
 Das bedeutet, dass Ihre API-Clients nur Strings senden können, aber solange diese Strings nur Zahlen enthalten, wird Pydantic sie konvertieren und validieren.
 
-Und das `dict` welches Sie als `weights` erhalten, wird `int`-Schlüssel und `float`-Werte haben.
+Und das `dict`, welches Sie als `weights` erhalten, wird `int`-Schlüssel und `float`-Werte haben.
 
 ///
 
-## Zusammenfassung
+## Zusammenfassung { #recap }
 
 Mit **FastAPI** haben Sie die maximale Flexibilität von Pydantic-Modellen, während Ihr Code einfach, kurz und elegant bleibt.
 

docs/de/docs/tutorial/body-updates.md

@@ -1,16 +1,16 @@
-# Body – Aktualisierungen
+# Body – Aktualisierungen { #body-updates }
 
-## Ersetzendes Aktualisieren mit `PUT`
+## Ersetzendes Aktualisieren mit `PUT` { #update-replacing-with-put }
 
 Um einen Artikel zu aktualisieren, können Sie die <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT" class="external-link" target="_blank">HTTP `PUT`</a> Operation verwenden.
 
-Sie können den `jsonable_encoder` verwenden, um die empfangenen Daten in etwas zu konvertieren, das als JSON gespeichert werden kann (in z. B. einer NoSQL-Datenbank). Zum Beispiel, um ein `datetime` in einen `str` zu konvertieren.
+Sie können den `jsonable_encoder` verwenden, um die empfangenen Daten in etwas zu konvertieren, das als JSON gespeichert werden kann (z. B. in einer NoSQL-Datenbank). Zum Beispiel, um ein `datetime` in einen `str` zu konvertieren.
 
 {* ../../docs_src/body_updates/tutorial001_py310.py hl[28:33] *}
 
 `PUT` wird verwendet, um Daten zu empfangen, die die existierenden Daten ersetzen sollen.
 
-### Warnung bezüglich des Ersetzens
+### Warnung bezüglich des Ersetzens { #warning-about-replacing }
 
 Das bedeutet, dass, wenn Sie den Artikel `bar` aktualisieren wollen, mittels `PUT` und folgendem Body:
 
@@ -22,15 +22,15 @@ Das bedeutet, dass, wenn Sie den Artikel `bar` aktualisieren wollen, mittels `PU
 }
 ```
 
-das Eingabemodell nun den Defaultwert `"tax": 10.5` hat, weil Sie das bereits gespeicherte Attribut `"tax": 20.2` nicht mit übergeben haben.
+weil das bereits gespeicherte Attribut `"tax": 20.2` nicht enthalten ist, das Eingabemodell den Defaultwert `"tax": 10.5` erhalten würde.
 
-Die Daten werden darum mit einem „neuen“ `tax`-Wert von `10.5` abgespeichert.
+Und die Daten würden mit diesem „neuen“ `tax` von `10.5` gespeichert werden.
 
-## Teilweises Ersetzen mit `PATCH`
+## Teilweises Ersetzen mit `PATCH` { #partial-updates-with-patch }
 
 Sie können auch die <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH" class="external-link" target="_blank">HTTP `PATCH`</a> Operation verwenden, um Daten *teilweise* zu ersetzen.
 
-Das bedeutet, sie senden nur die Daten, die Sie aktualisieren wollen, der Rest bleibt unverändert.
+Das bedeutet, Sie senden nur die Daten, die Sie aktualisieren wollen, der Rest bleibt unverändert.
 
 /// note | Hinweis
 
@@ -44,33 +44,33 @@ Aber dieser Leitfaden zeigt Ihnen mehr oder weniger, wie die beiden normalerweis
 
 ///
 
-### Pydantics `exclude_unset`-Parameter verwenden
+### Pydantics `exclude_unset`-Parameter verwenden { #using-pydantics-exclude-unset-parameter }
 
 Wenn Sie Teil-Aktualisierungen entgegennehmen, ist der `exclude_unset`-Parameter in der `.model_dump()`-Methode von Pydantic-Modellen sehr nützlich.
 
 Wie in `item.model_dump(exclude_unset=True)`.
 
-/// info
+/// info | Info
 
-In Pydantic v1 hieß diese Methode `.dict()`, in Pydantic v2 wurde sie deprecated (aber immer noch unterstützt) und in `.model_dump()` umbenannt.
+In Pydantic v1 hieß diese Methode `.dict()`, in Pydantic v2 wurde sie <abbr title="veraltet, obsolet: Es soll nicht mehr verwendet werden">deprecatet</abbr> (aber immer noch unterstützt) und in `.model_dump()` umbenannt.
 
 Die Beispiele hier verwenden `.dict()` für die Kompatibilität mit Pydantic v1, Sie sollten jedoch stattdessen `.model_dump()` verwenden, wenn Sie Pydantic v2 verwenden können.
 
 ///
 
-Das wird ein `dict` erstellen, mit nur den Daten, die gesetzt wurden als das `item`-Modell erstellt wurde, Defaultwerte ausgeschlossen.
+Das wird ein <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">`dict`</abbr> erstellen, mit nur den Daten, die gesetzt wurden, als das `item`-Modell erstellt wurde, Defaultwerte ausgeschlossen.
 
-Sie können das verwenden, um ein `dict` zu erstellen, das nur die (im Request) gesendeten Daten enthält, ohne Defaultwerte:
+Sie können das verwenden, um ein `dict` zu erstellen, das nur die (im <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr>) gesendeten Daten enthält, ohne Defaultwerte:
 
 {* ../../docs_src/body_updates/tutorial002_py310.py hl[32] *}
 
-### Pydantics `update`-Parameter verwenden
+### Pydantics `update`-Parameter verwenden { #using-pydantics-update-parameter }
 
 Jetzt können Sie eine Kopie des existierenden Modells mittels `.model_copy()` erstellen, wobei Sie dem `update`-Parameter ein `dict` mit den zu ändernden Daten übergeben.
 
-/// info
+/// info | Info
 
-In Pydantic v1 hieß diese Methode `.copy()`, in Pydantic v2 wurde sie deprecated (aber immer noch unterstützt) und in `.model_copy()` umbenannt.
+In Pydantic v1 hieß diese Methode `.copy()`, in Pydantic v2 wurde sie <abbr title="veraltet, obsolet: Es soll nicht mehr verwendet werden">deprecatet</abbr> (aber immer noch unterstützt) und in `.model_copy()` umbenannt.
 
 Die Beispiele hier verwenden `.copy()` für die Kompatibilität mit Pydantic v1, Sie sollten jedoch stattdessen `.model_copy()` verwenden, wenn Sie Pydantic v2 verwenden können.
 
@@ -80,7 +80,7 @@ Wie in `stored_item_model.model_copy(update=update_data)`:
 
 {* ../../docs_src/body_updates/tutorial002_py310.py hl[33] *}
 
-### Rekapitulation zum teilweisen Ersetzen
+### Rekapitulation zum teilweisen Ersetzen { #partial-updates-recap }
 
 Zusammengefasst, um Teil-Ersetzungen vorzunehmen:
 
@@ -90,7 +90,7 @@ Zusammengefasst, um Teil-Ersetzungen vorzunehmen:
 * Erzeugen Sie aus dem empfangenen Modell ein `dict` ohne Defaultwerte (mittels `exclude_unset`).
     * So ersetzen Sie nur die tatsächlich vom Benutzer gesetzten Werte, statt dass bereits gespeicherte Werte mit Defaultwerten des Modells überschrieben werden.
 * Erzeugen Sie eine Kopie ihres gespeicherten Modells, wobei Sie die Attribute mit den empfangenen Teil-Ersetzungen aktualisieren (mittels des `update`-Parameters).
-* Konvertieren Sie das kopierte Modell zu etwas, das in ihrer Datenbank gespeichert werden kann (indem Sie beispielsweise `jsonable_encoder` verwenden).
+* Konvertieren Sie das kopierte Modell zu etwas, das in Ihrer Datenbank gespeichert werden kann (indem Sie beispielsweise `jsonable_encoder` verwenden).
     * Das ist vergleichbar dazu, die `.model_dump()`-Methode des Modells erneut aufzurufen, aber es wird sicherstellen, dass die Werte zu Daten konvertiert werden, die ihrerseits zu JSON konvertiert werden können, zum Beispiel `datetime` zu `str`.
 * Speichern Sie die Daten in Ihrer Datenbank.
 * Geben Sie das aktualisierte Modell zurück.

docs/de/docs/tutorial/body.md

@@ -1,40 +1,40 @@
-# Requestbody
+# Requestbody { #request-body }
 
-Wenn Sie Daten von einem <abbr title="Client: Eine Software, die sich mit einem Server verbindet.">Client</abbr> (sagen wir, einem Browser) zu Ihrer API senden, dann senden Sie diese als einen **Requestbody** (Deutsch: Anfragekörper).
+Wenn Sie Daten von einem <abbr title="Client: Eine Software, die sich mit einem Server verbindet.">Client</abbr> (sagen wir, einem Browser) zu Ihrer API senden müssen, senden Sie sie als **Requestbody**.
 
-Ein **Request**body sind Daten, die vom Client zu Ihrer API gesendet werden. Ein **Response**body (Deutsch: Antwortkörper) sind Daten, die Ihre API zum Client sendet.
+Ein <abbr title="Anfragekörper">**Request**body</abbr> sind Daten, die vom Client zu Ihrer API gesendet werden. Ein <abbr title="Antwortkörper">**Response**body</abbr> sind Daten, die Ihre API zum Client sendet.
 
-Ihre API sendet fast immer einen **Response**body. Aber Clients senden nicht unbedingt immer **Request**bodys (sondern nur Metadaten).
+Ihre API muss fast immer einen **Response**body senden. Aber Clients müssen nicht unbedingt immer **Requestbodys** senden, manchmal fordern sie nur einen Pfad an, vielleicht mit einigen Query-Parametern, aber senden keinen Body.
 
-Um einen **Request**body zu deklarieren, verwenden Sie <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a>-Modelle mit allen deren Fähigkeiten und Vorzügen.
+Um einen **Request**body zu deklarieren, verwenden Sie <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a>-Modelle mit all deren Fähigkeiten und Vorzügen.
 
-/// info
+/// info | Info
 
-Um Daten zu versenden, sollten Sie eines von: `POST` (meistverwendet), `PUT`, `DELETE` oder `PATCH` verwenden.
+Um Daten zu senden, sollten Sie eines von: `POST` (meistverwendet), `PUT`, `DELETE` oder `PATCH` verwenden.
 
-Senden Sie einen Body mit einem `GET`-Request, dann führt das laut Spezifikation zu undefiniertem Verhalten. Trotzdem wird es von FastAPI unterstützt, für sehr komplexe/extreme Anwendungsfälle.
+Das Senden eines Bodys mit einem `GET`-Request hat ein undefiniertes Verhalten in den Spezifikationen, wird aber dennoch von FastAPI unterstützt, nur für sehr komplexe/extreme Anwendungsfälle.
 
-Da aber davon abgeraten wird, zeigt die interaktive Dokumentation mit Swagger-Benutzeroberfläche die Dokumentation für den Body auch nicht an, wenn `GET` verwendet wird. Dazwischengeschaltete Proxys unterstützen es möglicherweise auch nicht.
+Da davon abgeraten wird, zeigt die interaktive Dokumentation mit Swagger-Benutzeroberfläche die Dokumentation für den Body nicht an, wenn `GET` verwendet wird, und zwischengeschaltete Proxys unterstützen es möglicherweise nicht.
 
 ///
 
-## Importieren Sie Pydantics `BaseModel`
+## Pydantics `BaseModel` importieren { #import-pydantics-basemodel }
 
 Zuerst müssen Sie `BaseModel` von `pydantic` importieren:
 
 {* ../../docs_src/body/tutorial001_py310.py hl[2] *}
 
-## Erstellen Sie Ihr Datenmodell
+## Ihr Datenmodell erstellen { #create-your-data-model }
 
 Dann deklarieren Sie Ihr Datenmodell als eine Klasse, die von `BaseModel` erbt.
 
-Verwenden Sie Standard-Python-Typen für die Klassenattribute:
+Verwenden Sie Standard-Python-Typen für alle Attribute:
 
 {* ../../docs_src/body/tutorial001_py310.py hl[5:9] *}
 
-Wie auch bei Query-Parametern gilt, wenn ein Modellattribut einen Defaultwert hat, ist das Attribut nicht erforderlich. Ansonsten ist es erforderlich. Verwenden Sie `None`, um es als optional zu kennzeichnen.
+Wie auch bei der Deklaration von Query-Parametern gilt: Wenn ein Modellattribut einen Defaultwert hat, ist das Attribut nicht erforderlich. Andernfalls ist es erforderlich. Verwenden Sie `None`, um es einfach optional zu machen.
 
-Zum Beispiel deklariert das obige Modell ein JSON "`object`" (oder Python-`dict`) wie dieses:
+Zum Beispiel deklariert das obige Modell ein JSON "`object`" (oder Python-<abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">`dict`</abbr>) wie dieses:
 
 ```JSON
 {
@@ -54,109 +54,112 @@ Da `description` und `tax` optional sind (mit `None` als Defaultwert), wäre fol
 }
 ```
 
-## Deklarieren Sie es als Parameter
+## Als Parameter deklarieren { #declare-it-as-a-parameter }
 
 Um es zu Ihrer *Pfadoperation* hinzuzufügen, deklarieren Sie es auf die gleiche Weise, wie Sie Pfad- und Query-Parameter deklariert haben:
 
 {* ../../docs_src/body/tutorial001_py310.py hl[16] *}
 
-... und deklarieren Sie seinen Typ als das Modell, welches Sie erstellt haben, `Item`.
+... und deklarieren Sie dessen Typ als das Modell, welches Sie erstellt haben, `Item`.
 
-## Resultate
+## Resultate { #results }
 
-Mit nur dieser Python-Typdeklaration, wird **FastAPI**:
+Mit nur dieser Python-Typdeklaration wird **FastAPI**:
 
 * Den Requestbody als JSON lesen.
 * Die entsprechenden Typen konvertieren (falls nötig).
 * Diese Daten validieren.
-    * Wenn die Daten ungültig sind, einen klar lesbaren Fehler zurückgeben, der anzeigt, wo und was die inkorrekten Daten waren.
+    * Wenn die Daten ungültig sind, wird ein klar lesbarer Fehler zurückgegeben, der genau anzeigt, wo und was die inkorrekten Daten sind.
 * Ihnen die erhaltenen Daten im Parameter `item` übergeben.
-    * Da Sie diesen in der Funktion als vom Typ `Item` deklariert haben, erhalten Sie die ganze Editor-Unterstützung (Autovervollständigung, usw.) für alle Attribute und deren Typen.
-* Eine <a href="https://json-schema.org" class="external-link" target="_blank">JSON Schema</a> Definition für Ihr Modell generieren, welche Sie überall sonst verwenden können, wenn es für Ihr Projekt Sinn macht.
-* Diese Schemas werden Teil des generierten OpenAPI-Schemas und werden von den <abbr title="User Interface – Benutzeroberfläche">UIs</abbr> der automatischen Dokumentation verwendet.
+    * Da Sie ihn in der Funktion als vom Typ `Item` deklariert haben, erhalten Sie auch die volle Unterstützung des Editors (Autovervollständigung, usw.) für alle Attribute und deren Typen.
+* <a href="https://json-schema.org" class="external-link" target="_blank">JSON Schema</a>-Definitionen für Ihr Modell generieren, die Sie auch überall sonst verwenden können, wenn es für Ihr Projekt Sinn macht.
+* Diese Schemas werden Teil des generierten OpenAPI-Schemas und werden von den <abbr title="User Interfaces – Benutzeroberflächen">UIs</abbr> der automatischen Dokumentation genutzt.
 
-## Automatische Dokumentation
+## Automatische Dokumentation { #automatic-docs }
 
-Die JSON-Schemas Ihrer Modelle werden Teil ihrer OpenAPI-generierten Schemas und werden in der interaktiven API Dokumentation angezeigt:
+Die JSON-Schemas Ihrer Modelle werden Teil Ihres OpenAPI-generierten Schemas und in der interaktiven API-Dokumentation angezeigt:
 
 <img src="/img/tutorial/body/image01.png">
 
-Und werden auch verwendet in der API-Dokumentation innerhalb jeder *Pfadoperation*, welche sie braucht:
+Und werden auch in der API-Dokumentation innerhalb jeder *Pfadoperation*, die sie benötigt, verwendet:
 
 <img src="/img/tutorial/body/image02.png">
 
-## Editor Unterstützung
+## Editor-Unterstützung { #editor-support }
 
-In Ihrem Editor, innerhalb Ihrer Funktion, erhalten Sie Typhinweise und Code-Vervollständigung überall (was nicht der Fall wäre, wenn Sie ein `dict` anstelle eines Pydantic Modells erhalten hätten):
+In Ihrem Editor erhalten Sie innerhalb Ihrer Funktion Typhinweise und Code-Vervollständigung überall (was nicht der Fall wäre, wenn Sie ein `dict` anstelle eines Pydantic-Modells erhalten hätten):
 
 <img src="/img/tutorial/body/image03.png">
 
-Sie bekommen auch Fehler-Meldungen für inkorrekte Typoperationen:
+Sie bekommen auch Fehlermeldungen für inkorrekte Typoperationen:
 
 <img src="/img/tutorial/body/image04.png">
 
 Das ist nicht zufällig so, das ganze Framework wurde um dieses Design herum aufgebaut.
 
-Und es wurde in der Designphase gründlich getestet, vor der Implementierung, um sicherzustellen, dass es mit jedem Editor funktioniert.
+Und es wurde in der Designphase gründlich getestet, bevor irgendeine Implementierung stattfand, um sicherzustellen, dass es mit allen Editoren funktioniert.
 
-Es gab sogar ein paar Änderungen an Pydantic selbst, um das zu unterstützen.
+Es gab sogar einige Änderungen an Pydantic selbst, um dies zu unterstützen.
 
-Die vorherigen Screenshots zeigten <a href="https://code.visualstudio.com" class="external-link" target="_blank">Visual Studio Code</a>.
+Die vorherigen Screenshots wurden mit <a href="https://code.visualstudio.com" class="external-link" target="_blank">Visual Studio Code</a> aufgenommen.
 
-Aber Sie bekommen die gleiche Editor-Unterstützung in <a href="https://www.jetbrains.com/pycharm/" class="external-link" target="_blank">PyCharm</a> und in den meisten anderen Python-Editoren:
+Aber Sie würden die gleiche Editor-Unterstützung in <a href="https://www.jetbrains.com/pycharm/" class="external-link" target="_blank">PyCharm</a> und den meisten anderen Python-Editoren erhalten:
 
 <img src="/img/tutorial/body/image05.png">
 
 /// tip | Tipp
 
-Wenn Sie <a href="https://www.jetbrains.com/pycharm/" class="external-link" target="_blank">PyCharm</a> als Ihren Editor verwenden, probieren Sie das <a href="https://github.com/koxudaxi/pydantic-pycharm-plugin/" class="external-link" target="_blank">Pydantic PyCharm Plugin</a> aus.
+Wenn Sie <a href="https://www.jetbrains.com/pycharm/" class="external-link" target="_blank">PyCharm</a> als Ihren Editor verwenden, können Sie das <a href="https://github.com/koxudaxi/pydantic-pycharm-plugin/" class="external-link" target="_blank">Pydantic PyCharm Plugin</a> ausprobieren.
 
 Es verbessert die Editor-Unterstützung für Pydantic-Modelle, mit:
 
 * Code-Vervollständigung
 * Typüberprüfungen
 * Refaktorisierung
-* Suchen
+* Suche
 * Inspektionen
 
 ///
 
-## Das Modell verwenden
+## Das Modell verwenden { #use-the-model }
 
-Innerhalb der Funktion können Sie alle Attribute des Modells direkt verwenden:
+Innerhalb der Funktion können Sie alle Attribute des Modellobjekts direkt verwenden:
 
-{* ../../docs_src/body/tutorial002_py310.py hl[19] *}
+{* ../../docs_src/body/tutorial002_py310.py *}
 
-## Requestbody- + Pfad-Parameter
+## Requestbody- + Pfad-Parameter { #request-body-path-parameters }
 
-Sie können Pfad- und Requestbody-Parameter gleichzeitig deklarieren.
+Sie können Pfad-Parameter und den Requestbody gleichzeitig deklarieren.
 
 **FastAPI** erkennt, dass Funktionsparameter, die mit Pfad-Parametern übereinstimmen, **vom Pfad genommen** werden sollen, und dass Funktionsparameter, welche Pydantic-Modelle sind, **vom Requestbody genommen** werden sollen.
 
 {* ../../docs_src/body/tutorial003_py310.py hl[15:16] *}
 
-## Requestbody- + Pfad- + Query-Parameter
+
+## Requestbody- + Pfad- + Query-Parameter { #request-body-path-query-parameters }
 
 Sie können auch zur gleichen Zeit **Body-**, **Pfad-** und **Query-Parameter** deklarieren.
 
-**FastAPI** wird jeden Parameter korrekt erkennen und die Daten vom richtigen Ort holen.
+**FastAPI** wird jeden von ihnen korrekt erkennen und die Daten vom richtigen Ort holen.
 
 {* ../../docs_src/body/tutorial004_py310.py hl[16] *}
 
 Die Funktionsparameter werden wie folgt erkannt:
 
-* Wenn der Parameter auch im **Pfad** deklariert wurde, wird er als Pfad-Parameter interpretiert.
+* Wenn der Parameter auch im **Pfad** deklariert wurde, wird er als Pfad-Parameter verwendet.
 * Wenn der Parameter ein **einfacher Typ** ist (wie `int`, `float`, `str`, `bool`, usw.), wird er als **Query**-Parameter interpretiert.
 * Wenn der Parameter vom Typ eines **Pydantic-Modells** ist, wird er als Request**body** interpretiert.
 
 /// note | Hinweis
 
-FastAPI weiß, dass der Wert von `q` nicht erforderlich ist, wegen des definierten Defaultwertes `= None`
+FastAPI weiß, dass der Wert von `q` nicht erforderlich ist, aufgrund des definierten Defaultwertes `= None`.
+
+Das `str | None` (Python 3.10+) oder `Union` in `Union[str, None]` (Python 3.8+) wird von FastAPI nicht verwendet, um zu bestimmen, dass der Wert nicht erforderlich ist. FastAPI weiß, dass er nicht erforderlich ist, weil er einen Standardwert von `= None` hat.
 
-Das `Union` in `Union[str, None]` wird von FastAPI nicht verwendet, aber es erlaubt Ihrem Editor, Sie besser zu unterstützen und Fehler zu erkennen.
+Das Hinzufügen der Typannotationen ermöglicht jedoch Ihrem Editor, Ihnen eine bessere Unterstützung zu bieten und Fehler zu erkennen.
 
 ///
 
-## Ohne Pydantic
+## Ohne Pydantic { #without-pydantic }
 
-Wenn Sie keine Pydantic-Modelle verwenden wollen, können Sie auch **Body**-Parameter nehmen. Siehe die Dokumentation unter [Body – Mehrere Parameter: Einfache Werte im Body](body-multiple-params.md#einzelne-werte-im-body){.internal-link target=\_blank}.
+Wenn Sie keine Pydantic-Modelle verwenden möchten, können Sie auch **Body**-Parameter verwenden. Siehe die Dokumentation unter [Body – Mehrere Parameter: Einfache Werte im Body](body-multiple-params.md#singular-values-in-body){.internal-link target=_blank}.

docs/de/docs/tutorial/cookie-param-models.md

@@ -0,0 +1,76 @@
+# Cookie-Parameter-Modelle { #cookie-parameter-models }
+
+Wenn Sie eine Gruppe von **Cookies** haben, die zusammengehören, können Sie ein **Pydantic-Modell** erstellen, um diese zu deklarieren. 🍪
+
+Damit können Sie das Modell an **mehreren Stellen wiederverwenden** und auch Validierungen und Metadaten für alle Parameter gleichzeitig deklarieren. 😎
+
+/// note | Hinweis
+
+Dies wird seit FastAPI Version `0.115.0` unterstützt. 🤓
+
+///
+
+/// tip | Tipp
+
+Diese gleiche Technik gilt für `Query`, `Cookie` und `Header`. 😎
+
+///
+
+## Cookies mit einem Pydantic-Modell { #cookies-with-a-pydantic-model }
+
+Deklarieren Sie die **Cookie**-Parameter, die Sie benötigen, in einem **Pydantic-Modell**, und deklarieren Sie dann den Parameter als `Cookie`:
+
+{* ../../docs_src/cookie_param_models/tutorial001_an_py310.py hl[9:12,16] *}
+
+**FastAPI** wird die Daten für **jedes Feld** aus den im <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> empfangenen **Cookies** **extrahieren** und Ihnen das von Ihnen definierte Pydantic-Modell bereitstellen.
+
+## Die Dokumentation testen { #check-the-docs }
+
+Sie können die definierten Cookies in der Dokumentationsoberfläche unter `/docs` sehen:
+
+<div class="screenshot">
+<img src="/img/tutorial/cookie-param-models/image01.png">
+</div>
+
+/// info | Info
+
+Bitte beachten Sie, dass Browser Cookies auf spezielle Weise und im Hintergrund bearbeiten, sodass sie **nicht** leicht **JavaScript** erlauben, diese zu berühren.
+
+Wenn Sie zur **API-Dokumentationsoberfläche** unter `/docs` gehen, können Sie die **Dokumentation** für Cookies für Ihre *Pfadoperationen* sehen.
+
+Aber selbst wenn Sie die **Daten ausfüllen** und auf „Ausführen“ klicken, werden aufgrund der Tatsache, dass die Dokumentationsoberfläche mit **JavaScript** arbeitet, die Cookies nicht gesendet, und Sie werden eine **Fehlermeldung** sehen, als ob Sie keine Werte eingegeben hätten.
+
+///
+
+## Zusätzliche Cookies verbieten { #forbid-extra-cookies }
+
+In einigen speziellen Anwendungsfällen (wahrscheinlich nicht sehr häufig) möchten Sie möglicherweise die Cookies, die Sie empfangen möchten, **einschränken**.
+
+Ihre API hat jetzt die Macht, ihre eigene <abbr title="Das ist ein Scherz, nur für den Fall. Es hat nichts mit Cookie-Einwilligungen zu tun, aber es ist witzig, dass selbst die API jetzt die armen Cookies ablehnen kann. Haben Sie einen Keks. 🍪">Cookie-Einwilligung</abbr> zu kontrollieren. 🤪🍪
+
+Sie können die Modellkonfiguration von Pydantic verwenden, um `extra` Felder zu verbieten (`forbid`):
+
+{* ../../docs_src/cookie_param_models/tutorial002_an_py39.py hl[10] *}
+
+Wenn ein Client versucht, einige **zusätzliche Cookies** zu senden, erhält er eine **Error-<abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr>**.
+
+Arme Cookie-Banner, wie sie sich mühen, Ihre Einwilligung zu erhalten, dass die <abbr title="Das ist ein weiterer Scherz. Beachten Sie mich nicht. Trinken Sie einen Kaffee zu Ihrem Keks. ☕">API sie ablehnen darf</abbr>. 🍪
+
+Wenn der Client beispielsweise versucht, ein `santa_tracker`-Cookie mit einem Wert von `good-list-please` zu senden, erhält der Client eine **Error-Response**, die ihm mitteilt, dass das `santa_tracker` <abbr title="Santa beschwert sich über den Mangel an Cookies. 🎅 Okay, keine Cookie-Witze mehr.">Cookie nicht erlaubt ist</abbr>:
+
+```json
+{
+    "detail": [
+        {
+            "type": "extra_forbidden",
+            "loc": ["cookie", "santa_tracker"],
+            "msg": "Extra inputs are not permitted",
+            "input": "good-list-please",
+        }
+    ]
+}
+```
+
+## Zusammenfassung { #summary }
+
+Sie können **Pydantic-Modelle** verwenden, um <abbr title="Nehmen Sie einen letzten Keks, bevor Sie gehen. 🍪">**Cookies**</abbr> in **FastAPI** zu deklarieren. 😎

docs/de/docs/tutorial/cookie-params.md

@@ -1,35 +1,35 @@
-# Cookie-Parameter
+# Cookie-Parameter { #cookie-parameters }
 
-So wie `Query`- und `Path`-Parameter können Sie auch <abbr title='Cookie – „Keks“: Mechanismus, der kurze Daten in Textform im Browser des Benutzers speichert und abfragt'>Cookie</abbr>-Parameter definieren.
+Sie können Cookie-Parameter auf die gleiche Weise definieren wie `Query`- und `Path`-Parameter.
 
-## `Cookie` importieren
+## `Cookie` importieren { #import-cookie }
 
 Importieren Sie zuerst `Cookie`:
 
 {* ../../docs_src/cookie_params/tutorial001_an_py310.py hl[3] *}
 
-## `Cookie`-Parameter deklarieren
+## `Cookie`-Parameter deklarieren { #declare-cookie-parameters }
 
-Dann deklarieren Sie Ihre Cookie-Parameter, auf die gleiche Weise, wie Sie auch `Path`- und `Query`-Parameter deklarieren.
+Deklarieren Sie dann die Cookie-Parameter mit derselben Struktur wie bei `Path` und `Query`.
 
-Der erste Wert ist der Typ. Sie können `Cookie` die gehabten Extra Validierungs- und Beschreibungsparameter hinzufügen. Danach können Sie einen Defaultwert vergeben:
+Sie können den Defaultwert sowie alle zusätzlichen Validierungen oder Annotierungsparameter definieren:
 
 {* ../../docs_src/cookie_params/tutorial001_an_py310.py hl[9] *}
 
 /// note | Technische Details
 
-`Cookie` ist eine Schwesterklasse von `Path` und `Query`. Sie erbt von derselben gemeinsamen `Param`-Elternklasse.
+`Cookie` ist eine „Schwester“-Klasse von `Path` und `Query`. Sie erbt auch von derselben gemeinsamen `Param`-Klasse.
 
-Aber erinnern Sie sich, dass, wenn Sie `Query`, `Path`, `Cookie` und andere von `fastapi` importieren, diese tatsächlich Funktionen sind, welche spezielle Klassen zurückgeben.
+Aber denken Sie daran, dass, wenn Sie `Query`, `Path`, `Cookie` und andere von `fastapi` importieren, diese tatsächlich Funktionen sind, die spezielle Klassen zurückgeben.
 
 ///
 
-/// info
+/// info | Info
 
-Um Cookies zu deklarieren, müssen Sie `Cookie` verwenden, da diese Parameter sonst als Query-Parameter interpretiert werden würden.
+Um Cookies zu deklarieren, müssen Sie `Cookie` verwenden, da die Parameter sonst als Query-Parameter interpretiert würden.
 
 ///
 
-## Zusammenfassung
+## Zusammenfassung { #recap }
 
-Deklarieren Sie Cookies mittels `Cookie`, auf die gleiche Weise wie bei `Query` und `Path`.
+Deklarieren Sie Cookies mit `Cookie` und verwenden Sie dabei das gleiche allgemeine Muster wie bei `Query` und `Path`.

docs/de/docs/tutorial/cors.md

@@ -0,0 +1,88 @@
+# CORS (Cross-Origin Resource Sharing) { #cors-cross-origin-resource-sharing }
+
+<a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS" class="external-link" target="_blank">CORS oder „<abbr title="Ressourcenfreigabe zwischen Ursprüngen">Cross-Origin Resource Sharing</abbr>“</a> bezieht sich auf Situationen, in denen ein Frontend, das in einem Browser läuft, JavaScript-Code enthält, der mit einem Backend kommuniziert, und das Backend sich in einem anderen „Origin“ als das Frontend befindet.
+
+## Origin { #origin }
+
+Ein <abbr title="Ursprung">Origin</abbr> ist die Kombination aus Protokoll (`http`, `https`), Domain (`myapp.com`, `localhost`, `localhost.tiangolo.com`) und Port (`80`, `443`, `8080`).
+
+Alle folgenden sind also unterschiedliche Origins:
+
+* `http://localhost`
+* `https://localhost`
+* `http://localhost:8080`
+
+Auch wenn sie alle in `localhost` sind, verwenden sie unterschiedliche Protokolle oder Ports, daher sind sie unterschiedliche „Origins“.
+
+## Schritte { #steps }
+
+Angenommen, Sie haben ein Frontend, das in Ihrem Browser unter `http://localhost:8080` läuft, und dessen JavaScript versucht, mit einem Backend zu kommunizieren, das unter `http://localhost` läuft (da wir keinen Port angegeben haben, geht der Browser vom Default-Port `80` aus).
+
+Dann wird der Browser ein HTTP-`OPTIONS`-<abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> an das `:80`-Backend senden, und wenn das Backend die entsprechenden Header sendet, die die Kommunikation von diesem anderen Origin (`http://localhost:8080`) autorisieren, lässt der `:8080`-Browser das JavaScript im Frontend seinen Request an das `:80`-Backend senden.
+
+Um dies zu erreichen, muss das `:80`-Backend eine Liste von „erlaubten Origins“ haben.
+
+In diesem Fall müsste die Liste `http://localhost:8080` enthalten, damit das `:8080`-Frontend korrekt funktioniert.
+
+## Wildcards { #wildcards }
+
+Es ist auch möglich, die Liste als `"*"` (ein „Wildcard“) zu deklarieren, um anzuzeigen, dass alle erlaubt sind.
+
+Aber das erlaubt nur bestimmte Arten der Kommunikation und schließt alles aus, was Anmeldeinformationen beinhaltet: Cookies, Autorisierungsheader wie die, die mit Bearer Tokens verwendet werden, usw.
+
+Um sicherzustellen, dass alles korrekt funktioniert, ist es besser, die erlaubten Origins explizit anzugeben.
+
+## `CORSMiddleware` verwenden { #use-corsmiddleware }
+
+Sie können das in Ihrer **FastAPI**-Anwendung mit der `CORSMiddleware` konfigurieren.
+
+* Importieren Sie `CORSMiddleware`.
+* Erstellen Sie eine Liste der erlaubten Origins (als Strings).
+* Fügen Sie es als „Middleware“ zu Ihrer **FastAPI**-Anwendung hinzu.
+
+Sie können auch angeben, ob Ihr Backend erlaubt:
+
+* Anmeldeinformationen (Autorisierungsheader, Cookies, usw.).
+* Bestimmte HTTP-Methoden (`POST`, `PUT`) oder alle mit der Wildcard `"*"`.
+* Bestimmte HTTP-Header oder alle mit der Wildcard `"*"`.
+
+{* ../../docs_src/cors/tutorial001.py hl[2,6:11,13:19] *}
+
+Die von der `CORSMiddleware`-Implementierung verwendeten Defaultparameter sind standardmäßig restriktiv, daher müssen Sie bestimmte Origins, Methoden oder Header ausdrücklich aktivieren, damit Browser sie in einem Cross-Domain-Kontext verwenden dürfen.
+
+Die folgenden Argumente werden unterstützt:
+
+* `allow_origins` - Eine Liste von Origins, die Cross-Origin-Requests machen dürfen. z. B. `['https://example.org', 'https://www.example.org']`. Sie können `['*']` verwenden, um jedes Origin zuzulassen.
+* `allow_origin_regex` - Ein Regex-String zum Abgleichen gegen Origins, die Cross-Origin-Requests machen dürfen. z. B. `'https://.*\.example\.org'`.
+* `allow_methods` - Eine Liste von HTTP-Methoden, die für Cross-Origin-Requests erlaubt sein sollen. Standardmäßig `['GET']`. Sie können `['*']` verwenden, um alle Standardmethoden zu erlauben.
+* `allow_headers` - Eine Liste von HTTP-Requestheadern, die für Cross-Origin-Requests unterstützt werden sollten. Standardmäßig `[]`. Sie können `['*']` verwenden, um alle Header zu erlauben. Die Header `Accept`, `Accept-Language`, `Content-Language` und `Content-Type` sind immer für <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests" class="external-link" rel="noopener" target="_blank">einfache CORS-Requests</a> erlaubt.
+* `allow_credentials` - Anzeigen, dass Cookies für Cross-Origin-Requests unterstützt werden sollten. Standardmäßig `False`.
+
+    Keines der `allow_origins`, `allow_methods` und `allow_headers` kann auf `['*']` gesetzt werden, wenn `allow_credentials` auf `True` gesetzt ist. Alle müssen <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#credentialed_requests_and_wildcards" class="external-link" rel="noopener" target="_blank">explizit angegeben</a> werden.
+
+* `expose_headers` - Angabe der Responseheader, auf die der Browser zugreifen können soll. Standardmäßig `[]`.
+* `max_age` - Legt eine maximale Zeit in Sekunden fest, die Browser CORS-Responses zwischenspeichern dürfen. Standardmäßig `600`.
+
+Die Middleware antwortet auf zwei besondere Arten von HTTP-Requests ...
+
+### CORS-Preflight-Requests { #cors-preflight-requests }
+
+Dies sind alle `OPTIONS`-Requests mit `Origin`- und `Access-Control-Request-Method`-Headern.
+
+In diesem Fall wird die Middleware den eingehenden Request abfangen und mit entsprechenden CORS-Headern, und entweder einer `200`- oder `400`-<abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> zu Informationszwecken antworten.
+
+### Einfache Requests { #simple-requests }
+
+Jeder Request mit einem `Origin`-Header. In diesem Fall wird die Middleware den Request wie gewohnt durchlassen, aber entsprechende CORS-Header in die Response aufnehmen.
+
+## Weitere Informationen { #more-info }
+
+Weitere Informationen zu <abbr title="Cross-Origin Resource Sharing – Ressourcenfreigabe zwischen Ursprüngen">CORS</abbr> finden Sie in der <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS" class="external-link" target="_blank">Mozilla CORS-Dokumentation</a>.
+
+/// note | Technische Details
+
+Sie könnten auch `from starlette.middleware.cors import CORSMiddleware` verwenden.
+
+**FastAPI** bietet mehrere Middlewares in `fastapi.middleware` nur als Komfort für Sie, den Entwickler. Aber die meisten der verfügbaren Middlewares stammen direkt von Starlette.
+
+///

docs/de/docs/tutorial/debugging.md

@@ -0,0 +1,113 @@
+# Debugging { #debugging }
+
+Sie können den Debugger in Ihrem Editor verbinden, zum Beispiel mit Visual Studio Code oder PyCharm.
+
+## `uvicorn` aufrufen { #call-uvicorn }
+
+Importieren und führen Sie `uvicorn` direkt in Ihrer FastAPI-Anwendung aus:
+
+{* ../../docs_src/debugging/tutorial001.py hl[1,15] *}
+
+### Über `__name__ == "__main__"` { #about-name-main }
+
+Der Hauptzweck von `__name__ == "__main__"` ist, dass Code ausgeführt wird, wenn Ihre Datei mit folgendem Befehl aufgerufen wird:
+
+<div class="termy">
+
+```console
+$ python myapp.py
+```
+
+</div>
+
+aber nicht aufgerufen wird, wenn eine andere Datei sie importiert, wie in:
+
+```Python
+from myapp import app
+```
+
+#### Weitere Details { #more-details }
+
+Angenommen, Ihre Datei heißt `myapp.py`.
+
+Wenn Sie sie mit folgendem Befehl ausführen:
+
+<div class="termy">
+
+```console
+$ python myapp.py
+```
+
+</div>
+
+dann hat in Ihrer Datei die interne Variable `__name__`, die von Python automatisch erstellt wird, als Wert den String `"__main__"`.
+
+Daher wird der Abschnitt:
+
+```Python
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+```
+
+ausgeführt.
+
+---
+
+Dies wird nicht passieren, wenn Sie das Modul (die Datei) importieren.
+
+Wenn Sie also eine weitere Datei `importer.py` mit folgendem Inhalt haben:
+
+```Python
+from myapp import app
+
+# Hier mehr Code
+```
+
+wird in diesem Fall in `myapp.py` die automatisch erstellte Variable `__name__` nicht den Wert `"__main__"` haben.
+
+Daher wird die Zeile:
+
+```Python
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+```
+
+nicht ausgeführt.
+
+/// info | Info
+
+Für weitere Informationen besuchen Sie bitte <a href="https://docs.python.org/3/library/__main__.html" class="external-link" target="_blank">die offizielle Python-Dokumentation</a>.
+
+///
+
+## Ihren Code mit Ihrem Debugger ausführen { #run-your-code-with-your-debugger }
+
+Da Sie den Uvicorn-Server direkt aus Ihrem Code ausführen, können Sie Ihr Python-Programm (Ihre FastAPI-Anwendung) direkt aus dem Debugger aufrufen.
+
+---
+
+Zum Beispiel können Sie in Visual Studio Code:
+
+* Zum „Debug“-Panel gehen.
+* „Konfiguration hinzufügen ...“ auswählen.
+* „Python“ auswählen.
+* Den Debugger mit der Option „`Python: Current File (Integrated Terminal)`“ ausführen.
+
+Der Server wird dann mit Ihrem **FastAPI**-Code gestartet, an Ihren Haltepunkten angehalten, usw.
+
+So könnte es aussehen:
+
+<img src="/img/tutorial/debugging/image01.png">
+
+---
+
+Wenn Sie Pycharm verwenden, können Sie:
+
+* Das Menü „Run“ öffnen.
+* Die Option „Debug ...“ auswählen.
+* Ein Kontextmenü wird angezeigt.
+* Die zu debuggende Datei auswählen (in diesem Fall `main.py`).
+
+Der Server wird dann mit Ihrem **FastAPI**-Code gestartet, an Ihren Haltepunkten angehalten, usw.
+
+So könnte es aussehen:
+
+<img src="/img/tutorial/debugging/image02.png">

docs/de/docs/tutorial/dependencies/classes-as-dependencies.md

@@ -1,10 +1,10 @@
-# Klassen als Abhängigkeiten
+# Klassen als Abhängigkeiten { #classes-as-dependencies }
 
 Bevor wir tiefer in das **Dependency Injection** System eintauchen, lassen Sie uns das vorherige Beispiel verbessern.
 
-## Ein `dict` aus dem vorherigen Beispiel
+## Ein `dict` aus dem vorherigen Beispiel { #a-dict-from-the-previous-example }
 
-Im vorherigen Beispiel haben wir ein `dict` von unserer Abhängigkeit („Dependable“) zurückgegeben:
+Im vorherigen Beispiel haben wir ein <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">`dict`</abbr> von unserer Abhängigkeit („Dependable“) zurückgegeben:
 
 {* ../../docs_src/dependencies/tutorial001_an_py310.py hl[9] *}
 
@@ -14,7 +14,7 @@ Und wir wissen, dass Editoren nicht viel Unterstützung (wie etwa Code-Vervollst
 
 Das können wir besser machen ...
 
-## Was macht eine Abhängigkeit aus
+## Was macht eine Abhängigkeit aus { #what-makes-a-dependency }
 
 Bisher haben Sie Abhängigkeiten gesehen, die als Funktionen deklariert wurden.
 
@@ -38,7 +38,7 @@ something(some_argument, some_keyword_argument="foo")
 
 dann ist das ein „Callable“ (ein „Aufrufbares“).
 
-## Klassen als Abhängigkeiten
+## Klassen als Abhängigkeiten { #classes-as-dependencies_1 }
 
 Möglicherweise stellen Sie fest, dass Sie zum Erstellen einer Instanz einer Python-Klasse die gleiche Syntax verwenden.
 
@@ -89,7 +89,7 @@ In beiden Fällen wird sie haben:
 
 In beiden Fällen werden die Daten konvertiert, validiert, im OpenAPI-Schema dokumentiert, usw.
 
-## Verwendung
+## Verwenden { #use-it }
 
 Jetzt können Sie Ihre Abhängigkeit mithilfe dieser Klasse deklarieren.
 
@@ -97,7 +97,7 @@ Jetzt können Sie Ihre Abhängigkeit mithilfe dieser Klasse deklarieren.
 
 **FastAPI** ruft die Klasse `CommonQueryParams` auf. Dadurch wird eine „Instanz“ dieser Klasse erstellt und die Instanz wird als Parameter `commons` an Ihre Funktion überreicht.
 
-## Typannotation vs. `Depends`
+## Typannotation vs. `Depends` { #type-annotation-vs-depends }
 
 Beachten Sie, wie wir `CommonQueryParams` im obigen Code zweimal schreiben:
 
@@ -193,7 +193,7 @@ Es wird jedoch empfohlen, den Typ zu deklarieren, da Ihr Editor so weiß, was al
 
 <img src="/img/tutorial/dependencies/image02.png">
 
-## Abkürzung
+## Abkürzung { #shortcut }
 
 Aber Sie sehen, dass wir hier etwas Codeduplizierung haben, indem wir `CommonQueryParams` zweimal schreiben:
 

docs/de/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md

@@ -1,14 +1,14 @@
-# Abhängigkeiten in Pfadoperation-Dekoratoren
+# Abhängigkeiten in Pfadoperation-Dekoratoren { #dependencies-in-path-operation-decorators }
 
 Manchmal benötigen Sie den Rückgabewert einer Abhängigkeit innerhalb Ihrer *Pfadoperation-Funktion* nicht wirklich.
 
 Oder die Abhängigkeit gibt keinen Wert zurück.
 
-Aber Sie müssen Sie trotzdem ausführen/auflösen.
+Aber Sie müssen sie trotzdem ausführen/auflösen.
 
 In diesen Fällen können Sie, anstatt einen Parameter der *Pfadoperation-Funktion* mit `Depends` zu deklarieren, eine `list`e von `dependencies` zum *Pfadoperation-Dekorator* hinzufügen.
 
-## `dependencies` zum *Pfadoperation-Dekorator* hinzufügen
+## `dependencies` zum *Pfadoperation-Dekorator* hinzufügen { #add-dependencies-to-the-path-operation-decorator }
 
 Der *Pfadoperation-Dekorator* erhält ein optionales Argument `dependencies`.
 
@@ -28,7 +28,7 @@ Damit wird auch vermieden, neue Entwickler möglicherweise zu verwirren, die ein
 
 ///
 
-/// info
+/// info | Info
 
 In diesem Beispiel verwenden wir zwei erfundene benutzerdefinierte Header `X-Key` und `X-Token`.
 
@@ -36,23 +36,23 @@ Aber in realen Fällen würden Sie bei der Implementierung von Sicherheit mehr V
 
 ///
 
-## Abhängigkeitsfehler und -Rückgabewerte
+## Abhängigkeitsfehler und -Rückgabewerte { #dependencies-errors-and-return-values }
 
 Sie können dieselben Abhängigkeits-*Funktionen* verwenden, die Sie normalerweise verwenden.
 
-### Abhängigkeitsanforderungen
+### Abhängigkeitsanforderungen { #dependency-requirements }
 
-Sie können Anforderungen für einen Request (wie Header) oder andere Unterabhängigkeiten deklarieren:
+Sie können Anforderungen für einen <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> (wie Header) oder andere Unterabhängigkeiten deklarieren:
 
 {* ../../docs_src/dependencies/tutorial006_an_py39.py hl[8,13] *}
 
-### Exceptions auslösen
+### Exceptions auslösen { #raise-exceptions }
 
 Die Abhängigkeiten können Exceptions `raise`n, genau wie normale Abhängigkeiten:
 
 {* ../../docs_src/dependencies/tutorial006_an_py39.py hl[10,15] *}
 
-### Rückgabewerte
+### Rückgabewerte { #return-values }
 
 Und sie können Werte zurückgeben oder nicht, die Werte werden nicht verwendet.
 
@@ -60,10 +60,10 @@ Sie können also eine normale Abhängigkeit (die einen Wert zurückgibt), die Si
 
 {* ../../docs_src/dependencies/tutorial006_an_py39.py hl[11,16] *}
 
-## Abhängigkeiten für eine Gruppe von *Pfadoperationen*
+## Abhängigkeiten für eine Gruppe von *Pfadoperationen* { #dependencies-for-a-group-of-path-operations }
 
 Wenn Sie später lesen, wie Sie größere Anwendungen strukturieren ([Größere Anwendungen – Mehrere Dateien](../../tutorial/bigger-applications.md){.internal-link target=_blank}), möglicherweise mit mehreren Dateien, lernen Sie, wie Sie einen einzelnen `dependencies`-Parameter für eine Gruppe von *Pfadoperationen* deklarieren.
 
-## Globale Abhängigkeiten
+## Globale Abhängigkeiten { #global-dependencies }
 
 Als Nächstes werden wir sehen, wie man Abhängigkeiten zur gesamten `FastAPI`-Anwendung hinzufügt, sodass sie für jede *Pfadoperation* gelten.

docs/de/docs/tutorial/dependencies/dependencies-with-yield.md

@@ -1,4 +1,4 @@
-# Abhängigkeiten mit yield
+# Abhängigkeiten mit `yield` { #dependencies-with-yield }
 
 FastAPI unterstützt Abhängigkeiten, die nach Abschluss einige <abbr title="Manchmal auch genannt „Exit Code“, „Cleanup Code“, „Teardown Code“, „Closing Code“, „Kontext Manager Exit Code“, usw.">zusätzliche Schritte ausführen</abbr>.
 
@@ -23,11 +23,11 @@ Tatsächlich verwendet FastAPI diese beiden Dekoratoren intern.
 
 ///
 
-## Eine Datenbank-Abhängigkeit mit `yield`.
+## Eine Datenbank-Abhängigkeit mit `yield` { #a-database-dependency-with-yield }
 
 Sie könnten damit beispielsweise eine Datenbanksession erstellen und diese nach Abschluss schließen.
 
-Nur der Code vor und einschließlich der `yield`-Anweisung wird ausgeführt, bevor eine Response erzeugt wird:
+Nur der Code vor und einschließlich der `yield`-Anweisung wird ausgeführt, bevor eine <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> erzeugt wird:
 
 {* ../../docs_src/dependencies/tutorial007.py hl[2:4] *}
 
@@ -35,19 +35,19 @@ Der ge`yield`ete Wert ist das, was in *Pfadoperationen* und andere Abhängigkeit
 
 {* ../../docs_src/dependencies/tutorial007.py hl[4] *}
 
-Der auf die `yield`-Anweisung folgende Code wird ausgeführt, nachdem die Response gesendet wurde:
+Der auf die `yield`-Anweisung folgende Code wird ausgeführt, nachdem die Response erstellt wurde, aber bevor sie gesendet wird:
 
 {* ../../docs_src/dependencies/tutorial007.py hl[5:6] *}
 
 /// tip | Tipp
 
-Sie können `async`hrone oder reguläre Funktionen verwenden.
+Sie können `async`- oder reguläre Funktionen verwenden.
 
 **FastAPI** wird bei jeder das Richtige tun, so wie auch bei normalen Abhängigkeiten.
 
 ///
 
-## Eine Abhängigkeit mit `yield` und `try`.
+## Eine Abhängigkeit mit `yield` und `try` { #a-dependency-with-yield-and-try }
 
 Wenn Sie einen `try`-Block in einer Abhängigkeit mit `yield` verwenden, empfangen Sie alle Exceptions, die bei Verwendung der Abhängigkeit geworfen wurden.
 
@@ -59,7 +59,7 @@ Auf die gleiche Weise können Sie `finally` verwenden, um sicherzustellen, dass
 
 {* ../../docs_src/dependencies/tutorial007.py hl[3,5] *}
 
-## Unterabhängigkeiten mit `yield`.
+## Unterabhängigkeiten mit `yield` { #sub-dependencies-with-yield }
 
 Sie können Unterabhängigkeiten und „Bäume“ von Unterabhängigkeiten beliebiger Größe und Form haben, und einige oder alle davon können `yield` verwenden.
 
@@ -93,7 +93,7 @@ Dieses funktioniert dank Pythons <a href="https://docs.python.org/3/library/cont
 
 ///
 
-## Abhängigkeiten mit `yield` und `HTTPException`.
+## Abhängigkeiten mit `yield` und `HTTPException` { #dependencies-with-yield-and-httpexception }
 
 Sie haben gesehen, dass Ihre Abhängigkeiten `yield` verwenden können und `try`-Blöcke haben können, die Exceptions abfangen.
 
@@ -109,9 +109,27 @@ Aber es ist für Sie da, wenn Sie es brauchen. 🤓
 
 {* ../../docs_src/dependencies/tutorial008b_an_py39.py hl[18:22,31] *}
 
-Eine Alternative zum Abfangen von Exceptions (und möglicherweise auch zum Auslösen einer weiteren `HTTPException`) besteht darin, einen [benutzerdefinierten Exceptionhandler](../handling-errors.md#benutzerdefinierte-exceptionhandler-definieren){.internal-link target=_blank} zu erstellen.
+Eine Alternative zum Abfangen von Exceptions (und möglicherweise auch zum Auslösen einer weiteren `HTTPException`) besteht darin, einen [benutzerdefinierten Exceptionhandler](../handling-errors.md#install-custom-exception-handlers){.internal-link target=_blank} zu erstellen.
 
-## Ausführung von Abhängigkeiten mit `yield`
+## Abhängigkeiten mit `yield` und `except` { #dependencies-with-yield-and-except }
+
+Wenn Sie eine Exception mit `except` in einer Abhängigkeit mit `yield` abfangen und sie nicht erneut auslösen (oder eine neue Exception auslösen), kann FastAPI nicht feststellen, dass es eine Exception gab, genau so wie es bei normalem Python der Fall wäre:
+
+{* ../../docs_src/dependencies/tutorial008c_an_py39.py hl[15:16] *}
+
+In diesem Fall sieht der Client eine *HTTP 500 Internal Server Error*-Response, wie es sein sollte, da wir keine `HTTPException` oder Ähnliches auslösen, aber der Server hat **keine Logs** oder einen anderen Hinweis darauf, was der Fehler war. 😱
+
+### In Abhängigkeiten mit `yield` und `except` immer `raise` verwenden { #always-raise-in-dependencies-with-yield-and-except }
+
+Wenn Sie eine Exception in einer Abhängigkeit mit `yield` abfangen, sollten Sie – sofern Sie nicht eine andere `HTTPException` oder Ähnliches auslösen – die ursprüngliche Exception erneut auslösen.
+
+Sie können dieselbe Exception mit `raise` erneut auslösen:
+
+{* ../../docs_src/dependencies/tutorial008d_an_py39.py hl[17] *}
+
+Jetzt erhält der Client dieselbe *HTTP 500 Internal Server Error*-Response, aber der Server enthält unseren benutzerdefinierten `InternalError` in den Logs. 😎
+
+## Ausführung von Abhängigkeiten mit `yield` { #execution-of-dependencies-with-yield }
 
 Die Ausführungsreihenfolge ähnelt mehr oder weniger dem folgenden Diagramm. Die Zeit verläuft von oben nach unten. Und jede Spalte ist einer der interagierenden oder Code-ausführenden Teilnehmer.
 
@@ -135,22 +153,22 @@ participant tasks as Hintergrundtasks
     opt Löst aus
         operation -->> dep: Löst Exception aus (z. B. HTTPException)
         opt Handhabt
-            dep -->> dep: Kann Exception abfangen, eine neue HTTPException auslösen, andere Exceptions auslösen
-            dep -->> handler: Leitet Exception automatisch weiter
+            dep -->> dep: Kann Exception abfangen, eine neue HTTPException auslösen, andere Exception auslösen
         end
         handler -->> client: HTTP-Error-Response
     end
+
     operation ->> client: Sendet Response an Client
-    Note over client,operation: Response wurde gesendet, kann nicht mehr geändert werden
+    Note over client,operation: Response wurde bereits gesendet, kann nicht mehr geändert werden
     opt Tasks
         operation -->> tasks: Sendet Hintergrundtasks
     end
     opt Löst andere Exception aus
-        tasks -->> tasks: Handhabt Exception im Hintergrundtask-Code
+        tasks -->> tasks: Handhabt Exceptions im Hintergrundtask-Code
     end
 ```
 
-/// info
+/// info | Info
 
 Es wird nur **eine Response** an den Client gesendet. Es kann eine Error-Response oder die Response der *Pfadoperation* sein.
 
@@ -160,13 +178,13 @@ Nachdem eine dieser Responses gesendet wurde, kann keine weitere Response gesend
 
 /// tip | Tipp
 
-Obiges Diagramm verwendet `HTTPException`, aber Sie können auch jede andere Exception auslösen, die Sie in einer Abhängigkeit mit `yield` abfangen, oder mit einem [benutzerdefinierten Exceptionhandler](../handling-errors.md#benutzerdefinierte-exceptionhandler-definieren){.internal-link target=_blank} erstellt haben.
+Obiges Diagramm verwendet `HTTPException`, aber Sie können auch jede andere Exception auslösen, die Sie in einer Abhängigkeit mit `yield` abfangen, oder mit einem [benutzerdefinierten Exceptionhandler](../handling-errors.md#install-custom-exception-handlers){.internal-link target=_blank} erstellt haben.
 
-Wenn Sie eine Exception auslösen, wird diese mit yield an die Abhängigkeiten übergeben, einschließlich `HTTPException`, und dann **erneut** an die Exceptionhandler. Wenn es für diese Exception keinen Exceptionhandler gibt, wird sie von der internen Default-`ServerErrorMiddleware` gehandhabt, was einen HTTP-Statuscode 500 zurückgibt, um den Client darüber zu informieren, dass ein Fehler auf dem Server aufgetreten ist.
+Wenn Sie eine Exception auslösen, wird sie an die Abhängigkeiten mit `yield` weitergegeben, einschließlich `HTTPException`. In den meisten Fällen sollten Sie dieselbe Exception oder eine neue aus der Abhängigkeit mit `yield` erneut auslösen, um sicherzustellen, dass sie korrekt gehandhabt wird.
 
 ///
 
-## Abhängigkeiten mit `yield`, `HTTPException` und Hintergrundtasks
+## Abhängigkeiten mit `yield`, `HTTPException`, `except` und Hintergrundtasks { #dependencies-with-yield-httpexception-except-and-background-tasks }
 
 /// warning | Achtung
 
@@ -176,7 +194,15 @@ Diese Details sind vor allem dann nützlich, wenn Sie eine Version von FastAPI v
 
 ///
 
-Vor FastAPI 0.106.0 war das Auslösen von Exceptions nach `yield` nicht möglich, der Exit-Code in Abhängigkeiten mit `yield` wurde ausgeführt, *nachdem* die Response gesendet wurde, die [Exceptionhandler](../handling-errors.md#benutzerdefinierte-exceptionhandler-definieren){.internal-link target=_blank} wären also bereits ausgeführt worden.
+### Abhängigkeiten mit `yield` und `except`, technische Details { #dependencies-with-yield-and-except-technical-details }
+
+Vor FastAPI 0.110.0 war es so, dass wenn Sie eine Abhängigkeit mit `yield` verwendeten und dort eine Exception mit `except` abfingen und die Exception nicht erneut auslösten, diese Exception automatisch an Exceptionhandler oder den internen Serverfehler-Handler weitergereicht/ausgelöst wurde.
+
+Dies wurde in Version 0.110.0 geändert, um unbehandelte Speichernutzung durch weitergereichte Exceptions ohne Handler (interne Serverfehler) zu beheben und um das Verhalten an regulären Python-Code anzugleichen.
+
+### Hintergrundtasks und Abhängigkeiten mit `yield`, technische Details { #background-tasks-and-dependencies-with-yield-technical-details }
+
+Vor FastAPI 0.106.0 war das Auslösen von Exceptions nach `yield` nicht möglich, der Exit-Code in Abhängigkeiten mit `yield` wurde ausgeführt, *nachdem* die Response gesendet wurde, die [Exceptionhandler](../handling-errors.md#install-custom-exception-handlers){.internal-link target=_blank} wären also bereits ausgeführt worden.
 
 Dies wurde hauptsächlich so konzipiert, damit die gleichen Objekte, die durch Abhängigkeiten ge`yield`et werden, innerhalb von Hintergrundtasks verwendet werden können, da der Exit-Code ausgeführt wird, nachdem die Hintergrundtasks abgeschlossen sind.
 
@@ -194,9 +220,9 @@ Wenn Sie sich früher auf dieses Verhalten verlassen haben, sollten Sie jetzt di
 
 Anstatt beispielsweise dieselbe Datenbanksitzung zu verwenden, würden Sie eine neue Datenbanksitzung innerhalb des Hintergrundtasks erstellen und die Objekte mithilfe dieser neuen Sitzung aus der Datenbank abrufen. Und anstatt das Objekt aus der Datenbank als Parameter an die Hintergrundtask-Funktion zu übergeben, würden Sie die ID dieses Objekts übergeben und das Objekt dann innerhalb der Hintergrundtask-Funktion erneut laden.
 
-## Kontextmanager
+## Kontextmanager { #context-managers }
 
-### Was sind „Kontextmanager“
+### Was sind „Kontextmanager“ { #what-are-context-managers }
 
 „Kontextmanager“ (Englisch „Context Manager“) sind bestimmte Python-Objekte, die Sie in einer `with`-Anweisung verwenden können.
 
@@ -210,11 +236,11 @@ with open("./somefile.txt") as f:
 
 Im Hintergrund erstellt das `open("./somefile.txt")` ein Objekt, das als „Kontextmanager“ bezeichnet wird.
 
-Dieser stellt sicher dass, wenn der `with`-Block beendet ist, die Datei geschlossen wird, auch wenn Exceptions geworfen wurden.
+Dieser stellt sicher, dass, wenn der `with`-Block beendet ist, die Datei geschlossen wird, auch wenn Exceptions geworfen wurden.
 
 Wenn Sie eine Abhängigkeit mit `yield` erstellen, erstellt **FastAPI** dafür intern einen Kontextmanager und kombiniert ihn mit einigen anderen zugehörigen Tools.
 
-### Kontextmanager in Abhängigkeiten mit `yield` verwenden
+### Kontextmanager in Abhängigkeiten mit `yield` verwenden { #using-context-managers-in-dependencies-with-yield }
 
 /// warning | Achtung
 

docs/de/docs/tutorial/dependencies/global-dependencies.md

@@ -1,4 +1,4 @@
-# Globale Abhängigkeiten
+# Globale Abhängigkeiten { #global-dependencies }
 
 Bei einigen Anwendungstypen möchten Sie möglicherweise Abhängigkeiten zur gesamten Anwendung hinzufügen.
 
@@ -8,8 +8,8 @@ In diesem Fall werden sie auf alle *Pfadoperationen* in der Anwendung angewendet
 
 {* ../../docs_src/dependencies/tutorial012_an_py39.py hl[16] *}
 
-Und alle Ideen aus dem Abschnitt über das [Hinzufügen von `dependencies` zu den *Pfadoperation-Dekoratoren*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank} gelten weiterhin, aber in diesem Fall für alle *Pfadoperationen* in der Anwendung.
+Und alle Ideen aus dem Abschnitt über das [Hinzufügen von `dependencies` zu den *Pfadoperation-Dekoratoren*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank} gelten weiterhin, aber in diesem Fall für alle *Pfadoperationen* in der App.
 
-## Abhängigkeiten für Gruppen von *Pfadoperationen*
+## Abhängigkeiten für Gruppen von *Pfadoperationen* { #dependencies-for-groups-of-path-operations }
 
-Wenn Sie später lesen, wie Sie größere Anwendungen strukturieren ([Bigger Applications - Multiple Files](../../tutorial/bigger-applications.md){.internal-link target=_blank}), möglicherweise mit mehreren Dateien, lernen Sie, wie Sie einen einzelnen `dependencies`-Parameter für eine Gruppe von *Pfadoperationen* deklarieren.
+Wenn Sie später lesen, wie Sie größere Anwendungen strukturieren ([Größere Anwendungen – mehrere Dateien](../../tutorial/bigger-applications.md){.internal-link target=_blank}), möglicherweise mit mehreren Dateien, lernen Sie, wie Sie einen einzelnen `dependencies`-Parameter für eine Gruppe von *Pfadoperationen* deklarieren.

docs/de/docs/tutorial/dependencies/index.md

@@ -1,10 +1,10 @@
-# Abhängigkeiten
+# Abhängigkeiten { #dependencies }
 
-**FastAPI** hat ein sehr mächtiges, aber intuitives **<abbr title="Dependency Injection – Einbringen von Abhängigkeiten: Auch bekannt als Komponenten, Ressourcen, Provider, Services, Injectables">Dependency Injection</abbr>** System.
+**FastAPI** hat ein sehr mächtiges, aber intuitives **<abbr title="Einbringen von Abhängigkeiten: auch bekannt als Komponenten, Ressourcen, Provider, Services, Injectables">Dependency Injection</abbr>** System.
 
 Es ist so konzipiert, sehr einfach zu verwenden zu sein und es jedem Entwickler sehr leicht zu machen, andere Komponenten mit **FastAPI** zu integrieren.
 
-## Was ist „Dependency Injection“
+## Was ist „Dependency Injection“ { #what-is-dependency-injection }
 
 **„Dependency Injection“** bedeutet in der Programmierung, dass es für Ihren Code (in diesem Fall Ihre *Pfadoperation-Funktionen*) eine Möglichkeit gibt, Dinge zu deklarieren, die er verwenden möchte und die er zum Funktionieren benötigt: „Abhängigkeiten“ – „Dependencies“.
 
@@ -19,13 +19,13 @@ Das ist sehr nützlich, wenn Sie:
 
 All dies, während Sie Codeverdoppelung minimieren.
 
-## Erste Schritte
+## Erste Schritte { #first-steps }
 
 Sehen wir uns ein sehr einfaches Beispiel an. Es ist so einfach, dass es vorerst nicht sehr nützlich ist.
 
 Aber so können wir uns besser auf die Funktionsweise des **Dependency Injection** Systems konzentrieren.
 
-### Erstellen Sie eine Abhängigkeit (<abbr title="Das von dem abhängt, die zu verwendende Abhängigkeit">„Dependable“</abbr>)
+### Eine Abhängigkeit erstellen, oder <abbr title="Das von dem abhängt, die zu verwendende Abhängigkeit">„Dependable“</abbr> { #create-a-dependency-or-dependable }
 
 Konzentrieren wir uns zunächst auf die Abhängigkeit - die Dependency.
 
@@ -48,23 +48,23 @@ In diesem Fall erwartet diese Abhängigkeit:
 * Einen optionalen Query-Parameter `skip`, der ein `int` ist und standardmäßig `0` ist.
 * Einen optionalen Query-Parameter `limit`, der ein `int` ist und standardmäßig `100` ist.
 
-Und dann wird einfach ein `dict` zurückgegeben, welches diese Werte enthält.
+Und dann wird einfach ein <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">`dict`</abbr> zurückgegeben, welches diese Werte enthält.
 
-/// info
+/// info | Info
 
 FastAPI unterstützt (und empfiehlt die Verwendung von) `Annotated` seit Version 0.95.0.
 
 Wenn Sie eine ältere Version haben, werden Sie Fehler angezeigt bekommen, wenn Sie versuchen, `Annotated` zu verwenden.
 
-Bitte [aktualisieren Sie FastAPI](../../deployment/versions.md#upgrade-der-fastapi-versionen){.internal-link target=_blank} daher mindestens zu Version 0.95.1, bevor Sie `Annotated` verwenden.
+Bitte [aktualisieren Sie FastAPI](../../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} daher mindestens zu Version 0.95.1, bevor Sie `Annotated` verwenden.
 
 ///
 
-### `Depends` importieren
+### `Depends` importieren { #import-depends }
 
 {* ../../docs_src/dependencies/tutorial001_an_py310.py hl[3] *}
 
-### Deklarieren der Abhängigkeit im <abbr title="Das Abhängige, der Verwender der Abhängigkeit">„Dependant“</abbr>
+### Die Abhängigkeit im <abbr title="Das Abhängige, der Verwender der Abhängigkeit">„Dependant“</abbr> deklarieren { #declare-the-dependency-in-the-dependant }
 
 So wie auch `Body`, `Query`, usw., verwenden Sie `Depends` mit den Parametern Ihrer *Pfadoperation-Funktion*:
 
@@ -86,7 +86,7 @@ Im nächsten Kapitel erfahren Sie, welche anderen „Dinge“, außer Funktionen
 
 ///
 
-Immer wenn ein neuer Request eintrifft, kümmert sich **FastAPI** darum:
+Immer wenn ein neuer <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> eintrifft, kümmert sich **FastAPI** darum:
 
 * Ihre Abhängigkeitsfunktion („Dependable“) mit den richtigen Parametern aufzurufen.
 * Sich das Ergebnis von dieser Funktion zu holen.
@@ -105,7 +105,7 @@ common_parameters --> read_users
 
 Auf diese Weise schreiben Sie gemeinsam genutzten Code nur einmal, und **FastAPI** kümmert sich darum, ihn für Ihre *Pfadoperationen* aufzurufen.
 
-/// check
+/// check | Testen
 
 Beachten Sie, dass Sie keine spezielle Klasse erstellen und diese irgendwo an **FastAPI** übergeben müssen, um sie zu „registrieren“ oder so ähnlich.
 
@@ -113,7 +113,7 @@ Sie übergeben es einfach an `Depends` und **FastAPI** weiß, wie der Rest erled
 
 ///
 
-## `Annotated`-Abhängigkeiten wiederverwenden
+## `Annotated`-Abhängigkeiten wiederverwenden { #share-annotated-dependencies }
 
 In den Beispielen oben sehen Sie, dass es ein kleines bisschen **Codeverdoppelung** gibt.
 
@@ -139,7 +139,7 @@ Die Abhängigkeiten funktionieren weiterhin wie erwartet, und das **Beste daran*
 
 Das ist besonders nützlich, wenn Sie es in einer **großen Codebasis** verwenden, in der Sie in **vielen *Pfadoperationen*** immer wieder **dieselben Abhängigkeiten** verwenden.
 
-## `async` oder nicht `async`
+## `async` oder nicht `async` { #to-async-or-not-to-async }
 
 Da Abhängigkeiten auch von **FastAPI** aufgerufen werden (so wie Ihre *Pfadoperation-Funktionen*), gelten beim Definieren Ihrer Funktionen die gleichen Regeln.
 
@@ -151,11 +151,11 @@ Es spielt keine Rolle. **FastAPI** weiß, was zu tun ist.
 
 /// note | Hinweis
 
-Wenn Ihnen das nichts sagt, lesen Sie den [Async: *„In Eile?“*](../../async.md#in-eile){.internal-link target=_blank}-Abschnitt über `async` und `await` in der Dokumentation.
+Wenn Ihnen das nichts sagt, lesen Sie den [Async: *„In Eile?“*](../../async.md#in-a-hurry){.internal-link target=_blank}-Abschnitt über `async` und `await` in der Dokumentation.
 
 ///
 
-## Integriert in OpenAPI
+## Integriert in OpenAPI { #integrated-with-openapi }
 
 Alle Requestdeklarationen, -validierungen und -anforderungen Ihrer Abhängigkeiten (und Unterabhängigkeiten) werden in dasselbe OpenAPI-Schema integriert.
 
@@ -163,9 +163,9 @@ Die interaktive Dokumentation enthält also auch alle Informationen aus diesen A
 
 <img src="/img/tutorial/dependencies/image01.png">
 
-## Einfache Verwendung
+## Einfache Verwendung { #simple-usage }
 
-Näher betrachtet, werden *Pfadoperation-Funktionen* deklariert, um verwendet zu werden, wann immer ein *Pfad* und eine *Operation* übereinstimmen, und dann kümmert sich **FastAPI** darum, die Funktion mit den richtigen Parametern aufzurufen, die Daten aus der Anfrage extrahierend.
+Näher betrachtet, werden *Pfadoperation-Funktionen* deklariert, um verwendet zu werden, wann immer ein *Pfad* und eine *Operation* übereinstimmen, und dann kümmert sich **FastAPI** darum, die Funktion mit den richtigen Parametern aufzurufen, die Daten aus dem Request extrahierend.
 
 Tatsächlich funktionieren alle (oder die meisten) Webframeworks auf die gleiche Weise.
 
@@ -181,7 +181,7 @@ Andere gebräuchliche Begriffe für dieselbe Idee der „Abhängigkeitsinjektion
 * Injectables
 * Komponenten
 
-## **FastAPI**-Plugins
+## **FastAPI**-Plugins { #fastapi-plug-ins }
 
 Integrationen und „Plugins“ können mit dem **Dependency Injection** System erstellt werden. Aber tatsächlich besteht **keine Notwendigkeit, „Plugins“ zu erstellen**, da es durch die Verwendung von Abhängigkeiten möglich ist, eine unendliche Anzahl von Integrationen und Interaktionen zu deklarieren, die dann für Ihre *Pfadoperation-Funktionen* verfügbar sind.
 
@@ -189,7 +189,7 @@ Und Abhängigkeiten können auf sehr einfache und intuitive Weise erstellt werde
 
 Beispiele hierfür finden Sie in den nächsten Kapiteln zu relationalen und NoSQL-Datenbanken, Sicherheit usw.
 
-## **FastAPI**-Kompatibilität
+## **FastAPI**-Kompatibilität { #fastapi-compatibility }
 
 Die Einfachheit des Dependency Injection Systems macht **FastAPI** kompatibel mit:
 
@@ -199,10 +199,10 @@ Die Einfachheit des Dependency Injection Systems macht **FastAPI** kompatibel mi
 * externen APIs
 * Authentifizierungs- und Autorisierungssystemen
 * API-Nutzungs-Überwachungssystemen
-* Responsedaten-Injektionssystemen
+* <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Responsedaten</abbr>-Injektionssystemen
 * usw.
 
-## Einfach und leistungsstark
+## Einfach und leistungsstark { #simple-and-powerful }
 
 Obwohl das hierarchische Dependency Injection System sehr einfach zu definieren und zu verwenden ist, ist es dennoch sehr mächtig.
 
@@ -242,7 +242,7 @@ admin_user --> activate_user
 paying_user --> pro_items
 ```
 
-## Integriert mit **OpenAPI**
+## Integriert mit **OpenAPI** { #integrated-with-openapi_1 }
 
 Alle diese Abhängigkeiten, während sie ihre Anforderungen deklarieren, fügen auch Parameter, Validierungen, usw. zu Ihren *Pfadoperationen* hinzu.
 

docs/de/docs/tutorial/dependencies/sub-dependencies.md

@@ -1,4 +1,4 @@
-# Unterabhängigkeiten
+# Unterabhängigkeiten { #sub-dependencies }
 
 Sie können Abhängigkeiten erstellen, die **Unterabhängigkeiten** haben.
 
@@ -6,17 +6,17 @@ Diese können so **tief** verschachtelt sein, wie nötig.
 
 **FastAPI** kümmert sich darum, sie aufzulösen.
 
-## Erste Abhängigkeit, „Dependable“
+## Erste Abhängigkeit, „Dependable“ { #first-dependency-dependable }
 
 Sie könnten eine erste Abhängigkeit („Dependable“) wie folgt erstellen:
 
 {* ../../docs_src/dependencies/tutorial005_an_py310.py hl[8:9] *}
 
-Diese deklariert einen optionalen Abfrageparameter `q` vom Typ `str` und gibt ihn dann einfach zurück.
+Diese deklariert einen optionalen Query-Parameter `q` vom Typ `str` und gibt ihn dann einfach zurück.
 
 Das ist recht einfach (nicht sehr nützlich), hilft uns aber dabei, uns auf die Funktionsweise der Unterabhängigkeiten zu konzentrieren.
 
-## Zweite Abhängigkeit, „Dependable“ und „Dependant“
+## Zweite Abhängigkeit, „Dependable“ und „Dependant“ { #second-dependency-dependable-and-dependant }
 
 Dann können Sie eine weitere Abhängigkeitsfunktion (ein „Dependable“) erstellen, die gleichzeitig eine eigene Abhängigkeit deklariert (also auch ein „Dependant“ ist):
 
@@ -29,17 +29,17 @@ Betrachten wir die deklarierten Parameter:
 * Sie deklariert außerdem ein optionales `last_query`-Cookie, ein `str`.
     * Wenn der Benutzer keine Query `q` übermittelt hat, verwenden wir die zuletzt übermittelte Query, die wir zuvor in einem Cookie gespeichert haben.
 
-## Die Abhängigkeit verwenden
+## Die Abhängigkeit verwenden { #use-the-dependency }
 
 Diese Abhängigkeit verwenden wir nun wie folgt:
 
 {* ../../docs_src/dependencies/tutorial005_an_py310.py hl[23] *}
 
-/// info
+/// info | Info
 
 Beachten Sie, dass wir in der *Pfadoperation-Funktion* nur eine einzige Abhängigkeit deklarieren, den `query_or_cookie_extractor`.
 
-Aber **FastAPI** wird wissen, dass es zuerst `query_extractor` auflösen muss, um dessen Resultat `query_or_cookie_extractor` zu übergeben, wenn dieses aufgerufen wird.
+Aber **FastAPI** wird wissen, dass es zuerst `query_extractor` auflösen muss, um dessen Resultat an `query_or_cookie_extractor` zu übergeben, wenn dieses aufgerufen wird.
 
 ///
 
@@ -54,13 +54,13 @@ read_query["/items/"]
 query_extractor --> query_or_cookie_extractor --> read_query
 ```
 
-## Dieselbe Abhängigkeit mehrmals verwenden
+## Dieselbe Abhängigkeit mehrmals verwenden { #using-the-same-dependency-multiple-times }
 
-Wenn eine Ihrer Abhängigkeiten mehrmals für dieselbe *Pfadoperation* deklariert wird, beispielsweise wenn mehrere Abhängigkeiten eine gemeinsame Unterabhängigkeit haben, wird **FastAPI** diese Unterabhängigkeit nur einmal pro Request aufrufen.
+Wenn eine Ihrer Abhängigkeiten mehrmals für dieselbe *Pfadoperation* deklariert wird, beispielsweise wenn mehrere Abhängigkeiten eine gemeinsame Unterabhängigkeit haben, wird **FastAPI** diese Unterabhängigkeit nur einmal pro <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> aufrufen.
 
 Und es speichert den zurückgegebenen Wert in einem <abbr title="Mechanismus, der bereits berechnete/generierte Werte zwischenspeichert, um sie später wiederzuverwenden, anstatt sie erneut zu berechnen.">„Cache“</abbr> und übergibt diesen gecachten Wert an alle „Dependanten“, die ihn in diesem spezifischen Request benötigen, anstatt die Abhängigkeit mehrmals für denselben Request aufzurufen.
 
-In einem fortgeschrittenen Szenario, bei dem Sie wissen, dass die Abhängigkeit bei jedem Schritt (möglicherweise mehrmals) in derselben Anfrage aufgerufen werden muss, anstatt den zwischengespeicherten Wert zu verwenden, können Sie den Parameter `use_cache=False` festlegen, wenn Sie `Depends` verwenden:
+In einem fortgeschrittenen Szenario, bei dem Sie wissen, dass die Abhängigkeit bei jedem Schritt (möglicherweise mehrmals) in demselben Request aufgerufen werden muss, anstatt den zwischengespeicherten Wert zu verwenden, können Sie den Parameter `use_cache=False` festlegen, wenn Sie `Depends` verwenden:
 
 //// tab | Python 3.8+
 
@@ -86,7 +86,7 @@ async def needy_dependency(fresh_value: str = Depends(get_value, use_cache=False
 
 ////
 
-## Zusammenfassung
+## Zusammenfassung { #recap }
 
 Abgesehen von all den ausgefallenen Wörtern, die hier verwendet werden, ist das **Dependency Injection**-System recht simpel.
 

docs/de/docs/tutorial/encoder.md

@@ -1,12 +1,12 @@
-# JSON-kompatibler Encoder
+# JSON-kompatibler Encoder { #json-compatible-encoder }
 
-Es gibt Fälle, da möchten Sie einen Datentyp (etwa ein Pydantic-Modell) in etwas konvertieren, das kompatibel mit JSON ist (etwa ein `dict`, eine `list`e, usw.).
+Es gibt Fälle, da möchten Sie einen Datentyp (etwa ein Pydantic-Modell) in etwas konvertieren, das kompatibel mit JSON ist (etwa ein `dict`, eine `list`, usw.).
 
 Zum Beispiel, wenn Sie es in einer Datenbank speichern möchten.
 
 Dafür bietet **FastAPI** eine Funktion `jsonable_encoder()`.
 
-## `jsonable_encoder` verwenden
+## `jsonable_encoder` verwenden { #using-the-jsonable-encoder }
 
 Stellen wir uns vor, Sie haben eine Datenbank `fake_db`, die nur JSON-kompatible Daten entgegennimmt.
 

docs/de/docs/tutorial/extra-data-types.md

@@ -1,4 +1,4 @@
-# Zusätzliche Datentypen
+# Zusätzliche Datentypen { #extra-data-types }
 
 Bisher haben Sie gängige Datentypen verwendet, wie zum Beispiel:
 
@@ -12,12 +12,12 @@ Sie können aber auch komplexere Datentypen verwenden.
 Und Sie haben immer noch dieselbe Funktionalität wie bisher gesehen:
 
 * Großartige Editor-Unterstützung.
-* Datenkonvertierung bei eingehenden Requests.
-* Datenkonvertierung für Response-Daten.
+* Datenkonvertierung bei eingehenden <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Requests</abbr>.
+* Datenkonvertierung für <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr>-Daten.
 * Datenvalidierung.
 * Automatische Annotation und Dokumentation.
 
-## Andere Datentypen
+## Andere Datentypen { #other-data-types }
 
 Hier sind einige der zusätzlichen Datentypen, die Sie verwenden können:
 
@@ -36,11 +36,11 @@ Hier sind einige der zusätzlichen Datentypen, die Sie verwenden können:
 * `datetime.timedelta`:
     * Ein Python-`datetime.timedelta`.
     * Wird in Requests und Responses als `float` der Gesamtsekunden dargestellt.
-    * Pydantic ermöglicht auch die Darstellung als „ISO 8601 Zeitdifferenz-Kodierung“, <a href="https://docs.pydantic.dev/1.10/usage/exporting_models/#json_encoders" class="external-link" target="_blank">Weitere Informationen finden Sie in der Dokumentation</a>.
+    * Pydantic ermöglicht auch die Darstellung als „ISO 8601 Zeitdifferenz-Kodierung“, <a href="https://docs.pydantic.dev/latest/concepts/serialization/#custom-serializers" class="external-link" target="_blank">siehe die Dokumentation für weitere Informationen</a>.
 * `frozenset`:
     * Wird in Requests und Responses wie ein `set` behandelt:
         * Bei Requests wird eine Liste gelesen, Duplikate entfernt und in ein `set` umgewandelt.
-        * Bei Responses wird das `set` in eine `list`e umgewandelt.
+        * Bei Responses wird das `set` in eine `list` umgewandelt.
         * Das generierte Schema zeigt an, dass die `set`-Werte eindeutig sind (unter Verwendung von JSON Schemas `uniqueItems`).
 * `bytes`:
     * Standard-Python-`bytes`.
@@ -49,9 +49,9 @@ Hier sind einige der zusätzlichen Datentypen, die Sie verwenden können:
 * `Decimal`:
     * Standard-Python-`Decimal`.
     * In Requests und Responses wird es wie ein `float` behandelt.
-* Sie können alle gültigen Pydantic-Datentypen hier überprüfen: <a href="https://docs.pydantic.dev/latest/usage/types/types/" class="external-link" target="_blank">Pydantic data types</a>.
+* Sie können alle gültigen Pydantic-Datentypen hier überprüfen: <a href="https://docs.pydantic.dev/latest/usage/types/types/" class="external-link" target="_blank">Pydantic-Datentypen</a>.
 
-## Beispiel
+## Beispiel { #example }
 
 Hier ist ein Beispiel für eine *Pfadoperation* mit Parametern, die einige der oben genannten Typen verwenden.
 

docs/de/docs/tutorial/extra-models.md

@@ -1,42 +1,42 @@
-# Extramodelle
+# Extramodelle { #extra-models }
 
-Fahren wir beim letzten Beispiel fort. Es gibt normalerweise mehrere zusammengehörende Modelle.
+Im Anschluss an das vorherige Beispiel ist es üblich, mehr als ein zusammenhängendes Modell zu haben.
 
-Insbesondere Benutzermodelle, denn:
+Dies gilt insbesondere für Benutzermodelle, denn:
 
-* Das **hereinkommende Modell** sollte ein Passwort haben können.
-* Das **herausgehende Modell** sollte kein Passwort haben.
-* Das **Datenbankmodell** sollte wahrscheinlich ein <abbr title='Ein aus scheinbar zufälligen Zeichen bestehender „Fingerabdruck“ eines Textes. Der Inhalt des Textes kann nicht eingesehen werden.'>gehashtes</abbr> Passwort haben.
+* Das **Eingabemodell** muss ein Passwort enthalten können.
+* Das **Ausgabemodell** sollte kein Passwort haben.
+* Das **Datenbankmodell** müsste wahrscheinlich ein gehashtes Passwort haben.
 
 /// danger | Gefahr
 
-Speichern Sie niemals das Klartext-Passwort eines Benutzers. Speichern Sie immer den „sicheren Hash“, den Sie verifizieren können.
+Speichern Sie niemals das Klartextpasswort eines Benutzers. Speichern Sie immer einen „sicheren Hash“, den Sie dann verifizieren können.
 
-Falls Ihnen das nichts sagt, in den [Sicherheits-Kapiteln](security/simple-oauth2.md#passwort-hashing){.internal-link target=_blank} werden Sie lernen, was ein „Passwort-Hash“ ist.
+Wenn Sie nicht wissen, was das ist, werden Sie in den [Sicherheitskapiteln](security/simple-oauth2.md#password-hashing){.internal-link target=_blank} lernen, was ein „Passworthash“ ist.
 
 ///
 
-## Mehrere Modelle
+## Mehrere Modelle { #multiple-models }
 
-Hier der generelle Weg, wie die Modelle mit ihren Passwort-Feldern aussehen könnten, und an welchen Orten sie verwendet werden würden.
+Hier ist eine allgemeine Idee, wie die Modelle mit ihren Passwortfeldern aussehen könnten und an welchen Stellen sie verwendet werden:
 
 {* ../../docs_src/extra_models/tutorial001_py310.py hl[7,9,14,20,22,27:28,31:33,38:39] *}
 
-/// info
+/// info | Info
 
-In Pydantic v1 hieß diese Methode `.dict()`, in Pydantic v2 wurde sie deprecated (aber immer noch unterstützt) und in `.model_dump()` umbenannt.
+In Pydantic v1 hieß die Methode `.dict()`, in Pydantic v2 wurde sie <abbr title="veraltet, obsolet: Es soll nicht mehr verwendet werden">deprecatet</abbr> (aber weiterhin unterstützt) und in `.model_dump()` umbenannt.
 
-Die Beispiele hier verwenden `.dict()` für die Kompatibilität mit Pydantic v1, Sie sollten jedoch stattdessen `.model_dump()` verwenden, wenn Sie Pydantic v2 verwenden können.
+Die Beispiele hier verwenden `.dict()` für die Kompatibilität mit Pydantic v1, aber Sie sollten `.model_dump()` verwenden, wenn Sie Pydantic v2 verwenden können.
 
 ///
 
-### Über `**user_in.dict()`
+### Über `**user_in.dict()` { #about-user-in-dict }
 
-#### Pydantic's `.dict()`
+#### Die `.dict()`-Methode von Pydantic { #pydantics-dict }
 
 `user_in` ist ein Pydantic-Modell der Klasse `UserIn`.
 
-Pydantic-Modelle haben eine `.dict()`-Methode, die ein `dict` mit den Daten des Modells zurückgibt.
+Pydantic-Modelle haben eine `.dict()`-Methode, die ein <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">`dict`</abbr> mit den Daten des Modells zurückgibt.
 
 Wenn wir also ein Pydantic-Objekt `user_in` erstellen, etwa so:
 
@@ -44,21 +44,21 @@ Wenn wir also ein Pydantic-Objekt `user_in` erstellen, etwa so:
 user_in = UserIn(username="john", password="secret", email="john.doe@example.com")
 ```
 
-und wir rufen seine `.dict()`-Methode auf:
+und dann aufrufen:
 
 ```Python
 user_dict = user_in.dict()
 ```
 
-dann haben wir jetzt in der Variable `user_dict` ein `dict` mit den gleichen Daten (es ist ein `dict` statt eines Pydantic-Modellobjekts).
+haben wir jetzt ein `dict` mit den Daten in der Variablen `user_dict` (es ist ein `dict` statt eines Pydantic-Modellobjekts).
 
-Wenn wir es ausgeben:
+Und wenn wir aufrufen:
 
 ```Python
 print(user_dict)
 ```
 
-bekommen wir ein Python-`dict`:
+würden wir ein Python-`dict` erhalten mit:
 
 ```Python
 {
@@ -69,17 +69,17 @@ bekommen wir ein Python-`dict`:
 }
 ```
 
-#### Ein `dict` entpacken
+#### Ein `dict` entpacken { #unpacking-a-dict }
 
-Wenn wir ein `dict` wie `user_dict` nehmen, und es einer Funktion (oder Klassenmethode) mittels `**user_dict` übergeben, wird Python es „entpacken“. Es wird die Schlüssel und Werte von `user_dict` direkt als Schlüsselwort-Argumente übergeben.
+Wenn wir ein `dict` wie `user_dict` nehmen und es einer Funktion (oder Klasse) mit `**user_dict` übergeben, wird Python es „entpacken“. Es wird die Schlüssel und Werte von `user_dict` direkt als Schlüsselwort-Argumente übergeben.
 
-Wenn wir also das `user_dict` von oben nehmen und schreiben:
+Setzen wir also das `user_dict` von oben ein:
 
 ```Python
 UserInDB(**user_dict)
 ```
 
-dann ist das ungefähr äquivalent zu:
+so ist das äquivalent zu:
 
 ```Python
 UserInDB(
@@ -90,7 +90,7 @@ UserInDB(
 )
 ```
 
-Oder, präziser, `user_dict` wird direkt verwendet, welche Werte es auch immer haben mag:
+Oder genauer gesagt, dazu, `user_dict` direkt zu verwenden, mit welchen Inhalten es auch immer in der Zukunft haben mag:
 
 ```Python
 UserInDB(
@@ -101,34 +101,34 @@ UserInDB(
 )
 ```
 
-#### Ein Pydantic-Modell aus den Inhalten eines anderen erstellen.
+#### Ein Pydantic-Modell aus dem Inhalt eines anderen { #a-pydantic-model-from-the-contents-of-another }
 
-Da wir in obigem Beispiel `user_dict` mittels `user_in.dict()` erzeugt haben, ist dieser Code:
+Da wir im obigen Beispiel `user_dict` von `user_in.dict()` bekommen haben, wäre dieser Code:
 
 ```Python
 user_dict = user_in.dict()
 UserInDB(**user_dict)
 ```
 
-äquivalent zu:
+gleichwertig zu:
 
 ```Python
 UserInDB(**user_in.dict())
 ```
 
-... weil `user_in.dict()` ein `dict` ist, und dann lassen wir Python es „entpacken“, indem wir es `UserInDB` übergeben, mit vorangestelltem `**`.
+... weil `user_in.dict()` ein `dict` ist, und dann lassen wir Python es „entpacken“, indem wir es an `UserInDB` mit vorangestelltem `**` übergeben.
 
-Wir erhalten also ein Pydantic-Modell aus den Daten eines anderen Pydantic-Modells.
+Auf diese Weise erhalten wir ein Pydantic-Modell aus den Daten eines anderen Pydantic-Modells.
 
-#### Ein `dict` entpacken und zusätzliche Schlüsselwort-Argumente
+#### Ein `dict` entpacken und zusätzliche Schlüsselwort-Argumente { #unpacking-a-dict-and-extra-keywords }
 
-Und dann fügen wir ein noch weiteres Schlüsselwort-Argument hinzu, `hashed_password=hashed_password`:
+Und dann fügen wir das zusätzliche Schlüsselwort-Argument `hashed_password=hashed_password` hinzu, wie in:
 
 ```Python
 UserInDB(**user_in.dict(), hashed_password=hashed_password)
 ```
 
-... was am Ende ergibt:
+... was so ist wie:
 
 ```Python
 UserInDB(
@@ -142,78 +142,81 @@ UserInDB(
 
 /// warning | Achtung
 
-Die Hilfsfunktionen `fake_password_hasher` und `fake_save_user` demonstrieren nur den möglichen Fluss der Daten und bieten natürlich keine echte Sicherheit.
+Die unterstützenden zusätzlichen Funktionen `fake_password_hasher` und `fake_save_user` dienen nur zur Demo eines möglichen Datenflusses, bieten jedoch natürlich keine echte Sicherheit.
 
 ///
 
-## Verdopplung vermeiden
+## Verdopplung vermeiden { #reduce-duplication }
 
-Reduzierung von Code-Verdoppelung ist eine der Kern-Ideen von **FastAPI**.
+Die Reduzierung von Code-Verdoppelung ist eine der Kernideen von **FastAPI**.
 
-Weil Verdoppelung von Code die Wahrscheinlichkeit von Fehlern, Sicherheitsproblemen, Desynchronisation (Code wird nur an einer Stelle verändert, aber nicht an einer anderen), usw. erhöht.
+Da die Verdopplung von Code die Wahrscheinlichkeit von Fehlern, Sicherheitsproblemen, Problemen mit der Desynchronisation des Codes (wenn Sie an einer Stelle, aber nicht an der anderen aktualisieren) usw. erhöht.
 
-Unsere Modelle teilen alle eine Menge der Daten und verdoppeln Attribut-Namen und -Typen.
+Und diese Modelle teilen alle eine Menge der Daten und verdoppeln Attributnamen und -typen.
 
-Das können wir besser machen.
+Wir könnten es besser machen.
 
-Wir deklarieren ein `UserBase`-Modell, das als Basis für unsere anderen Modelle dient. Dann können wir Unterklassen erstellen, die seine Attribute (Typdeklarationen, Validierungen, usw.) erben.
+Wir können ein `UserBase`-Modell deklarieren, das als Basis für unsere anderen Modelle dient. Und dann können wir Unterklassen dieses Modells erstellen, die seine Attribute (Typdeklarationen, Validierung usw.) erben.
 
-Die ganze Datenkonvertierung, -validierung, -dokumentation, usw. wird immer noch wie gehabt funktionieren.
+Die ganze Datenkonvertierung, -validierung, -dokumentation usw. wird immer noch wie gewohnt funktionieren.
 
-Auf diese Weise beschreiben wir nur noch die Unterschiede zwischen den Modellen (mit Klartext-`password`, mit `hashed_password`, und ohne Passwort):
+Auf diese Weise können wir nur die Unterschiede zwischen den Modellen (mit Klartext-`password`, mit `hashed_password` und ohne Passwort) deklarieren:
 
 {* ../../docs_src/extra_models/tutorial002_py310.py hl[7,13:14,17:18,21:22] *}
 
-## `Union`, oder `anyOf`
+## `Union` oder `anyOf` { #union-or-anyof }
 
-Sie können deklarieren, dass eine Response eine <abbr title="Union – Verbund, Einheit‚ Vereinigung: Eines von Mehreren">`Union`</abbr> mehrerer Typen ist, sprich, einer dieser Typen.
+Sie können deklarieren, dass eine <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> eine <abbr title="Union – Verbund, Einheit, Vereinigung: Eines von Mehreren">`Union`</abbr> mehrerer Typen ist, das bedeutet, dass die Response einer von ihnen ist.
 
-Das wird in OpenAPI mit `anyOf` angezeigt.
+Dies wird in OpenAPI mit `anyOf` definiert.
 
-Um das zu tun, verwenden Sie Pythons Standard-Typhinweis <a href="https://docs.python.org/3/library/typing.html#typing.Union" class="external-link" target="_blank">`typing.Union`</a>:
+Um das zu tun, verwenden Sie den Standard-Python-Typhinweis <a href="https://docs.python.org/3/library/typing.html#typing.Union" class="external-link" target="_blank">`typing.Union`</a>:
 
 /// note | Hinweis
 
-Listen Sie, wenn Sie eine <a href="https://pydantic-docs.helpmanual.io/usage/types/#unions" class="external-link" target="_blank">`Union`</a> definieren, denjenigen Typ zuerst, der am spezifischsten ist, gefolgt von den weniger spezifischen Typen. Im Beispiel oben, in `Union[PlaneItem, CarItem]` also den spezifischeren `PlaneItem` vor dem weniger spezifischen `CarItem`.
+Wenn Sie eine <a href="https://docs.pydantic.dev/latest/concepts/types/#unions" class="external-link" target="_blank">`Union`</a> definieren, listen Sie den spezifischeren Typ zuerst auf, gefolgt vom weniger spezifischen Typ. Im Beispiel unten steht `PlaneItem` vor `CarItem` in `Union[PlaneItem, CarItem]`.
 
 ///
 
 {* ../../docs_src/extra_models/tutorial003_py310.py hl[1,14:15,18:20,33] *}
 
-### `Union` in Python 3.10
 
-In diesem Beispiel übergeben wir dem Argument `response_model` den Wert `Union[PlaneItem, CarItem]`.
+### `Union` in Python 3.10 { #union-in-python-3-10 }
 
-Da wir es als **Wert einem Argument überreichen**, statt es als **Typannotation** zu verwenden, müssen wir `Union` verwenden, selbst in Python 3.10.
+In diesem Beispiel übergeben wir `Union[PlaneItem, CarItem]` als Wert des Arguments `response_model`.
 
-Wenn es eine Typannotation gewesen wäre, hätten wir auch den vertikalen Trennstrich verwenden können, wie in:
+Da wir es als **Wert an ein Argument übergeben**, anstatt es in einer **Typannotation** zu verwenden, müssen wir `Union` verwenden, sogar in Python 3.10.
+
+Wäre es eine Typannotation gewesen, hätten wir den vertikalen Strich verwenden können, wie in:
 
 ```Python
 some_variable: PlaneItem | CarItem
 ```
 
-Aber wenn wir das in der Zuweisung `response_model=PlaneItem | CarItem` machen, erhalten wir eine Fehlermeldung, da Python versucht, eine **ungültige Operation** zwischen `PlaneItem` und `CarItem` durchzuführen, statt es als Typannotation zu interpretieren.
+Aber wenn wir das in der Zuweisung `response_model=PlaneItem | CarItem` machen, würden wir einen Fehler erhalten, weil Python versuchen würde, eine **ungültige Operation** zwischen `PlaneItem` und `CarItem` auszuführen, anstatt es als Typannotation zu interpretieren.
 
-## Listen von Modellen
+## Liste von Modellen { #list-of-models }
 
-Genauso können Sie eine Response deklarieren, die eine Liste von Objekten ist.
+Auf die gleiche Weise können Sie Responses von Listen von Objekten deklarieren.
 
-Verwenden Sie dafür Pythons Standard `typing.List` (oder nur `list` in Python 3.9 und darüber):
+Dafür verwenden Sie Pythons Standard-`typing.List` (oder nur `list` in Python 3.9 und höher):
 
 {* ../../docs_src/extra_models/tutorial004_py39.py hl[18] *}
 
-## Response mit beliebigem `dict`
 
-Sie könne auch eine Response deklarieren, die ein beliebiges `dict` zurückgibt, bei dem nur die Typen der Schlüssel und der Werte bekannt sind, ohne ein Pydantic-Modell zu verwenden.
+## Response mit beliebigem `dict` { #response-with-arbitrary-dict }
+
+Sie können auch eine Response deklarieren, die ein beliebiges `dict` zurückgibt, indem Sie nur die Typen der Schlüssel und Werte ohne ein Pydantic-Modell deklarieren.
 
-Das ist nützlich, wenn Sie die gültigen Feld-/Attribut-Namen von vorneherein nicht wissen (was für ein Pydantic-Modell notwendig ist).
+Dies ist nützlich, wenn Sie die gültigen Feld-/Attributnamen nicht im Voraus kennen (die für ein Pydantic-Modell benötigt werden würden).
 
-In diesem Fall können Sie `typing.Dict` verwenden (oder nur `dict` in Python 3.9 und darüber):
+In diesem Fall können Sie `typing.Dict` verwenden (oder nur `dict` in Python 3.9 und höher):
 
 {* ../../docs_src/extra_models/tutorial005_py39.py hl[6] *}
 
-## Zusammenfassung
+
+## Zusammenfassung { #recap }
 
 Verwenden Sie gerne mehrere Pydantic-Modelle und vererben Sie je nach Bedarf.
 
-Sie brauchen kein einzelnes Datenmodell pro Einheit, wenn diese Einheit verschiedene Zustände annehmen kann. So wie unsere Benutzer-„Einheit“, welche einen Zustand mit `password`, einen mit `password_hash` und einen ohne Passwort hatte.
+Sie brauchen kein einzelnes Datenmodell pro Einheit, wenn diese Einheit in der Lage sein muss, verschiedene „Zustände“ zu haben. Wie im Fall der Benutzer-„Einheit“ mit einem Zustand einschließlich `password`, `password_hash` und ohne Passwort.

docs/de/docs/tutorial/first-steps.md

@@ -1,36 +1,52 @@
-# Erste Schritte
+# Erste Schritte { #first-steps }
 
 Die einfachste FastAPI-Datei könnte wie folgt aussehen:
 
 {* ../../docs_src/first_steps/tutorial001.py *}
 
-Kopieren Sie dies in eine Datei `main.py`.
+Kopieren Sie das in eine Datei `main.py`.
 
 Starten Sie den Live-Server:
 
 <div class="termy">
 
 ```console
-$ uvicorn main:app --reload
+$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:solid">main.py</u>
 
-<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-<span style="color: green;">INFO</span>:     Started reloader process [28720]
-<span style="color: green;">INFO</span>:     Started server process [28722]
-<span style="color: green;">INFO</span>:     Waiting for application startup.
-<span style="color: green;">INFO</span>:     Application startup complete.
-```
+  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting development server 🚀
 
-</div>
+             Searching for package file structure from directories
+             with <font color="#3465A4">__init__.py</font> files
+             Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
 
-/// note | Hinweis
+   <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span>  🐍 main.py
 
-Der Befehl `uvicorn main:app` bezieht sich auf:
+     <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span>  Importing the FastAPI app object from the module with
+             the following code:
 
-* `main`: die Datei `main.py` (das sogenannte Python-„Modul“).
-* `app`: das Objekt, welches in der Datei `main.py` mit der Zeile `app = FastAPI()` erzeugt wurde.
-* `--reload`: lässt den Server nach Codeänderungen neu starten. Verwenden Sie das nur während der Entwicklung.
+             <u style="text-decoration-style:solid">from </u><u style="text-decoration-style:solid"><b>main</b></u><u style="text-decoration-style:solid"> import </u><u style="text-decoration-style:solid"><b>app</b></u>
 
-///
+      <span style="background-color:#007166"><font color="#D3D7CF"> app </font></span>  Using import string: <font color="#3465A4">main:app</font>
+
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Server started at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font>
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Documentation at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000/docs</u></font>
+
+      <span style="background-color:#007166"><font color="#D3D7CF"> tip </font></span>  Running in development mode, for production use:
+             <b>fastapi run</b>
+
+             Logs:
+
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Will watch for changes in these directories:
+             <b>[</b><font color="#4E9A06">&apos;/home/user/code/awesomeapp&apos;</font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Uvicorn running on <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font> <b>(</b>Press CTRL+C
+             to quit<b>)</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started reloader process <b>[</b><font color="#34E2E2"><b>383138</b></font><b>]</b> using WatchFiles
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started server process <b>[</b><font color="#34E2E2"><b>383153</b></font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Waiting for application startup.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Application startup complete.
+```
+
+</div>
 
 In der Konsolenausgabe sollte es eine Zeile geben, die ungefähr so aussieht:
 
@@ -38,27 +54,27 @@ In der Konsolenausgabe sollte es eine Zeile geben, die ungefähr so aussieht:
 INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
 
-Diese Zeile zeigt die URL, unter der Ihre Anwendung auf Ihrem lokalen Computer bereitgestellt wird.
+Diese Zeile zeigt die URL, unter der Ihre App auf Ihrem lokalen Computer bereitgestellt wird.
 
-### Testen Sie es
+### Es testen { #check-it }
 
-Öffnen Sie Ihren Browser unter <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000.</a>
+Öffnen Sie Ihren Browser unter <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000</a>.
 
-Sie werden folgende JSON-Response sehen:
+Sie werden die JSON-<abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> sehen:
 
 ```JSON
 {"message": "Hello World"}
 ```
 
-### Interaktive API-Dokumentation
+### Interaktive API-Dokumentation { #interactive-api-docs }
 
-Gehen Sie als Nächstes auf <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs </a>.
+Gehen Sie als Nächstes auf <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 
 Sie werden die automatisch erzeugte, interaktive API-Dokumentation sehen (bereitgestellt durch <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a>):
 
 ![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)
 
-### Alternative API-Dokumentation
+### Alternative API-Dokumentation { #alternative-api-docs }
 
 Gehen Sie nun auf <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
 
@@ -66,31 +82,31 @@ Dort sehen Sie die alternative, automatische Dokumentation (bereitgestellt durch
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
 
-### OpenAPI
+### OpenAPI { #openapi }
 
 **FastAPI** generiert ein „Schema“ mit all Ihren APIs unter Verwendung des **OpenAPI**-Standards zur Definition von APIs.
 
-#### „Schema“
+#### „Schema“ { #schema }
 
 Ein „Schema“ ist eine Definition oder Beschreibung von etwas. Nicht der eigentliche Code, der es implementiert, sondern lediglich eine abstrakte Beschreibung.
 
-#### API-„Schema“
+#### API-„Schema“ { #api-schema }
 
-In diesem Fall ist  <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> eine Spezifikation, die vorschreibt, wie ein Schema für Ihre API zu definieren ist.
+In diesem Fall ist <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> 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“
+#### Daten-„Schema“ { #data-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 und JSON Schema { #openapi-and-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`
+#### Die `openapi.json` testen { #check-the-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.
 
@@ -119,7 +135,7 @@ Es wird ein JSON angezeigt, welches ungefähr so aussieht:
 ...
 ```
 
-#### Wofür OpenAPI gedacht ist
+#### Wofür OpenAPI gedacht ist { #what-is-openapi-for }
 
 Das OpenAPI-Schema ist die Grundlage für die beiden enthaltenen interaktiven Dokumentationssysteme.
 
@@ -127,9 +143,9 @@ Es gibt dutzende Alternativen, die alle auf OpenAPI basieren. Sie können jede d
 
 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.
 
-## Rückblick, Schritt für Schritt
+## Zusammenfassung, Schritt für Schritt { #recap-step-by-step }
 
-### Schritt 1: Importieren von `FastAPI`
+### Schritt 1: `FastAPI` importieren { #step-1-import-fastapi }
 
 {* ../../docs_src/first_steps/tutorial001.py hl[1] *}
 
@@ -137,13 +153,13 @@ Ebenfalls können Sie es verwenden, um automatisch Code für Clients zu generier
 
 /// note | Technische Details
 
-`FastAPI`  ist eine Klasse, die direkt von `Starlette` erbt.
+`FastAPI` ist eine Klasse, die direkt von `Starlette` erbt.
 
 Sie können alle <a href="https://www.starlette.io/" class="external-link" target="_blank">Starlette</a>-Funktionalitäten auch mit `FastAPI` nutzen.
 
 ///
 
-### Schritt 2: Erzeugen einer `FastAPI`-„Instanz“
+### Schritt 2: Erzeugen einer `FastAPI`-„Instanz“ { #step-2-create-a-fastapi-instance }
 
 {* ../../docs_src/first_steps/tutorial001.py hl[3] *}
 
@@ -151,37 +167,9 @@ In diesem Beispiel ist die Variable `app` eine „Instanz“ der Klasse `FastAPI
 
 Dies wird der Hauptinteraktionspunkt für die Erstellung all Ihrer APIs sein.
 
-Die Variable `app` ist dieselbe, auf die sich der Befehl `uvicorn` bezieht:
-
-<div class="termy">
-
-```console
-$ uvicorn main:app --reload
-
-<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-```
-
-</div>
-
-Wenn Sie Ihre Anwendung wie folgt erstellen:
-
-{* ../../docs_src/first_steps/tutorial002.py hl[3] *}
-
-Und in eine Datei `main.py` einfügen, dann würden Sie `uvicorn` wie folgt aufrufen:
-
-<div class="termy">
-
-```console
-$ uvicorn main:my_awesome_api --reload
-
-<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-```
-
-</div>
-
-### Schritt 3: Erstellen einer *Pfadoperation*
+### Schritt 3: Erstellen einer *Pfadoperation* { #step-3-create-a-path-operation }
 
-#### Pfad
+#### Pfad { #path }
 
 „Pfad“ bezieht sich hier auf den letzten Teil der URL, beginnend mit dem ersten `/`.
 
@@ -197,7 +185,7 @@ https://example.com/items/foo
 /items/foo
 ```
 
-/// info
+/// info | Info
 
 Ein „Pfad“ wird häufig auch als „Endpunkt“ oder „Route“ bezeichnet.
 
@@ -205,7 +193,7 @@ 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 { #operation }
 
 „Operation“ bezieht sich hier auf eine der HTTP-„Methoden“.
 
@@ -240,16 +228,16 @@ In OpenAPI wird folglich jede dieser HTTP-Methoden als „Operation“ bezeichne
 
 Wir werden sie auch „**Operationen**“ nennen.
 
-#### Definieren eines *Pfadoperation-Dekorators*
+#### Definieren eines *Pfadoperation-Dekorators* { #define-a-path-operation-decorator }
 
 {* ../../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:
+Das `@app.get("/")` sagt **FastAPI**, dass die Funktion direkt darunter für die Bearbeitung von <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Requests</abbr> zuständig ist, die an:
 
- * den Pfad `/`
- * unter der Verwendung der <abbr title="eine HTTP GET Methode"><code>get</code>-Operation</abbr> gehen
+* den Pfad `/`
+* unter der Verwendung der <abbr title="eine HTTP-GET-Methode"><code>get</code>-Operation</abbr> gehen
 
-/// info | `@decorator` Information
+/// info | `@decorator` Info
 
 Diese `@something`-Syntax wird in Python „Dekorator“ genannt.
 
@@ -269,7 +257,7 @@ Sie können auch die anderen Operationen verwenden:
 * `@app.put()`
 * `@app.delete()`
 
-Oder die exotischeren:
+Und die exotischeren:
 
 * `@app.options()`
 * `@app.head()`
@@ -288,7 +276,7 @@ Wenn Sie beispielsweise GraphQL verwenden, führen Sie normalerweise alle Aktion
 
 ///
 
-### Schritt 4: Definieren der **Pfadoperation-Funktion**
+### Schritt 4: Definieren der **Pfadoperation-Funktion** { #step-4-define-the-path-operation-function }
 
 Das ist unsere „**Pfadoperation-Funktion**“:
 
@@ -300,7 +288,7 @@ Das ist unsere „**Pfadoperation-Funktion**“:
 
 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.
+Sie wird von **FastAPI** immer dann aufgerufen, wenn sie einen Request an die URL „`/`“ mittels einer `GET`-Operation erhält.
 
 In diesem Fall handelt es sich um eine `async`-Funktion.
 
@@ -312,11 +300,11 @@ Sie könnten sie auch als normale Funktion anstelle von `async def` definieren:
 
 /// note | Hinweis
 
-Wenn Sie den Unterschied nicht kennen, lesen Sie [Async: *„In Eile?“*](../async.md#in-eile){.internal-link target=_blank}.
+Wenn Sie den Unterschied nicht kennen, lesen Sie [Async: *„In Eile?“*](../async.md#in-a-hurry){.internal-link target=_blank}.
 
 ///
 
-### Schritt 5: den Inhalt zurückgeben
+### Schritt 5: den Inhalt zurückgeben { #step-5-return-the-content }
 
 {* ../../docs_src/first_steps/tutorial001.py hl[8] *}
 
@@ -324,12 +312,12 @@ Sie können ein `dict`, eine `list`, einzelne Werte wie `str`, `int`, usw. zurü
 
 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.
+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
+## Zusammenfassung { #recap }
 
 * Importieren Sie `FastAPI`.
 * Erstellen Sie eine `app` Instanz.
-* Schreiben Sie einen **Pfadoperation-Dekorator** (wie z. B. `@app.get("/")`).
-* Schreiben Sie eine **Pfadoperation-Funktion** (wie z. B. oben `def root(): ...`).
-* Starten Sie den Entwicklungsserver (z. B. `uvicorn main:app --reload`).
+* 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`.

docs/de/docs/tutorial/handling-errors.md

@@ -1,49 +1,49 @@
-# Fehlerbehandlung
+# Fehler behandeln { #handling-errors }
 
-Es gibt viele Situationen, in denen Sie einem Client, der Ihre API benutzt, einen Fehler zurückgeben müssen.
+Es gibt viele Situationen, in denen Sie einem Client, der Ihre API nutzt, einen Fehler mitteilen müssen.
 
-Dieser Client könnte ein Browser mit einem Frontend, Code von jemand anderem, ein <abbr title="Internet of Things – Internet der Dinge: Geräte, die über das Internet Informationen austauschen">IoT</abbr>-Gerät, usw., sein.
+Dieser Client könnte ein Browser mit einem Frontend sein, ein Code von jemand anderem, ein IoT-Gerät usw.
 
-Sie müssten beispielsweise einem Client sagen:
+Sie könnten dem Client mitteilen müssen, dass:
 
-* Dass er nicht die notwendigen Berechtigungen hat, eine Aktion auszuführen.
-* Dass er zu einer Ressource keinen Zugriff hat.
-* Dass die Ressource, auf die er zugreifen möchte, nicht existiert.
+* Der Client nicht genügend Berechtigungen für diese Operation hat.
+* Der Client keinen Zugriff auf diese Ressource hat.
+* Die Ressource, auf die der Client versucht hat, zuzugreifen, nicht existiert.
 * usw.
 
-In diesen Fällen geben Sie normalerweise einen **HTTP-Statuscode** im Bereich **400** (400 bis 499) zurück.
+In diesen Fällen würden Sie normalerweise einen **HTTP-Statuscode** im Bereich **400** (von 400 bis 499) zurückgeben.
 
-Das ist vergleichbar mit den HTTP-Statuscodes im Bereich 200 (von 200 bis 299). Diese „200“er Statuscodes bedeuten, dass der Request in einem bestimmten Aspekt ein „Success“ („Erfolg“) war.
+Dies ist vergleichbar mit den HTTP-Statuscodes im Bereich 200 (von 200 bis 299). Diese „200“-Statuscodes bedeuten, dass der <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> in irgendeiner Weise erfolgreich war.
 
-Die Statuscodes im 400er-Bereich bedeuten hingegen, dass es einen Fehler gab.
+Die Statuscodes im Bereich 400 bedeuten hingegen, dass es einen Fehler seitens des Clients gab.
 
-Erinnern Sie sich an all diese **404 Not Found** Fehler (und Witze)?
+Erinnern Sie sich an all diese **„404 Not Found“** Fehler (und Witze)?
 
-## `HTTPException` verwenden
+## `HTTPException` verwenden { #use-httpexception }
 
-Um HTTP-Responses mit Fehlern zum Client zurückzugeben, verwenden Sie `HTTPException`.
+Um HTTP-<abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Responses</abbr> mit Fehlern an den Client zurückzugeben, verwenden Sie `HTTPException`.
 
-### `HTTPException` importieren
+### `HTTPException` importieren { #import-httpexception }
 
 {* ../../docs_src/handling_errors/tutorial001.py hl[1] *}
 
-### Eine `HTTPException` in Ihrem Code auslösen
+### Eine `HTTPException` in Ihrem Code auslösen { #raise-an-httpexception-in-your-code }
 
-`HTTPException` ist eine normale Python-<abbr title="Exception – Ausnahme, Fehler: Python-Objekt, das einen Fehler nebst Metadaten repräsentiert">Exception</abbr> mit einigen zusätzlichen Daten, die für APIs relevant sind.
+`HTTPException` ist eine normale Python-Exception mit zusätzlichen Daten, die für APIs relevant sind.
 
-Weil es eine Python-Exception ist, geben Sie sie nicht zurück, (`return`), sondern Sie lösen sie aus (`raise`).
+Weil es eine Python-Exception ist, geben Sie sie nicht zurück (`return`), sondern lösen sie aus (`raise`).
 
-Das bedeutet auch, wenn Sie in einer Hilfsfunktion sind, die Sie von ihrer *Pfadoperation-Funktion* aus aufrufen, und Sie lösen eine `HTTPException` von innerhalb dieser Hilfsfunktion aus, dann wird der Rest der *Pfadoperation-Funktion* nicht ausgeführt, sondern der Request wird sofort abgebrochen und der HTTP-Error der `HTTP-Exception` wird zum Client gesendet.
+Das bedeutet auch, wenn Sie sich innerhalb einer Hilfsfunktion befinden, die Sie innerhalb Ihrer *Pfadoperation-Funktion* aufrufen, und Sie die `HTTPException` aus dieser Hilfsfunktion heraus auslösen, wird der restliche Code in der *Pfadoperation-Funktion* nicht ausgeführt. Der Request wird sofort abgebrochen und der HTTP-Error der `HTTPException` wird an den Client gesendet.
 
-Der Vorteil, eine Exception auszulösen (`raise`), statt sie zurückzugeben (`return`) wird im Abschnitt über Abhängigkeiten und Sicherheit klarer werden.
+Der Vorteil des Auslösens einer Exception gegenüber dem Zurückgeben eines Wertes wird im Abschnitt über Abhängigkeiten und Sicherheit deutlicher werden.
 
-Im folgenden Beispiel lösen wir, wenn der Client eine ID anfragt, die nicht existiert, eine Exception mit dem Statuscode `404` aus.
+In diesem Beispiel lösen wir eine Exception mit einem Statuscode von `404` aus, wenn der Client einen Artikel mit einer nicht existierenden ID anfordert:
 
 {* ../../docs_src/handling_errors/tutorial001.py hl[11] *}
 
-### Die resultierende Response
+### Die resultierende Response { #the-resulting-response }
 
-Wenn der Client `http://example.com/items/foo` anfragt (ein `item_id` `"foo"`), erhält dieser Client einen HTTP-Statuscode 200 und folgende JSON-Response:
+Wenn der Client `http://example.com/items/foo` anfordert (ein `item_id` `"foo"`), erhält dieser Client einen HTTP-Statuscode 200 und diese JSON-Response:
 
 ```JSON
 {
@@ -51,7 +51,7 @@ Wenn der Client `http://example.com/items/foo` anfragt (ein `item_id` `"foo"`),
 }
 ```
 
-Aber wenn der Client `http://example.com/items/bar` anfragt (ein nicht-existierendes `item_id` `"bar"`), erhält er einen HTTP-Statuscode 404 (der „Not Found“-Fehler), und eine JSON-Response wie folgt:
+Aber wenn der Client `http://example.com/items/bar` anfordert (ein nicht-existierendes `item_id` `"bar"`), erhält er einen HTTP-Statuscode 404 (der „not found“-Error) und eine JSON-Response wie:
 
 ```JSON
 {
@@ -61,41 +61,41 @@ Aber wenn der Client `http://example.com/items/bar` anfragt (ein nicht-existiere
 
 /// tip | Tipp
 
-Wenn Sie eine `HTTPException` auslösen, können Sie dem Parameter `detail` jeden Wert übergeben, der nach JSON konvertiert werden kann, nicht nur `str`.
+Wenn Sie eine `HTTPException` auslösen, können Sie dem Parameter `detail` jeden Wert übergeben, der in JSON konvertiert werden kann, nicht nur `str`.
 
-Zum Beispiel ein `dict`, eine `list`, usw.
+Sie könnten ein `dict`, eine `list`, usw. übergeben.
 
-Das wird automatisch von **FastAPI** gehandhabt und der Wert nach JSON konvertiert.
+Diese werden von **FastAPI** automatisch gehandhabt und in JSON konvertiert.
 
 ///
 
-## Benutzerdefinierte Header hinzufügen
+## Benutzerdefinierte Header hinzufügen { #add-custom-headers }
 
-Es gibt Situationen, da ist es nützlich, dem HTTP-Error benutzerdefinierte Header hinzufügen zu können, etwa in einigen Sicherheitsszenarien.
+Es gibt Situationen, in denen es nützlich ist, dem HTTP-Error benutzerdefinierte Header hinzuzufügen. Zum Beispiel in einigen Sicherheitsszenarien.
 
-Sie müssen das wahrscheinlich nicht direkt in ihrem Code verwenden.
+Sie werden es wahrscheinlich nicht direkt in Ihrem Code verwenden müssen.
 
-Aber falls es in einem fortgeschrittenen Szenario notwendig ist, können Sie benutzerdefinierte Header wie folgt hinzufügen:
+Aber falls Sie es für ein fortgeschrittenes Szenario benötigen, können Sie benutzerdefinierte Header hinzufügen:
 
 {* ../../docs_src/handling_errors/tutorial002.py hl[14] *}
 
-## Benutzerdefinierte Exceptionhandler definieren
+## Benutzerdefinierte Exceptionhandler installieren { #install-custom-exception-handlers }
 
-Sie können benutzerdefinierte <abbr title="Exceptionhandler – Ausnahmebehandler: Funktion, die sich um die Bearbeitung einer Exception kümmert">Exceptionhandler</abbr> hinzufügen, mithilfe <a href="https://www.starlette.io/exceptions/" class="external-link" target="_blank">derselben Werkzeuge für Exceptions von Starlette</a>.
+Sie können benutzerdefinierte <abbr title="Ausnahmebehandler: Funktion, die sich um die Bearbeitung einer Exception kümmert">Exceptionhandler</abbr> mit <a href="https://www.starlette.io/exceptions/" class="external-link" target="_blank">den gleichen Exception-Werkzeugen von Starlette</a> hinzufügen.
 
-Nehmen wir an, Sie haben eine benutzerdefinierte Exception `UnicornException`, die Sie (oder eine Bibliothek, die Sie verwenden) `raise`n könnten.
+Angenommen, Sie haben eine benutzerdefinierte Exception `UnicornException`, die Sie (oder eine Bibliothek, die Sie verwenden) `raise`n könnten.
 
 Und Sie möchten diese Exception global mit FastAPI handhaben.
 
-Sie könnten einen benutzerdefinierten Exceptionhandler mittels `@app.exception_handler()` hinzufügen:
+Sie könnten einen benutzerdefinierten Exceptionhandler mit `@app.exception_handler()` hinzufügen:
 
 {* ../../docs_src/handling_errors/tutorial003.py hl[5:7,13:18,24] *}
 
-Wenn Sie nun `/unicorns/yolo` anfragen, `raise`d die *Pfadoperation* eine `UnicornException`.
+Hier, wenn Sie `/unicorns/yolo` anfordern, wird die *Pfadoperation* eine `UnicornException` `raise`n.
 
 Aber diese wird von `unicorn_exception_handler` gehandhabt.
 
-Sie erhalten also einen sauberen Error mit einem Statuscode `418` und dem JSON-Inhalt:
+Sie erhalten also einen sauberen Fehler mit einem HTTP-Statuscode von `418` und dem JSON-Inhalt:
 
 ```JSON
 {"message": "Oops! yolo did something. There goes a rainbow..."}
@@ -103,33 +103,33 @@ Sie erhalten also einen sauberen Error mit einem Statuscode `418` und dem JSON-I
 
 /// note | Technische Details
 
-Sie können auch `from starlette.requests import Request` und `from starlette.responses import JSONResponse` verwenden.
+Sie könnten auch `from starlette.requests import Request` und `from starlette.responses import JSONResponse` verwenden.
 
-**FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, als Annehmlichkeit für Sie, den Entwickler. Die meisten verfügbaren Responses kommen aber direkt von Starlette. Das Gleiche gilt für `Request`.
+**FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, nur als Annehmlichkeit für Sie, den Entwickler. Aber die meisten verfügbaren Responses kommen direkt von Starlette. Dasselbe gilt für `Request`.
 
 ///
 
-## Die Default-Exceptionhandler überschreiben
+## Die Default-Exceptionhandler überschreiben { #override-the-default-exception-handlers }
 
 **FastAPI** hat einige Default-Exceptionhandler.
 
-Diese Handler kümmern sich darum, Default-JSON-Responses zurückzugeben, wenn Sie eine `HTTPException` `raise`n, und wenn der Request ungültige Daten enthält.
+Diese Handler sind dafür verantwortlich, die Default-JSON-Responses zurückzugeben, wenn Sie eine `HTTPException` `raise`n und wenn der Request ungültige Daten enthält.
 
-Sie können diese Exceptionhandler mit ihren eigenen überschreiben.
+Sie können diese Exceptionhandler mit Ihren eigenen überschreiben.
 
-### Requestvalidierung-Exceptions überschreiben
+### Überschreiben von Request-Validierungs-Exceptions { #override-request-validation-exceptions }
 
 Wenn ein Request ungültige Daten enthält, löst **FastAPI** intern einen `RequestValidationError` aus.
 
-Und bietet auch einen Default-Exceptionhandler dafür.
+Und es enthält auch einen Default-Exceptionhandler für diesen.
 
-Um diesen zu überschreiben, importieren Sie den `RequestValidationError` und verwenden Sie ihn in `@app.exception_handler(RequestValidationError)`, um Ihren Exceptionhandler zu dekorieren.
+Um diesen zu überschreiben, importieren Sie den `RequestValidationError` und verwenden Sie ihn mit `@app.exception_handler(RequestValidationError)`, um den Exceptionhandler zu dekorieren.
 
-Der Exceptionhandler wird einen `Request` und die Exception entgegennehmen.
+Der Exceptionhandler erhält einen `Request` und die Exception.
 
 {* ../../docs_src/handling_errors/tutorial004.py hl[2,14:16] *}
 
-Wenn Sie nun `/items/foo` besuchen, erhalten Sie statt des Default-JSON-Errors:
+Wenn Sie nun zu `/items/foo` gehen, erhalten Sie anstelle des standardmäßigen JSON-Fehlers mit:
 
 ```JSON
 {
@@ -146,7 +146,7 @@ Wenn Sie nun `/items/foo` besuchen, erhalten Sie statt des Default-JSON-Errors:
 }
 ```
 
-eine Textversion:
+eine Textversion mit:
 
 ```
 1 validation error
@@ -154,27 +154,27 @@ path -> item_id
   value is not a valid integer (type=type_error.integer)
 ```
 
-#### `RequestValidationError` vs. `ValidationError`
+#### `RequestValidationError` vs. `ValidationError` { #requestvalidationerror-vs-validationerror }
 
 /// warning | Achtung
 
-Das folgende sind technische Details, die Sie überspringen können, wenn sie für Sie nicht wichtig sind.
+Dies sind technische Details, die Sie überspringen können, wenn sie für Sie jetzt nicht wichtig sind.
 
 ///
 
-`RequestValidationError` ist eine Unterklasse von Pydantics <a href="https://pydantic-docs.helpmanual.io/usage/models/#error-handling" class="external-link" target="_blank">`ValidationError`</a>.
+`RequestValidationError` ist eine Unterklasse von Pydantics <a href="https://docs.pydantic.dev/latest/concepts/models/#error-handling" class="external-link" target="_blank">`ValidationError`</a>.
 
-**FastAPI** verwendet diesen, sodass Sie, wenn Sie ein Pydantic-Modell für `response_model` verwenden, und ihre Daten fehlerhaft sind, einen Fehler in ihrem Log sehen.
+**FastAPI** verwendet diesen so, dass, wenn Sie ein Pydantic-Modell in `response_model` verwenden und Ihre Daten einen Fehler haben, Sie den Fehler in Ihrem Log sehen.
 
-Aber der Client/Benutzer sieht ihn nicht. Stattdessen erhält der Client einen <abbr title="Interner Server-Fehler">„Internal Server Error“</abbr> mit einem HTTP-Statuscode `500`.
+Aber der Client/Benutzer wird ihn nicht sehen. Stattdessen erhält der Client einen „Internal Server Error“ mit einem HTTP-Statuscode `500`.
 
-Das ist, wie es sein sollte, denn wenn Sie einen Pydantic-`ValidationError` in Ihrer *Response* oder irgendwo sonst in ihrem Code haben (es sei denn, im *Request* des Clients), ist das tatsächlich ein Bug in ihrem Code.
+Es sollte so sein, denn wenn Sie einen Pydantic `ValidationError` in Ihrer *Response* oder irgendwo anders in Ihrem Code haben (nicht im *Request* des Clients), ist es tatsächlich ein Fehler in Ihrem Code.
 
-Und während Sie den Fehler beheben, sollten ihre Clients/Benutzer keinen Zugriff auf interne Informationen über den Fehler haben, da das eine Sicherheitslücke aufdecken könnte.
+Und während Sie den Fehler beheben, sollten Ihre Clients/Benutzer keinen Zugriff auf interne Informationen über den Fehler haben, da das eine Sicherheitslücke aufdecken könnte.
 
-### den `HTTPException`-Handler überschreiben
+### Überschreiben des `HTTPException`-Fehlerhandlers { #override-the-httpexception-error-handler }
 
-Genauso können Sie den `HTTPException`-Handler überschreiben.
+Auf die gleiche Weise können Sie den `HTTPException`-Handler überschreiben.
 
 Zum Beispiel könnten Sie eine Klartext-Response statt JSON für diese Fehler zurückgeben wollen:
 
@@ -182,21 +182,21 @@ Zum Beispiel könnten Sie eine Klartext-Response statt JSON für diese Fehler zu
 
 /// note | Technische Details
 
-Sie können auch `from starlette.responses import PlainTextResponse` verwenden.
+Sie könnten auch `from starlette.responses import PlainTextResponse` verwenden.
 
-**FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, als Annehmlichkeit für Sie, den Entwickler. Die meisten verfügbaren Responses kommen aber direkt von Starlette.
+**FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, nur als Annehmlichkeit für Sie, den Entwickler. Aber die meisten verfügbaren Responses kommen direkt von Starlette.
 
 ///
 
-### Den `RequestValidationError`-Body verwenden
+### Verwenden des `RequestValidationError`-Bodys { #use-the-requestvalidationerror-body }
 
 Der `RequestValidationError` enthält den empfangenen `body` mit den ungültigen Daten.
 
-Sie könnten diesen verwenden, während Sie Ihre Anwendung entwickeln, um den Body zu loggen und zu debuggen, ihn zum Benutzer zurückzugeben, usw.
+Sie könnten diesen während der Entwicklung Ihrer Anwendung verwenden, um den Body zu loggen und zu debuggen, ihn an den Benutzer zurückzugeben usw.
 
 {* ../../docs_src/handling_errors/tutorial005.py hl[14] *}
 
-Jetzt versuchen Sie, einen ungültigen Artikel zu senden:
+Versuchen Sie nun, einen ungültigen Artikel zu senden:
 
 ```JSON
 {
@@ -205,7 +205,7 @@ Jetzt versuchen Sie, einen ungültigen Artikel zu senden:
 }
 ```
 
-Sie erhalten eine Response, die Ihnen sagt, dass die Daten ungültig sind, und welche den empfangenen Body enthält.
+Sie erhalten eine Response, die Ihnen sagt, dass die Daten ungültig sind und die den empfangenen Body enthält:
 
 ```JSON hl_lines="12-15"
 {
@@ -226,30 +226,30 @@ Sie erhalten eine Response, die Ihnen sagt, dass die Daten ungültig sind, und w
 }
 ```
 
-#### FastAPIs `HTTPException` vs. Starlettes `HTTPException`
+#### FastAPIs `HTTPException` vs. Starlettes `HTTPException` { #fastapis-httpexception-vs-starlettes-httpexception }
 
 **FastAPI** hat seine eigene `HTTPException`.
 
-Und **FastAPI**s `HTTPException`-Fehlerklasse erbt von Starlettes `HTTPException`-Fehlerklasse.
+Und die `HTTPException`-Fehlerklasse von **FastAPI** erbt von der `HTTPException`-Fehlerklasse von Starlette.
 
-Der einzige Unterschied besteht darin, dass **FastAPIs** `HTTPException` alles für das Feld `detail` akzeptiert, was nach JSON konvertiert werden kann, während Starlettes `HTTPException` nur Strings zulässt.
+Der einzige Unterschied besteht darin, dass die `HTTPException` von **FastAPI** beliebige JSON-konvertierbare Daten für das `detail`-Feld akzeptiert, während die `HTTPException` von Starlette nur Strings dafür akzeptiert.
 
-Sie können also weiterhin **FastAPI**s `HTTPException` wie üblich in Ihrem Code auslösen.
+Sie können also weiterhin die `HTTPException` von **FastAPI** wie üblich in Ihrem Code auslösen.
 
-Aber wenn Sie einen Exceptionhandler registrieren, registrieren Sie ihn für Starlettes `HTTPException`.
+Aber wenn Sie einen Exceptionhandler registrieren, sollten Sie ihn für die `HTTPException` von Starlette registrieren.
 
-Auf diese Weise wird Ihr Handler, wenn irgendein Teil von Starlettes internem Code, oder eine Starlette-Erweiterung, oder -Plugin eine Starlette-`HTTPException` auslöst, in der Lage sein, diese zu fangen und zu handhaben.
+Auf diese Weise, wenn irgendein Teil des internen Codes von Starlette, oder eine Starlette-Erweiterung oder ein Plug-in, eine Starlette `HTTPException` auslöst, wird Ihr Handler in der Lage sein, diese abzufangen und zu handhaben.
 
-Damit wir in diesem Beispiel beide `HTTPException`s im selben Code haben können, benennen wir Starlettes Exception um zu `StarletteHTTPException`:
+Um in diesem Beispiel beide `HTTPException`s im selben Code zu haben, wird die Exception von Starlette zu `StarletteHTTPException` umbenannt:
 
 ```Python
 from starlette.exceptions import HTTPException as StarletteHTTPException
 ```
 
-### **FastAPI**s Exceptionhandler wiederverwenden
+### Die Exceptionhandler von **FastAPI** wiederverwenden { #reuse-fastapis-exception-handlers }
 
-Wenn Sie die Exception zusammen mit denselben Default-Exceptionhandlern von **FastAPI** verwenden möchten, können Sie die Default-Exceptionhandler von `fastapi.Exception_handlers` importieren und wiederverwenden:
+Wenn Sie die Exception zusammen mit den gleichen Default-Exceptionhandlern von **FastAPI** verwenden möchten, können Sie die Default-Exceptionhandler aus `fastapi.exception_handlers` importieren und wiederverwenden:
 
 {* ../../docs_src/handling_errors/tutorial006.py hl[2:5,15,21] *}
 
-In diesem Beispiel `print`en Sie nur den Fehler mit einer sehr ausdrucksstarken Nachricht, aber Sie sehen, worauf wir hinauswollen. Sie können mit der Exception etwas machen und dann einfach die Default-Exceptionhandler wiederverwenden.
+In diesem Beispiel geben Sie nur den Fehler mit einer sehr ausdrucksstarken Nachricht aus, aber Sie verstehen das Prinzip. Sie können die Exception verwenden und dann einfach die Default-Exceptionhandler wiederverwenden.

docs/de/docs/tutorial/header-param-models.md

@@ -0,0 +1,72 @@
+# Header-Parameter-Modelle { #header-parameter-models }
+
+Wenn Sie eine Gruppe verwandter **Header-Parameter** haben, können Sie ein **Pydantic-Modell** erstellen, um diese zu deklarieren.
+
+Dadurch können Sie das **Modell an mehreren Stellen wiederverwenden** und auch Validierungen und Metadaten für alle Parameter gleichzeitig deklarieren. 😎
+
+/// note | Hinweis
+
+Dies wird seit FastAPI Version `0.115.0` unterstützt. 🤓
+
+///
+
+## Header-Parameter mit einem Pydantic-Modell { #header-parameters-with-a-pydantic-model }
+
+Deklarieren Sie die erforderlichen **Header-Parameter** in einem **Pydantic-Modell** und dann den Parameter als `Header`:
+
+{* ../../docs_src/header_param_models/tutorial001_an_py310.py hl[9:14,18] *}
+
+**FastAPI** wird die Daten für **jedes Feld** aus den **Headern** des <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> extrahieren und Ihnen das von Ihnen definierte Pydantic-Modell geben.
+
+## Die Dokumentation testen { #check-the-docs }
+
+Sie können die erforderlichen Header in der Dokumentationsoberfläche unter `/docs` sehen:
+
+<div class="screenshot">
+<img src="/img/tutorial/header-param-models/image01.png">
+</div>
+
+## Zusätzliche Header verbieten { #forbid-extra-headers }
+
+In einigen speziellen Anwendungsfällen (wahrscheinlich nicht sehr häufig) möchten Sie möglicherweise die **Header einschränken**, die Sie erhalten möchten.
+
+Sie können Pydantics Modellkonfiguration verwenden, um `extra` Felder zu verbieten (`forbid`):
+
+{* ../../docs_src/header_param_models/tutorial002_an_py310.py hl[10] *}
+
+Wenn ein Client versucht, einige **zusätzliche Header** zu senden, erhält er eine **Error-<abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr>**.
+
+Zum Beispiel, wenn der Client versucht, einen `tool`-Header mit einem Wert von `plumbus` zu senden, erhält er eine **Error-Response**, die ihm mitteilt, dass der Header-Parameter `tool` nicht erlaubt ist:
+
+```json
+{
+    "detail": [
+        {
+            "type": "extra_forbidden",
+            "loc": ["header", "tool"],
+            "msg": "Extra inputs are not permitted",
+            "input": "plumbus",
+        }
+    ]
+}
+```
+
+## Automatische Umwandlung von Unterstrichen deaktivieren { #disable-convert-underscores }
+
+Ähnlich wie bei regulären Header-Parametern werden bei der Verwendung von Unterstrichen in den Parameternamen diese **automatisch in Bindestriche umgewandelt**.
+
+Wenn Sie beispielsweise einen Header-Parameter `save_data` im Code haben, wird der erwartete HTTP-Header `save-data` sein, und er wird auch so in der Dokumentation angezeigt.
+
+Falls Sie aus irgendeinem Grund diese automatische Umwandlung deaktivieren müssen, können Sie dies auch für Pydantic-Modelle für Header-Parameter tun.
+
+{* ../../docs_src/header_param_models/tutorial003_an_py310.py hl[19] *}
+
+/// warning | Achtung
+
+Bevor Sie `convert_underscores` auf `False` setzen, bedenken Sie, dass einige HTTP-Proxies und -Server die Verwendung von Headern mit Unterstrichen nicht zulassen.
+
+///
+
+## Zusammenfassung { #summary }
+
+Sie können **Pydantic-Modelle** verwenden, um **Header** in **FastAPI** zu deklarieren. 😎

docs/de/docs/tutorial/header-params.md

@@ -1,50 +1,50 @@
-# Header-Parameter
+# Header-Parameter { #header-parameters }
 
-So wie `Query`-, `Path`-, und `Cookie`-Parameter können Sie auch <abbr title='Header – Kopfzeilen, Header, Header-Felder: Schlüssel-Wert-Metadaten, die vom Client beim Request, und vom Server bei der Response gesendet werden'>Header</abbr>-Parameter definieren.
+Sie können Header-Parameter genauso definieren, wie Sie `Query`-, `Path`- und `Cookie`-Parameter definieren.
 
-## `Header` importieren
+## `Header` importieren { #import-header }
 
 Importieren Sie zuerst `Header`:
 
 {* ../../docs_src/header_params/tutorial001_an_py310.py hl[3] *}
 
-## `Header`-Parameter deklarieren
+## `Header`-Parameter deklarieren { #declare-header-parameters }
 
-Dann deklarieren Sie Ihre Header-Parameter, auf die gleiche Weise, wie Sie auch `Path`-, `Query`-, und `Cookie`-Parameter deklarieren.
+Deklarieren Sie dann die Header-Parameter mit derselben Struktur wie bei `Path`, `Query` und `Cookie`.
 
-Der erste Wert ist der Typ. Sie können `Header` die gehabten Extra Validierungs- und Beschreibungsparameter hinzufügen. Danach können Sie einen Defaultwert vergeben:
+Sie können den Defaultwert sowie alle zusätzlichen Validierungs- oder Annotationsparameter definieren:
 
 {* ../../docs_src/header_params/tutorial001_an_py310.py hl[9] *}
 
 /// note | Technische Details
 
-`Header` ist eine Schwesterklasse von `Path`, `Query` und `Cookie`. Sie erbt von derselben gemeinsamen `Param`-Elternklasse.
+`Header` ist eine „Schwester“-Klasse von `Path`, `Query` und `Cookie`. Sie erbt ebenfalls von der gemeinsamen `Param`-Klasse.
 
-Aber erinnern Sie sich, dass, wenn Sie `Query`, `Path`,  `Header` und andere von `fastapi` importieren, diese tatsächlich Funktionen sind, welche spezielle Klassen zurückgeben.
+Aber denken Sie daran, dass bei der Nutzung von `Query`, `Path`, `Header` und anderen Importen aus `fastapi`, diese tatsächlich Funktionen sind, die spezielle Klassen zurückgeben.
 
 ///
 
-/// info
+/// info | Info
 
-Um Header zu deklarieren, müssen Sie `Header` verwenden, da diese Parameter sonst als Query-Parameter interpretiert werden würden.
+Um Header zu deklarieren, müssen Sie `Header` verwenden, da die Parameter sonst als Query-Parameter interpretiert werden würden.
 
 ///
 
-## Automatische Konvertierung
+## Automatische Konvertierung { #automatic-conversion }
 
-`Header` hat weitere Funktionalität, zusätzlich zu der, die `Path`, `Query` und `Cookie` bereitstellen.
+`Header` bietet etwas zusätzliche Funktionalität im Vergleich zu `Path`, `Query` und `Cookie`.
 
-Die meisten Standard-Header benutzen als Trennzeichen einen Bindestrich, auch bekannt als das „Minus-Symbol“ (`-`).
+Die meisten Standard-Header sind durch ein „Bindestrich“-Zeichen getrennt, auch bekannt als „Minus-Symbol“ (`-`).
 
-Aber eine Variable wie `user-agent` ist in Python nicht gültig.
+Aber eine Variable wie `user-agent` ist in Python ungültig.
 
-Darum wird `Header` standardmäßig in Parameternamen den Unterstrich (`_`) zu einem Bindestrich (`-`) konvertieren.
+Daher wird `Header` standardmäßig die Zeichen des Parameter-Namens von Unterstrich (`_`) zu Bindestrich (`-`) konvertieren, um die Header zu extrahieren und zu dokumentieren.
 
-HTTP-Header sind außerdem unabhängig von Groß-/Kleinschreibung, darum können Sie sie mittels der Standard-Python-Schreibweise deklarieren (auch bekannt als "snake_case").
+Außerdem ist Groß-/Klein­schrei­bung in HTTP-Headern nicht relevant, daher können Sie sie im Standard-Python-Stil (auch bekannt als „snake_case“) deklarieren.
 
-Sie können also `user_agent` schreiben, wie Sie es normalerweise in Python-Code machen würden, statt etwa die ersten Buchstaben groß zu schreiben, wie in `User_Agent`.
+Sie können also `user_agent` verwenden, wie Sie es normalerweise im Python-Code tun würden, anstatt die Anfangsbuchstaben wie bei `User_Agent` großzuschreiben oder Ähnliches.
 
-Wenn Sie aus irgendeinem Grund das automatische Konvertieren von Unterstrichen zu Bindestrichen abschalten möchten, setzen Sie den Parameter `convert_underscores` auf `False`.
+Wenn Sie aus irgendeinem Grund die automatische Konvertierung von Unterstrichen zu Bindestrichen deaktivieren müssen, setzen Sie den Parameter `convert_underscores` von `Header` auf `False`:
 
 {* ../../docs_src/header_params/tutorial002_an_py310.py hl[10] *}
 
@@ -54,26 +54,26 @@ Bevor Sie `convert_underscores` auf `False` setzen, bedenken Sie, dass manche HT
 
 ///
 
-## Doppelte Header
+## Doppelte Header { #duplicate-headers }
 
-Es ist möglich, doppelte Header zu empfangen. Also den gleichen Header mit unterschiedlichen Werten.
+Es ist möglich, doppelte Header zu empfangen. Damit ist gemeint, denselben Header mit mehreren Werten.
 
-Sie können solche Fälle deklarieren, indem Sie in der Typdeklaration eine Liste verwenden.
+Sie können solche Fälle definieren, indem Sie in der Typdeklaration eine Liste verwenden.
 
-Sie erhalten dann alle Werte von diesem doppelten Header als Python-`list`e.
+Sie erhalten dann alle Werte von diesem doppelten Header als Python-`list`.
 
-Um zum Beispiel einen Header `X-Token` zu deklarieren, der mehrmals vorkommen kann, schreiben Sie:
+Um beispielsweise einen `X-Token`-Header zu deklarieren, der mehrmals vorkommen kann, können Sie schreiben:
 
 {* ../../docs_src/header_params/tutorial003_an_py310.py hl[9] *}
 
-Wenn Sie mit einer *Pfadoperation* kommunizieren, die zwei HTTP-Header sendet, wie:
+Wenn Sie mit dieser *Pfadoperation* kommunizieren und zwei HTTP-Header senden, wie:
 
 ```
 X-Token: foo
 X-Token: bar
 ```
 
-Dann wäre die Response:
+Dann wäre die <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr>:
 
 ```JSON
 {
@@ -84,8 +84,8 @@ Dann wäre die Response:
 }
 ```
 
-## Zusammenfassung
+## Zusammenfassung { #recap }
 
-Deklarieren Sie Header mittels `Header`, auf die gleiche Weise wie bei `Query`, `Path` und `Cookie`.
+Deklarieren Sie Header mit `Header`, wobei Sie dasselbe gängige Muster wie bei `Query`, `Path` und `Cookie` verwenden.
 
-Machen Sie sich keine Sorgen um Unterstriche in ihren Variablen, **FastAPI** wird sich darum kümmern, diese zu konvertieren.
+Und machen Sie sich keine Sorgen um Unterstriche in Ihren Variablen, **FastAPI** wird sich darum kümmern, sie zu konvertieren.

docs/de/docs/tutorial/index.md

@@ -1,83 +1,95 @@
-# Tutorial – Benutzerhandbuch
+# Tutorial – Benutzerhandbuch { #tutorial-user-guide }
 
-Dieses Tutorial zeigt Ihnen Schritt für Schritt, wie Sie **FastAPI** und die meisten seiner Funktionen verwenden können.
+Dieses Tutorial zeigt Ihnen Schritt für Schritt, wie Sie **FastAPI** mit den meisten seiner Funktionen verwenden können.
 
-Jeder Abschnitt baut schrittweise auf den vorhergehenden auf. Diese Abschnitte sind aber nach einzelnen Themen gegliedert, sodass Sie direkt zu einem bestimmten Thema übergehen können, um Ihre speziellen API-Anforderungen zu lösen.
+Jeder Abschnitt baut schrittweise auf den vorhergehenden auf, ist jedoch in einzelne Themen gegliedert, sodass Sie direkt zu einem bestimmten Thema übergehen können, um Ihre spezifischen API-Anforderungen zu lösen.
 
-Außerdem dienen diese als zukünftige Referenz.
+Es ist auch so gestaltet, dass es als zukünftige Referenz dient, sodass Sie jederzeit zurückkommen und genau das sehen, was Sie benötigen.
 
-Dadurch können Sie jederzeit  zurückkommen und sehen genau das, was Sie benötigen.
+## Den Code ausführen { #run-the-code }
 
-## Den Code ausführen
+Alle Codeblöcke können kopiert und direkt verwendet werden (es sind tatsächlich getestete Python-Dateien).
 
-Alle Codeblöcke können kopiert und direkt verwendet werden (da es sich um getestete Python-Dateien handelt).
-
-Um eines der Beispiele auszuführen, kopieren Sie den Code in eine Datei `main.py`, und starten Sie `uvicorn` mit:
+Um eines der Beispiele auszuführen, kopieren Sie den Code in eine Datei `main.py` und starten Sie `fastapi dev` mit:
 
 <div class="termy">
 
 ```console
-$ uvicorn main:app --reload
+$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:solid">main.py</u>
+
+  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting development server 🚀
+
+             Searching for package file structure from directories
+             with <font color="#3465A4">__init__.py</font> files
+             Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
+
+   <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span>  🐍 main.py
+
+     <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span>  Importing the FastAPI app object from the module with
+             the following code:
+
+             <u style="text-decoration-style:solid">from </u><u style="text-decoration-style:solid"><b>main</b></u><u style="text-decoration-style:solid"> import </u><u style="text-decoration-style:solid"><b>app</b></u>
+
+      <span style="background-color:#007166"><font color="#D3D7CF"> app </font></span>  Using import string: <font color="#3465A4">main:app</font>
+
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Server started at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font>
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Documentation at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000/docs</u></font>
+
+      <span style="background-color:#007166"><font color="#D3D7CF"> tip </font></span>  Running in development mode, for production use:
+             <b>fastapi run</b>
 
-<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-<span style="color: green;">INFO</span>:     Started reloader process [28720]
-<span style="color: green;">INFO</span>:     Started server process [28722]
-<span style="color: green;">INFO</span>:     Waiting for application startup.
-<span style="color: green;">INFO</span>:     Application startup complete.
+             Logs:
+
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Will watch for changes in these directories:
+             <b>[</b><font color="#4E9A06">&apos;/home/user/code/awesomeapp&apos;</font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Uvicorn running on <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font> <b>(</b>Press CTRL+C
+             to quit<b>)</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started reloader process <b>[</b><font color="#34E2E2"><b>383138</b></font><b>]</b> using WatchFiles
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started server process <b>[</b><font color="#34E2E2"><b>383153</b></font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Waiting for application startup.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Application startup complete.
 ```
 
 </div>
 
-Es wird **ausdrücklich empfohlen**, dass Sie den Code schreiben oder kopieren, ihn bearbeiten und lokal ausführen.
+Es wird **dringend empfohlen**, den Code zu schreiben oder zu kopieren, ihn zu bearbeiten und lokal auszuführen.
 
 Die Verwendung in Ihrem eigenen Editor zeigt Ihnen die Vorteile von FastAPI am besten, wenn Sie sehen, wie wenig Code Sie schreiben müssen, all die Typprüfungen, die automatische Vervollständigung usw.
 
 ---
 
-## FastAPI installieren
+## FastAPI installieren { #install-fastapi }
 
-Der erste Schritt besteht aus der Installation von FastAPI.
+Der erste Schritt besteht darin, FastAPI zu installieren.
 
-Für dieses Tutorial empfiehlt es sich, FastAPI mit allen optionalen Abhängigkeiten und Funktionen zu installieren:
+Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellen, sie aktivieren und dann **FastAPI installieren**:
 
 <div class="termy">
 
 ```console
-$ pip install "fastapi[all]"
+$ pip install "fastapi[standard]"
 
 ---> 100%
 ```
 
 </div>
 
-... das beinhaltet auch `uvicorn`, welchen Sie als Server verwenden können, der ihren Code ausführt.
-
 /// note | Hinweis
 
-Sie können die einzelnen Teile auch separat installieren.
-
-Das folgende würden Sie wahrscheinlich tun, wenn Sie Ihre Anwendung in der Produktion einsetzen:
+Wenn Sie mit `pip install "fastapi[standard]"` installieren, werden einige optionale Standard-Abhängigkeiten mit installiert, einschließlich `fastapi-cloud-cli`, welches Ihnen das Deployment in der <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a> ermöglicht.
 
-```
-pip install fastapi
-```
-
-Installieren Sie auch `uvicorn` als Server:
-
-```
-pip install "uvicorn[standard]"
-```
+Wenn Sie diese optionalen Abhängigkeiten nicht haben möchten, können Sie stattdessen `pip install fastapi` installieren.
 
-Das gleiche gilt für jede der optionalen Abhängigkeiten, die Sie verwenden möchten.
+Wenn Sie die Standard-Abhängigkeiten, aber ohne das `fastapi-cloud-cli` installieren möchten, können Sie mit `pip install "fastapi[standard-no-fastapi-cloud-cli]"` installieren.
 
 ///
 
-## Handbuch für fortgeschrittene Benutzer
+## Handbuch für fortgeschrittene Benutzer { #advanced-user-guide }
 
-Es gibt auch ein **Handbuch für fortgeschrittene Benutzer**, welches Sie später nach diesem **Tutorial – Benutzerhandbuch** lesen können.
+Es gibt auch ein **Handbuch für fortgeschrittene Benutzer**, das Sie nach diesem **Tutorial – Benutzerhandbuch** lesen können.
 
-Das **Handbuch für fortgeschrittene Benutzer** baut auf diesem Tutorial auf, verwendet dieselben Konzepte und bringt Ihnen einige zusätzliche Funktionen bei.
+Das **Handbuch für fortgeschrittene Benutzer** baut hierauf auf, verwendet dieselben Konzepte und bringt Ihnen einige zusätzliche Funktionen bei.
 
-Allerdings sollten Sie zuerst das **Tutorial – Benutzerhandbuch** lesen (was Sie hier gerade tun).
+Sie sollten jedoch zuerst das **Tutorial – Benutzerhandbuch** lesen (was Sie gerade tun).
 
-Die Dokumentation ist so konzipiert, dass Sie mit dem **Tutorial – Benutzerhandbuch** eine vollständige Anwendung erstellen können und diese dann je nach Bedarf mit einigen der zusätzlichen Ideen aus dem **Handbuch für fortgeschrittene Benutzer** vervollständigen können.
+Es ist so konzipiert, dass Sie mit dem **Tutorial – Benutzerhandbuch** eine vollständige Anwendung erstellen können und diese dann je nach Bedarf mit einigen der zusätzlichen Ideen aus dem **Handbuch für fortgeschrittene Benutzer** erweitern können.

docs/de/docs/tutorial/metadata.md

@@ -1,10 +1,10 @@
-# Metadaten und URLs der Dokumentationen
+# Metadaten und Dokumentations-URLs { #metadata-and-docs-urls }
 
-Sie können mehrere Metadaten-Einstellungen für Ihre **FastAPI**-Anwendung konfigurieren.
+Sie können mehrere Metadaten-Konfigurationen in Ihrer **FastAPI**-Anwendung anpassen.
 
-## Metadaten für die API
+## Metadaten für die API { #metadata-for-api }
 
-Sie können die folgenden Felder festlegen, welche in der OpenAPI-Spezifikation und den Benutzeroberflächen der automatischen API-Dokumentation verwendet werden:
+Sie können die folgenden Felder festlegen, die in der OpenAPI-Spezifikation und in den Benutzeroberflächen der automatischen API-Dokumentation verwendet werden:
 
 | Parameter | Typ | Beschreibung |
 |------------|------|-------------|
@@ -13,16 +13,16 @@ Sie können die folgenden Felder festlegen, welche in der OpenAPI-Spezifikation
 | `description` | `str` | Eine kurze Beschreibung der API. Kann Markdown verwenden. |
 | `version` | `string` | Die Version der API. Das ist die Version Ihrer eigenen Anwendung, nicht die von OpenAPI. Zum Beispiel `2.5.0`. |
 | `terms_of_service` | `str` | Eine URL zu den Nutzungsbedingungen für die API. Falls angegeben, muss es sich um eine URL handeln. |
-| `contact` | `dict` | Die Kontaktinformationen für die verfügbar gemachte API. Kann mehrere Felder enthalten. <details><summary><code>contact</code>-Felder</summary><table><thead><tr><th>Parameter</th><th>Typ</th><th>Beschreibung</th></tr></thead><tbody><tr><td><code>name</code></td><td><code>str</code></td><td>Der identifizierende Name der Kontaktperson/Organisation.</td></tr><tr><td><code>url</code></td><td><code>str</code></td><td>Die URL, die auf die Kontaktinformationen verweist. MUSS im Format einer URL vorliegen.</td></tr><tr><td><code>email</code></td><td><code>str</code></td><td>Die E-Mail-Adresse der Kontaktperson/Organisation. MUSS im Format einer E-Mail-Adresse vorliegen.</td></tr></tbody></table></details> |
-| `license_info` | `dict` | Die Lizenzinformationen für die verfügbar gemachte API. Kann mehrere Felder enthalten. <details><summary><code>license_info</code>-Felder</summary><table><thead><tr><th>Parameter</th><th>Typ</th><th>Beschreibung</th></tr></thead><tbody><tr><td><code>name</code></td><td><code>str</code></td><td><strong>ERFORDERLICH</strong> (wenn eine <code>license_info</code> festgelegt ist). Der für die API verwendete Lizenzname.</td></tr><tr><td><code>identifier</code></td><td><code>str</code></td><td>Ein <a href="https://spdx.org/licenses/" class="external-link" target="_blank">SPDX</a>-Lizenzausdruck für die API. Das Feld <code>identifier</code> und das Feld <code>url</code> schließen sich gegenseitig aus. <small>Verfügbar seit OpenAPI 3.1.0, FastAPI 0.99.0.</small></td></tr><tr><td><code>url</code></td><td><code >str</code></td><td>Eine URL zur Lizenz, die für die API verwendet wird. MUSS im Format einer URL vorliegen.</td></tr></tbody></table></details> |
+| `contact` | `dict` | Die Kontaktinformationen für die freigegebene API. Kann mehrere Felder enthalten. <details><summary><code>contact</code>-Felder</summary><table><thead><tr><th>Parameter</th><th>Typ</th><th>Beschreibung</th></tr></thead><tbody><tr><td><code>name</code></td><td><code>str</code></td><td>Der identifizierende Name der Kontaktperson/Organisation.</td></tr><tr><td><code>url</code></td><td><code>str</code></td><td>Die URL, die auf die Kontaktinformationen verweist. MUSS im Format einer URL vorliegen.</td></tr><tr><td><code>email</code></td><td><code>str</code></td><td>Die E-Mail-Adresse der Kontaktperson/Organisation. MUSS im Format einer E-Mail-Adresse vorliegen.</td></tr></tbody></table></details> |
+| `license_info` | `dict` | Die Lizenzinformationen für die freigegebene API. Kann mehrere Felder enthalten. <details><summary><code>license_info</code>-Felder</summary><table><thead><tr><th>Parameter</th><th>Typ</th><th>Beschreibung</th></tr></thead><tbody><tr><td><code>name</code></td><td><code>str</code></td><td><strong>ERFORDERLICH</strong> (wenn eine <code>license_info</code> festgelegt ist). Der für die API verwendete Lizenzname.</td></tr><tr><td><code>identifier</code></td><td><code>str</code></td><td>Ein <a href="https://spdx.org/licenses/" class="external-link" target="_blank">SPDX</a>-Lizenzausdruck für die API. Das Feld <code>identifier</code> und das Feld <code>url</code> schließen sich gegenseitig aus. <small>Verfügbar seit OpenAPI 3.1.0, FastAPI 0.99.0.</small></td></tr><tr><td><code>url</code></td><td><code>str</code></td><td>Eine URL zur Lizenz, die für die API verwendet wird. MUSS im Format einer URL vorliegen.</td></tr></tbody></table></details> |
 
 Sie können diese wie folgt setzen:
 
-{* ../../docs_src/metadata/tutorial001.py hl[3:16,19:32] *}
+{* ../../docs_src/metadata/tutorial001.py hl[3:16, 19:32] *}
 
 /// tip | Tipp
 
-Sie können Markdown in das Feld `description` schreiben und es wird in der Ausgabe gerendert.
+Sie können Markdown im Feld `description` verwenden, und es wird in der Ausgabe gerendert.
 
 ///
 
@@ -30,7 +30,7 @@ Mit dieser Konfiguration würde die automatische API-Dokumentation wie folgt aus
 
 <img src="/img/tutorial/metadata/image01.png">
 
-## Lizenz-ID
+## Lizenzkennung { #license-identifier }
 
 Seit OpenAPI 3.1.0 und FastAPI 0.99.0 können Sie die `license_info` auch mit einem `identifier` anstelle einer `url` festlegen.
 
@@ -38,29 +38,29 @@ Zum Beispiel:
 
 {* ../../docs_src/metadata/tutorial001_1.py hl[31] *}
 
-## Metadaten für Tags
+## Metadaten für Tags { #metadata-for-tags }
 
-Sie können mit dem Parameter `openapi_tags` auch zusätzliche Metadaten für die verschiedenen Tags hinzufügen, die zum Gruppieren Ihrer Pfadoperationen verwendet werden.
+Sie können auch zusätzliche Metadaten für die verschiedenen Tags hinzufügen, die zum Gruppieren Ihrer Pfadoperationen verwendet werden, mit dem Parameter `openapi_tags`.
 
-Es wird eine Liste benötigt, die für jedes Tag ein Dict enthält.
+Er nimmt eine Liste entgegen, die für jeden Tag ein <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">Dictionary</abbr> enthält.
 
-Jedes Dict kann Folgendes enthalten:
+Jedes Dictionary kann Folgendes enthalten:
 
 * `name` (**erforderlich**): ein `str` mit demselben Tag-Namen, den Sie im Parameter `tags` in Ihren *Pfadoperationen* und `APIRouter`n verwenden.
 * `description`: ein `str` mit einer kurzen Beschreibung für das Tag. Sie kann Markdown enthalten und wird in der Benutzeroberfläche der Dokumentation angezeigt.
 * `externalDocs`: ein `dict`, das externe Dokumentation beschreibt mit:
-     * `description`: ein `str` mit einer kurzen Beschreibung für die externe Dokumentation.
-     * `url` (**erforderlich**): ein `str` mit der URL für die externe Dokumentation.
+    * `description`: ein `str` mit einer kurzen Beschreibung für die externe Dokumentation.
+    * `url` (**erforderlich**): ein `str` mit der URL für die externe Dokumentation.
 
-### Metadaten für Tags erstellen
+### Metadaten für Tags erstellen { #create-metadata-for-tags }
 
-Versuchen wir das an einem Beispiel mit Tags für `users` und `items`.
+Versuchen wir es mit einem Beispiel mit Tags für `users` und `items`.
 
-Erstellen Sie Metadaten für Ihre Tags und übergeben Sie sie an den Parameter `openapi_tags`:
+Erstellen Sie Metadaten für Ihre Tags und übergeben Sie diese an den Parameter `openapi_tags`:
 
 {* ../../docs_src/metadata/tutorial004.py hl[3:16,18] *}
 
-Beachten Sie, dass Sie Markdown in den Beschreibungen verwenden können. Beispielsweise wird „login“ in Fettschrift (**login**) und „fancy“ in Kursivschrift (_fancy_) angezeigt.
+Beachten Sie, dass Sie Markdown innerhalb der Beschreibungen verwenden können. Zum Beispiel wird „login“ in Fettschrift (**login**) und „fancy“ in Kursivschrift (_fancy_) angezeigt.
 
 /// tip | Tipp
 
@@ -68,31 +68,31 @@ Sie müssen nicht für alle von Ihnen verwendeten Tags Metadaten hinzufügen.
 
 ///
 
-### Ihre Tags verwenden
+### Ihre Tags verwenden { #use-your-tags }
 
 Verwenden Sie den Parameter `tags` mit Ihren *Pfadoperationen* (und `APIRouter`n), um diese verschiedenen Tags zuzuweisen:
 
 {* ../../docs_src/metadata/tutorial004.py hl[21,26] *}
 
-/// info
+/// info | Info
 
 Lesen Sie mehr zu Tags unter [Pfadoperation-Konfiguration](path-operation-configuration.md#tags){.internal-link target=_blank}.
 
 ///
 
-### Die Dokumentation anschauen
+### Die Dokumentation testen { #check-the-docs }
 
 Wenn Sie nun die Dokumentation ansehen, werden dort alle zusätzlichen Metadaten angezeigt:
 
 <img src="/img/tutorial/metadata/image02.png">
 
-### Reihenfolge der Tags
+### Reihenfolge der Tags { #order-of-tags }
 
-Die Reihenfolge der Tag-Metadaten-Dicts definiert auch die Reihenfolge, in der diese in der Benutzeroberfläche der Dokumentation angezeigt werden.
+Die Reihenfolge der Tag-Metadaten-Dictionarys definiert auch die Reihenfolge, in der diese in der Benutzeroberfläche der Dokumentation angezeigt werden.
 
-Auch wenn beispielsweise `users` im Alphabet nach `items` kommt, wird es vor diesen angezeigt, da wir seine Metadaten als erstes Dict der Liste hinzugefügt haben.
+Auch wenn beispielsweise `users` im Alphabet nach `items` kommt, wird es vor diesen angezeigt, da wir deren Metadaten als erstes Dictionary der Liste hinzugefügt haben.
 
-## OpenAPI-URL
+## OpenAPI-URL { #openapi-url }
 
 Standardmäßig wird das OpenAPI-Schema unter `/openapi.json` bereitgestellt.
 
@@ -104,16 +104,16 @@ Um beispielsweise festzulegen, dass es unter `/api/v1/openapi.json` bereitgestel
 
 Wenn Sie das OpenAPI-Schema vollständig deaktivieren möchten, können Sie `openapi_url=None` festlegen, wodurch auch die Dokumentationsbenutzeroberflächen deaktiviert werden, die es verwenden.
 
-## URLs der Dokumentationen
+## URLs der Dokumentationen { #docs-urls }
 
 Sie können die beiden enthaltenen Dokumentationsbenutzeroberflächen konfigurieren:
 
 * **Swagger UI**: bereitgestellt unter `/docs`.
-     * Sie können deren URL mit dem Parameter `docs_url` festlegen.
-     * Sie können sie deaktivieren, indem Sie `docs_url=None` festlegen.
+    * Sie können deren URL mit dem Parameter `docs_url` festlegen.
+    * Sie können sie deaktivieren, indem Sie `docs_url=None` festlegen.
 * **ReDoc**: bereitgestellt unter `/redoc`.
-     * Sie können deren URL mit dem Parameter `redoc_url` festlegen.
-     * Sie können sie deaktivieren, indem Sie `redoc_url=None` festlegen.
+    * Sie können deren URL mit dem Parameter `redoc_url` festlegen.
+    * Sie können sie deaktivieren, indem Sie `redoc_url=None` festlegen.
 
 Um beispielsweise Swagger UI so einzustellen, dass sie unter `/documentation` bereitgestellt wird, und ReDoc zu deaktivieren:
 

docs/de/docs/tutorial/middleware.md

@@ -1,8 +1,8 @@
-# Middleware
+# Middleware { #middleware }
 
 Sie können Middleware zu **FastAPI**-Anwendungen hinzufügen.
 
-Eine „Middleware“ ist eine Funktion, die mit jedem **Request** arbeitet, bevor er von einer bestimmten *Pfadoperation* verarbeitet wird. Und auch mit jeder **Response**, bevor sie zurückgegeben wird.
+Eine „Middleware“ ist eine Funktion, die mit jedem **<abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr>** arbeitet, bevor er von einer bestimmten *Pfadoperation* verarbeitet wird. Und auch mit jeder **<abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr>**, bevor sie zurückgegeben wird.
 
 * Sie nimmt jeden **Request** entgegen, der an Ihre Anwendung gesendet wird.
 * Sie kann dann etwas mit diesem **Request** tun oder beliebigen Code ausführen.
@@ -15,11 +15,11 @@ Eine „Middleware“ ist eine Funktion, die mit jedem **Request** arbeitet, bev
 
 Wenn Sie Abhängigkeiten mit `yield` haben, wird der Exit-Code *nach* der Middleware ausgeführt.
 
-Wenn es Hintergrundaufgaben gab (später dokumentiert), werden sie *nach* allen Middlewares ausgeführt.
+Wenn es Hintergrundtasks gab (dies wird später im [Hintergrundtasks](background-tasks.md){.internal-link target=_blank}-Abschnitt behandelt), werden sie *nach* allen Middlewares ausgeführt.
 
 ///
 
-## Erstellung einer Middleware
+## Eine Middleware erstellen { #create-a-middleware }
 
 Um eine Middleware zu erstellen, verwenden Sie den Dekorator `@app.middleware("http")` über einer Funktion.
 
@@ -35,9 +35,9 @@ Die Middleware-Funktion erhält:
 
 /// tip | Tipp
 
-Beachten Sie, dass benutzerdefinierte proprietäre Header hinzugefügt werden können. <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers" class="external-link" target="_blank">Verwenden Sie dafür das Präfix 'X-'</a>.
+Beachten Sie, dass benutzerdefinierte proprietäre Header hinzugefügt werden können <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers" class="external-link" target="_blank">unter Verwendung des `X-`-Präfixes</a>.
 
-Wenn Sie jedoch benutzerdefinierte Header haben, die ein Client in einem Browser sehen soll, müssen Sie sie zu Ihrer CORS-Konfigurationen ([CORS (Cross-Origin Resource Sharing)](cors.md){.internal-link target=_blank}) hinzufügen, indem Sie den Parameter `expose_headers` verwenden, der in der <a href="https://www.starlette.io/middleware/#corsmiddleware" class="external-link" target="_blank">Starlette-CORS-Dokumentation</a> dokumentiert ist.
+Wenn Sie jedoch benutzerdefinierte Header haben, die ein Client in einem Browser sehen soll, müssen Sie sie zu Ihrer CORS-Konfiguration ([CORS (Cross-Origin Resource Sharing)](cors.md){.internal-link target=_blank}) hinzufügen, indem Sie den Parameter `expose_headers` verwenden, der in der <a href="https://www.starlette.io/middleware/#corsmiddleware" class="external-link" target="_blank">Starlettes CORS-Dokumentation</a> dokumentiert ist.
 
 ///
 
@@ -49,7 +49,7 @@ Sie könnten auch `from starlette.requests import Request` verwenden.
 
 ///
 
-### Vor und nach der `response`
+### Vor und nach der `response` { #before-and-after-the-response }
 
 Sie können Code hinzufügen, der mit dem `request` ausgeführt wird, bevor dieser von einer beliebigen *Pfadoperation* empfangen wird.
 
@@ -59,8 +59,37 @@ Sie könnten beispielsweise einen benutzerdefinierten Header `X-Process-Time` hi
 
 {* ../../docs_src/middleware/tutorial001.py hl[10,12:13] *}
 
-## Andere Middlewares
+/// tip | Tipp
+
+Hier verwenden wir <a href="https://docs.python.org/3/library/time.html#time.perf_counter" class="external-link" target="_blank">`time.perf_counter()`</a> anstelle von `time.time()`, da es für diese Anwendungsfälle präziser sein kann. 🤓
+
+///
+
+## Ausführungsreihenfolge bei mehreren Middlewares { #multiple-middleware-execution-order }
+
+Wenn Sie mehrere Middlewares hinzufügen, entweder mit dem `@app.middleware()` Dekorator oder der Methode `app.add_middleware()`, umschließt jede neue Middleware die Anwendung und bildet einen Stapel. Die zuletzt hinzugefügte Middleware ist die *äußerste*, und die erste ist die *innerste*.
+
+Auf dem Requestpfad läuft die *äußerste* Middleware zuerst.
+
+Auf dem Responsepfad läuft sie zuletzt.
+
+Zum Beispiel:
+
+```Python
+app.add_middleware(MiddlewareA)
+app.add_middleware(MiddlewareB)
+```
+
+Dies führt zu folgender Ausführungsreihenfolge:
+
+* **Request**: MiddlewareB → MiddlewareA → Route
+
+* **Response**: Route → MiddlewareA → MiddlewareB
+
+Dieses Stapelverhalten stellt sicher, dass Middlewares in einer vorhersehbaren und kontrollierbaren Reihenfolge ausgeführt werden.
+
+## Andere Middlewares { #other-middlewares }
 
-Sie können später mehr über andere Middlewares in [Handbuch für fortgeschrittene Benutzer: Fortgeschrittene Middleware](../advanced/middleware.md){.internal-link target=_blank} lesen.
+Sie können später mehr über andere Middlewares im [Handbuch für fortgeschrittene Benutzer: Fortgeschrittene Middleware](../advanced/middleware.md){.internal-link target=_blank} lesen.
 
-In der nächsten Sektion erfahren Sie, wie Sie <abbr title="Cross-Origin Resource Sharing">CORS</abbr> mit einer Middleware behandeln können.
+In der nächsten Sektion erfahren Sie, wie Sie <abbr title="Cross-Origin Resource Sharing – Ressourcenfreigabe zwischen Ursprüngen">CORS</abbr> mit einer Middleware behandeln können.

docs/de/docs/tutorial/path-operation-configuration.md

@@ -1,6 +1,6 @@
-# Pfadoperation-Konfiguration
+# Pfadoperation-Konfiguration { #path-operation-configuration }
 
-Es gibt mehrere Konfigurations-Parameter, die Sie Ihrem *Pfadoperation-Dekorator* übergeben können.
+Es gibt mehrere Parameter, die Sie Ihrem *Pfadoperation-Dekorator* übergeben können, um ihn zu konfigurieren.
 
 /// warning | Achtung
 
@@ -8,13 +8,13 @@ Beachten Sie, dass diese Parameter direkt dem *Pfadoperation-Dekorator* übergeb
 
 ///
 
-## Response-Statuscode
+## Response-Statuscode { #response-status-code }
 
-Sie können den (HTTP-)`status_code` definieren, den die Response Ihrer *Pfadoperation* verwenden soll.
+Sie können den (HTTP-)`status_code` definieren, der in der <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> Ihrer *Pfadoperation* verwendet werden soll.
 
 Sie können direkt den `int`-Code übergeben, etwa `404`.
 
-Aber falls Sie sich nicht mehr erinnern, wofür jede Nummer steht, können Sie die Abkürzungs-Konstanten in `status` verwenden:
+Aber falls Sie sich nicht mehr erinnern, wofür jeder Nummerncode steht, können Sie die Abkürzungs-Konstanten in `status` verwenden:
 
 {* ../../docs_src/path_operation_configuration/tutorial001_py310.py hl[1,15] *}
 
@@ -28,9 +28,9 @@ Sie können auch `from starlette import status` verwenden.
 
 ///
 
-## Tags
+## Tags { #tags }
 
-Sie können Ihrer *Pfadoperation* Tags hinzufügen, mittels des Parameters `tags`, dem eine `list`e von `str`s übergeben wird (in der Regel nur ein `str`):
+Sie können Ihrer *Pfadoperation* Tags hinzufügen, indem Sie dem Parameter `tags` eine `list`e von `str`s übergeben (in der Regel nur ein `str`):
 
 {* ../../docs_src/path_operation_configuration/tutorial002_py310.py hl[15,20,25] *}
 
@@ -38,47 +38,47 @@ Diese werden zum OpenAPI-Schema hinzugefügt und von den automatischen Dokumenta
 
 <img src="/img/tutorial/path-operation-configuration/image01.png">
 
-### Tags mittels Enumeration
+### Tags mittels Enumeration { #tags-with-enums }
 
-Wenn Sie eine große Anwendung haben, können sich am Ende **viele Tags** anhäufen, und Sie möchten sicherstellen, dass Sie für verwandte *Pfadoperationen* immer den **gleichen Tag** nehmen.
+Wenn Sie eine große Anwendung haben, können sich am Ende **viele Tags** anhäufen, und Sie möchten sicherstellen, dass Sie für verwandte *Pfadoperationen* immer den **gleichen Tag** verwenden.
 
 In diesem Fall macht es Sinn, die Tags in einem `Enum` zu speichern.
 
-**FastAPI** unterstützt diese genauso wie einfache Strings:
+**FastAPI** unterstützt das auf die gleiche Weise wie einfache Strings:
 
 {* ../../docs_src/path_operation_configuration/tutorial002b.py hl[1,8:10,13,18] *}
 
-## Zusammenfassung und Beschreibung
+## Zusammenfassung und Beschreibung { #summary-and-description }
 
-Sie können eine Zusammenfassung (`summary`) und eine Beschreibung (`description`) hinzufügen:
+Sie können eine <abbr title="Zusammenfassung">`summary`</abbr> und eine <abbr title="Beschreibung">`description`</abbr> hinzufügen:
 
 {* ../../docs_src/path_operation_configuration/tutorial003_py310.py hl[18:19] *}
 
-## Beschreibung mittels Docstring
+## Beschreibung mittels Docstring { #description-from-docstring }
 
 Da Beschreibungen oft mehrere Zeilen lang sind, können Sie die Beschreibung der *Pfadoperation* im <abbr title="Ein mehrzeiliger String (keiner Variable zugewiesen) als erster Ausdruck in einer Funktion, wird für die Dokumentation derselben verwendet">Docstring</abbr> der Funktion deklarieren, und **FastAPI** wird sie daraus auslesen.
 
-Sie können im Docstring <a href="https://en.wikipedia.org/wiki/Markdown" class="external-link" target="_blank">Markdown</a> schreiben, es wird korrekt interpretiert und angezeigt (die Einrückung des Docstring beachtend).
+Sie können <a href="https://en.wikipedia.org/wiki/Markdown" class="external-link" target="_blank">Markdown</a> im Docstring schreiben, es wird korrekt interpretiert und angezeigt (unter Berücksichtigung der Einrückung des Docstring).
 
 {* ../../docs_src/path_operation_configuration/tutorial004_py310.py hl[17:25] *}
 
-In der interaktiven Dokumentation sieht das dann so aus:
+Es wird in der interaktiven Dokumentation verwendet:
 
 <img src="/img/tutorial/path-operation-configuration/image02.png">
 
-## Beschreibung der Response
+## Beschreibung der Response { #response-description }
 
-Die Response können Sie mit dem Parameter `response_description` beschreiben:
+Sie können die Response mit dem Parameter `response_description` beschreiben:
 
 {* ../../docs_src/path_operation_configuration/tutorial005_py310.py hl[19] *}
 
-/// info
+/// info | Info
 
-beachten Sie, dass sich `response_description` speziell auf die Response bezieht, während `description` sich generell auf die *Pfadoperation* bezieht.
+Beachten Sie, dass sich `response_description` speziell auf die Response bezieht, während `description` sich generell auf die *Pfadoperation* bezieht.
 
 ///
 
-/// check
+/// check | Testen
 
 OpenAPI verlangt, dass jede *Pfadoperation* über eine Beschreibung der Response verfügt.
 
@@ -88,13 +88,13 @@ Daher, wenn Sie keine vergeben, wird **FastAPI** automatisch eine für „Erfolg
 
 <img src="/img/tutorial/path-operation-configuration/image03.png">
 
-## Eine *Pfadoperation* deprecaten
+## Eine *Pfadoperation* deprecaten { #deprecate-a-path-operation }
 
-Wenn Sie eine *Pfadoperation* als <abbr title="deprecated – obsolet, veraltet: Es soll nicht mehr verwendet werden">deprecated</abbr> kennzeichnen möchten, ohne sie zu entfernen, fügen Sie den Parameter `deprecated` hinzu:
+Wenn Sie eine *Pfadoperation* als <abbr title="veraltet, obsolet: Es soll nicht mehr verwendet werden">deprecatet</abbr> kennzeichnen möchten, ohne sie zu entfernen, fügen Sie den Parameter `deprecated` hinzu:
 
 {* ../../docs_src/path_operation_configuration/tutorial006.py hl[16] *}
 
-Sie wird in der interaktiven Dokumentation gut sichtbar als deprecated markiert werden:
+Sie wird in der interaktiven Dokumentation gut sichtbar als deprecatet markiert werden:
 
 <img src="/img/tutorial/path-operation-configuration/image04.png">
 
@@ -102,6 +102,6 @@ Vergleichen Sie, wie deprecatete und nicht-deprecatete *Pfadoperationen* aussehe
 
 <img src="/img/tutorial/path-operation-configuration/image05.png">
 
-## Zusammenfassung
+## Zusammenfassung { #recap }
 
 Sie können auf einfache Weise Metadaten für Ihre *Pfadoperationen* definieren, indem Sie den *Pfadoperation-Dekoratoren* Parameter hinzufügen.

docs/de/docs/tutorial/path-params-numeric-validations.md

@@ -1,60 +1,56 @@
-# Pfad-Parameter und Validierung von Zahlen
+# Pfad-Parameter und Validierung von Zahlen { #path-parameters-and-numeric-validations }
 
-So wie Sie mit `Query` für Query-Parameter zusätzliche Validierungen und Metadaten hinzufügen können, können Sie das mittels `Path` auch für Pfad-Parameter tun.
+So wie Sie mit `Query` für Query-Parameter zusätzliche Validierungen und Metadaten deklarieren können, können Sie mit `Path` die gleichen Validierungen und Metadaten für Pfad-Parameter deklarieren.
 
-## `Path` importieren
+## `Path` importieren { #import-path }
 
-Importieren Sie zuerst `Path` von `fastapi`, und importieren Sie `Annotated`.
+Importieren Sie zuerst `Path` von `fastapi`, und importieren Sie `Annotated`:
 
 {* ../../docs_src/path_params_numeric_validations/tutorial001_an_py310.py hl[1,3] *}
 
-/// info
+/// info | Info
 
-FastAPI unterstützt (und empfiehlt die Verwendung von) `Annotated` seit Version 0.95.0.
+FastAPI hat in Version 0.95.0 Unterstützung für `Annotated` hinzugefügt und es zur Verwendung empfohlen.
 
-Wenn Sie eine ältere Version haben, werden Sie Fehler angezeigt bekommen, wenn Sie versuchen, `Annotated` zu verwenden.
+Wenn Sie eine ältere Version haben, würden Fehler angezeigt werden, wenn Sie versuchen, `Annotated` zu verwenden.
 
-Bitte [aktualisieren Sie FastAPI](../deployment/versions.md#upgrade-der-fastapi-versionen){.internal-link target=_blank} daher mindestens zu Version 0.95.1, bevor Sie `Annotated` verwenden.
+Stellen Sie sicher, dass Sie [FastAPI aktualisieren](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank}, auf mindestens Version 0.95.1, bevor Sie `Annotated` verwenden.
 
 ///
 
-## Metadaten deklarieren
+## Metadaten deklarieren { #declare-metadata }
 
-Sie können die gleichen Parameter deklarieren wie für `Query`.
+Sie können dieselben Parameter wie für `Query` deklarieren.
 
-Um zum Beispiel einen `title`-Metadaten-Wert für den Pfad-Parameter `item_id` zu deklarieren, schreiben Sie:
+Um zum Beispiel einen `title`-Metadaten-Wert für den Pfad-Parameter `item_id` zu deklarieren, können Sie schreiben:
 
 {* ../../docs_src/path_params_numeric_validations/tutorial001_an_py310.py hl[10] *}
 
 /// note | Hinweis
 
-Ein Pfad-Parameter ist immer erforderlich, weil er Teil des Pfads sein muss.
-
-Sie sollten ihn daher mit `...` deklarieren, um ihn als erforderlich auszuzeichnen.
-
-Doch selbst wenn Sie ihn mit `None` deklarieren, oder einen Defaultwert setzen, bewirkt das nichts, er bleibt immer erforderlich.
+Ein Pfad-Parameter ist immer erforderlich, da er Teil des Pfads sein muss. Selbst wenn Sie ihn mit `None` deklarieren oder einen Defaultwert setzen, würde das nichts ändern, er wäre dennoch immer erforderlich.
 
 ///
 
-## Sortieren Sie die Parameter, wie Sie möchten
+## Die Parameter sortieren, wie Sie möchten { #order-the-parameters-as-you-need }
 
 /// tip | Tipp
 
-Wenn Sie `Annotated` verwenden, ist das folgende nicht so wichtig / nicht notwendig.
+Das ist wahrscheinlich nicht so wichtig oder notwendig, wenn Sie `Annotated` verwenden.
 
 ///
 
-Nehmen wir an, Sie möchten den Query-Parameter `q` als erforderlichen `str` deklarieren.
+Angenommen, Sie möchten den Query-Parameter `q` als erforderlichen `str` deklarieren.
 
-Und Sie müssen sonst nichts anderes für den Parameter deklarieren, Sie brauchen also nicht wirklich `Query`.
+Und Sie müssen sonst nichts anderes für diesen Parameter deklarieren, Sie brauchen also `Query` nicht wirklich.
 
-Aber Sie brauchen `Path` für den `item_id`-Pfad-Parameter. Und Sie möchten aus irgendeinem Grund nicht `Annotated` verwenden.
+Aber Sie müssen dennoch `Path` für den `item_id`-Pfad-Parameter verwenden. Und aus irgendeinem Grund möchten Sie `Annotated` nicht verwenden.
 
-Python wird sich beschweren, wenn Sie einen Parameter mit Defaultwert vor einen Parameter ohne Defaultwert setzen.
+Python wird sich beschweren, wenn Sie einen Wert mit einem „Default“ vor einem Wert ohne „Default“ setzen.
 
-Aber Sie können die Reihenfolge der Parameter ändern, den Query-Parameter ohne Defaultwert zuerst.
+Aber Sie können die Reihenfolge ändern und den Wert ohne Default (den Query-Parameter `q`) zuerst setzen.
 
-Für **FastAPI** ist es nicht wichtig. Es erkennt die Parameter anhand ihres Namens, ihrer Typen, und ihrer Defaultwerte (`Query`, `Path`, usw.). Es kümmert sich nicht um die Reihenfolge.
+Für **FastAPI** spielt es keine Rolle. Es erkennt die Parameter anhand ihrer Namen, Typen und Default-Deklarationen (`Query`, `Path`, usw.), es kümmert sich nicht um die Reihenfolge.
 
 Sie können Ihre Funktion also so deklarieren:
 
@@ -66,104 +62,103 @@ Bevorzugen Sie die `Annotated`-Version, falls möglich.
 
 ///
 
-```Python hl_lines="7"
-{!> ../../docs_src/path_params_numeric_validations/tutorial002.py!}
-```
+{* ../../docs_src/path_params_numeric_validations/tutorial002.py hl[7] *}
 
 ////
 
-Aber bedenken Sie, dass Sie dieses Problem nicht haben, wenn Sie `Annotated` verwenden, da Sie nicht die Funktions-Parameter-Defaultwerte für `Query()` oder `Path()` verwenden.
+Aber bedenken Sie, dass Sie dieses Problem nicht haben, wenn Sie `Annotated` verwenden, da es nicht darauf ankommt, dass Sie keine Funktionsparameter-Defaultwerte für `Query()` oder `Path()` verwenden.
 
-{* ../../docs_src/path_params_numeric_validations/tutorial002_an_py39.py hl[10] *}
+{* ../../docs_src/path_params_numeric_validations/tutorial002_an_py39.py *}
 
-## Sortieren Sie die Parameter wie Sie möchten: Tricks
+## Die Parameter sortieren, wie Sie möchten: Tricks { #order-the-parameters-as-you-need-tricks }
 
 /// tip | Tipp
 
-Wenn Sie `Annotated` verwenden, ist das folgende nicht so wichtig / nicht notwendig.
+Das ist wahrscheinlich nicht so wichtig oder notwendig, wenn Sie `Annotated` verwenden.
 
 ///
 
-Hier ein **kleiner Trick**, der nützlich sein kann, aber Sie werden ihn nicht oft brauchen.
+Hier ist ein **kleiner Trick**, der nützlich sein kann, obwohl Sie ihn nicht oft benötigen werden.
 
-Wenn Sie eines der folgenden Dinge tun möchten:
+Wenn Sie:
 
-* den `q`-Parameter ohne `Query` oder irgendeinem Defaultwert deklarieren
-* den Pfad-Parameter `item_id` mittels `Path` deklarieren
-* die Parameter in einer unterschiedlichen Reihenfolge haben
-* `Annotated` nicht verwenden
+* den `q`-Query-Parameter sowohl ohne `Query` als auch ohne Defaultwert deklarieren
+* den Pfad-Parameter `item_id` mit `Path` deklarieren
+* sie in einer anderen Reihenfolge haben
+* nicht `Annotated` verwenden
 
-... dann hat Python eine kleine Spezial-Syntax für Sie.
+... möchten, dann hat Python eine kleine Spezial-Syntax dafür.
 
-Übergeben Sie der Funktion `*` als ersten Parameter.
+Übergeben Sie `*`, als den ersten Parameter der Funktion.
 
-Python macht nichts mit diesem `*`, aber es wird wissen, dass alle folgenden Parameter als <abbr title="Keyword-Argument – Schlüsselwort-Argument: Das Argument wird anhand seines Namens erkannt, nicht anhand seiner Reihenfolge in der Argumentliste">Keyword-Argumente</abbr> (Schlüssel-Wert-Paare), auch bekannt als <abbr title="Von: K-ey W-ord Arg-uments"><code>kwargs</code></abbr>, verwendet werden. Selbst wenn diese keinen Defaultwert haben.
+Python wird nichts mit diesem `*` machen, aber es wird wissen, dass alle folgenden Parameter als Schlüsselwortargumente (Schlüssel-Wert-Paare) verwendet werden sollen, auch bekannt als <abbr title="Von: K-ey W-ord Arg-uments"><code>kwargs</code></abbr>. Selbst wenn diese keinen Defaultwert haben.
 
 {* ../../docs_src/path_params_numeric_validations/tutorial003.py hl[7] *}
 
-### Besser mit `Annotated`
+### Besser mit `Annotated` { #better-with-annotated }
 
-Bedenken Sie, dass Sie, wenn Sie `Annotated` verwenden, dieses Problem nicht haben, weil Sie keine Defaultwerte für Ihre Funktionsparameter haben. Sie müssen daher wahrscheinlich auch nicht `*` verwenden.
+Bedenken Sie, dass Sie, wenn Sie `Annotated` verwenden, da Sie keine Funktionsparameter-Defaultwerte verwenden, dieses Problem nicht haben werden und wahrscheinlich nicht `*` verwenden müssen.
 
 {* ../../docs_src/path_params_numeric_validations/tutorial003_an_py39.py hl[10] *}
 
-## Validierung von Zahlen: Größer oder gleich
+## Validierung von Zahlen: Größer oder gleich { #number-validations-greater-than-or-equal }
+
+Mit `Query` und `Path` (und anderen, die Sie später sehen werden) können Sie Zahlenbeschränkungen deklarieren.
 
-Mit `Query` und `Path` (und anderen, die Sie später kennenlernen), können Sie Zahlenbeschränkungen deklarieren.
+Hier, mit `ge=1`, muss `item_id` eine ganze Zahl sein, die „`g`reater than or `e`qual to“ (größer oder gleich) `1` ist.
 
-Hier, mit `ge=1`, wird festgelegt, dass `item_id` eine Ganzzahl benötigt, die größer oder gleich `1` ist (`g`reater than or `e`qual).
 {* ../../docs_src/path_params_numeric_validations/tutorial004_an_py39.py hl[10] *}
 
-## Validierung von Zahlen: Größer und kleiner oder gleich
+## Validierung von Zahlen: Größer und kleiner oder gleich { #number-validations-greater-than-and-less-than-or-equal }
 
-Das Gleiche trifft zu auf:
+Das Gleiche gilt für:
 
-* `gt`: `g`reater `t`han – größer als
-* `le`: `l`ess than or `e`qual – kleiner oder gleich
+* `gt`: `g`reater `t`han (größer als)
+* `le`: `l`ess than or `e`qual (kleiner oder gleich)
 
 {* ../../docs_src/path_params_numeric_validations/tutorial005_an_py39.py hl[10] *}
 
-## Validierung von Zahlen: Floats, größer und kleiner
+## Validierung von Zahlen: Floats, größer und kleiner { #number-validations-floats-greater-than-and-less-than }
 
-Zahlenvalidierung funktioniert auch für <abbr title="Kommazahl">`float`</abbr>-Werte.
+Zahlenvalidierung funktioniert auch für <abbr title="Fließkommazahlen">`float`</abbr>-Werte.
 
-Hier wird es wichtig, in der Lage zu sein, <abbr title="greater than – größer als"><code>gt</code></abbr> zu deklarieren, und nicht nur <abbr title="greater than or equal – größer oder gleich"><code>ge</code></abbr>, da Sie hiermit bestimmen können, dass ein Wert, zum Beispiel, größer als `0` sein muss, obwohl er kleiner als `1` ist.
+Hier wird es wichtig, in der Lage zu sein, <abbr title="greater than – größer als"><code>gt</code></abbr> und nicht nur <abbr title="greater than or equal – größer oder gleich"><code>ge</code></abbr> zu deklarieren. Da Sie mit dieser Option erzwingen können, dass ein Wert größer als `0` sein muss, selbst wenn er kleiner als `1` ist.
 
-`0.5` wäre also ein gültiger Wert, aber nicht `0.0` oder `0`.
+Also wäre `0.5` ein gültiger Wert. Aber `0.0` oder `0` nicht.
 
-Das gleiche gilt für <abbr title="less than – kleiner als"><code>lt</code></abbr>.
+Und das Gleiche gilt für <abbr title="less than – kleiner als"><code>lt</code></abbr>.
 
 {* ../../docs_src/path_params_numeric_validations/tutorial006_an_py39.py hl[13] *}
 
-## Zusammenfassung
+## Zusammenfassung { #recap }
 
-Mit `Query` und `Path` (und anderen, die Sie noch nicht gesehen haben) können Sie Metadaten und Stringvalidierungen deklarieren, so wie in [Query-Parameter und Stringvalidierungen](query-params-str-validations.md){.internal-link target=_blank} beschrieben.
+Mit `Query`, `Path` (und anderen, die Sie noch nicht gesehen haben) können Sie Metadaten und Stringvalidierungen auf die gleichen Weisen deklarieren wie in [Query-Parameter und Stringvalidierungen](query-params-str-validations.md){.internal-link target=_blank} beschrieben.
 
-Und Sie können auch Validierungen für Zahlen deklarieren:
+Und Sie können auch Zahlenvalidierungen deklarieren:
 
-* `gt`: `g`reater `t`han – größer als
-* `ge`: `g`reater than or `e`qual – größer oder gleich
-* `lt`: `l`ess `t`han – kleiner als
-* `le`: `l`ess than or `e`qual – kleiner oder gleich
+* `gt`: `g`reater `t`han (größer als)
+* `ge`: `g`reater than or `e`qual (größer oder gleich)
+* `lt`: `l`ess `t`han (kleiner als)
+* `le`: `l`ess than or `e`qual (kleiner oder gleich)
 
-/// info
+/// info | Info
 
-`Query`, `Path`, und andere Klassen, die Sie später kennenlernen, sind Unterklassen einer allgemeinen `Param`-Klasse.
+`Query`, `Path`, und andere Klassen, die Sie später sehen werden, sind Unterklassen einer gemeinsamen `Param`-Klasse.
 
-Sie alle teilen die gleichen Parameter für zusätzliche Validierung und Metadaten, die Sie gesehen haben.
+Alle von ihnen teilen die gleichen Parameter für zusätzliche Validierung und Metadaten, die Sie gesehen haben.
 
 ///
 
 /// note | Technische Details
 
-`Query`, `Path` und andere, die Sie von `fastapi` importieren, sind tatsächlich Funktionen.
+Wenn Sie `Query`, `Path` und andere von `fastapi` importieren, sind sie tatsächlich Funktionen.
 
-Die, wenn sie aufgerufen werden, Instanzen der Klassen mit demselben Namen zurückgeben.
+Die, wenn sie aufgerufen werden, Instanzen von Klassen mit demselben Namen zurückgeben.
 
-Sie importieren also `Query`, welches eine Funktion ist. Aber wenn Sie es aufrufen, gibt es eine Instanz der Klasse zurück, die auch `Query` genannt wird.
+Sie importieren also `Query`, was eine Funktion ist. Und wenn Sie sie aufrufen, gibt sie eine Instanz einer Klasse zurück, die auch `Query` genannt wird.
 
 Diese Funktionen existieren (statt die Klassen direkt zu verwenden), damit Ihr Editor keine Fehlermeldungen über ihre Typen ausgibt.
 
-Auf diese Weise können Sie Ihren Editor und Ihre Programmier-Tools verwenden, ohne besondere Einstellungen vornehmen zu müssen, um diese Fehlermeldungen stummzuschalten.
+Auf diese Weise können Sie Ihren normalen Editor und Ihre Programmier-Tools verwenden, ohne besondere Einstellungen vornehmen zu müssen, um diese Fehlermeldungen stummzuschalten.
 
 ///

docs/de/docs/tutorial/path-params.md

@@ -1,18 +1,18 @@
-# Pfad-Parameter
+# Pfad-Parameter { #path-parameters }
 
-Sie können Pfad-„Parameter“ oder -„Variablen“ mit der gleichen Syntax deklarieren, welche in Python-<abbr title="Format-String – Formatierter String: Der String enthält Variablen, die mit geschweiften Klammern umschlossen sind. Solche Stellen werden durch den Wert der Variable ersetzt">Format-Strings</abbr> verwendet wird:
+Sie können Pfad-„Parameter“ oder -„Variablen“ mit der gleichen Syntax deklarieren, welche in Python-<abbr title="Formatstring – Formatierter String: Der String enthält Ausdrücke, die mit geschweiften Klammern umschlossen sind. Solche Stellen werden durch den Wert des Ausdrucks ersetzt">Formatstrings</abbr> verwendet wird:
 
 {* ../../docs_src/path_params/tutorial001.py hl[6:7] *}
 
 Der Wert des Pfad-Parameters `item_id` wird Ihrer Funktion als das Argument `item_id` übergeben.
 
-Wenn Sie dieses Beispiel ausführen und auf <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a> gehen, sehen Sie als Response:
+Wenn Sie dieses Beispiel ausführen und auf <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a> gehen, sehen Sie als <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr>:
 
 ```JSON
 {"item_id":"foo"}
 ```
 
-## Pfad-Parameter mit Typen
+## Pfad-Parameter mit Typen { #path-parameters-with-types }
 
 Sie können den Typ eines Pfad-Parameters in der Argumentliste der Funktion deklarieren, mit Standard-Python-Typannotationen:
 
@@ -20,13 +20,13 @@ Sie können den Typ eines Pfad-Parameters in der Argumentliste der Funktion dekl
 
 In diesem Fall wird `item_id` als `int` deklariert, also als Ganzzahl.
 
-/// check
+/// check | Testen
 
 Dadurch erhalten Sie Editor-Unterstützung innerhalb Ihrer Funktion, mit Fehlerprüfungen, Codevervollständigung, usw.
 
 ///
 
-## Daten-<abbr title="Auch bekannt als: Serialisierung, Parsen, Marshalling">Konversion</abbr>
+## Daten-<abbr title="Auch bekannt als: Serialisierung, Parsen, Marshalling">Konversion</abbr> { #data-conversion }
 
 Wenn Sie dieses Beispiel ausführen und Ihren Browser unter <a href="http://127.0.0.1:8000/items/3" class="external-link" target="_blank">http://127.0.0.1:8000/items/3</a> öffnen, sehen Sie als Response:
 
@@ -34,15 +34,15 @@ Wenn Sie dieses Beispiel ausführen und Ihren Browser unter <a href="http://127.
 {"item_id":3}
 ```
 
-/// check
+/// check | Testen
 
 Beachten Sie, dass der Wert, den Ihre Funktion erhält und zurückgibt, die Zahl `3` ist, also ein `int`. Nicht der String `"3"`, also ein `str`.
 
-Sprich, mit dieser Typdeklaration wird **FastAPI** die Anfrage automatisch <abbr title="Den String, der von einer HTTP Anfrage kommt, in Python-Objekte konvertieren">„parsen“</abbr>.
+Sprich, mit dieser Typdeklaration wird **FastAPI** den <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> automatisch <abbr title="Den String, der von einem HTTP-Request kommt, in Python-Objekte konvertieren">„parsen“</abbr>.
 
 ///
 
-## Datenvalidierung
+## Datenvalidierung { #data-validation }
 
 Wenn Sie aber im Browser <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a> besuchen, erhalten Sie eine hübsche HTTP-Fehlermeldung:
 
@@ -67,7 +67,7 @@ Der Pfad-Parameter `item_id` hatte den Wert `"foo"`, was kein `int` ist.
 
 Die gleiche Fehlermeldung würde angezeigt werden, wenn Sie ein `float` (also eine Kommazahl) statt eines `int`s übergeben würden, wie etwa in: <a href="http://127.0.0.1:8000/items/4.2" class="external-link" target="_blank">http://127.0.0.1:8000/items/4.2</a>
 
-/// check
+/// check | Testen
 
 Sprich, mit der gleichen Python-Typdeklaration gibt Ihnen **FastAPI** Datenvalidierung.
 
@@ -77,13 +77,13 @@ Das ist unglaublich hilfreich, wenn Sie Code entwickeln und debuggen, welcher mi
 
 ///
 
-## Dokumentation
+## Dokumentation { #documentation }
 
 Wenn Sie die Seite <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> in Ihrem Browser öffnen, sehen Sie eine automatische, interaktive API-Dokumentation:
 
 <img src="/img/tutorial/path-params/image01.png">
 
-/// check
+/// check | Testen
 
 Wiederum, mit dieser gleichen Python-Typdeklaration gibt Ihnen **FastAPI** eine automatische, interaktive Dokumentation (verwendet die Swagger-Benutzeroberfläche).
 
@@ -91,7 +91,7 @@ Beachten Sie, dass der Pfad-Parameter dort als Ganzzahl deklariert ist.
 
 ///
 
-## Nützliche Standards. Alternative Dokumentation
+## Nützliche Standards. Alternative Dokumentation { #standards-based-benefits-alternative-documentation }
 
 Und weil das generierte Schema vom <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md" class="external-link" target="_blank">OpenAPI</a>-Standard kommt, gibt es viele kompatible Tools.
 
@@ -101,15 +101,15 @@ Zum Beispiel bietet **FastAPI** selbst eine alternative API-Dokumentation (verwe
 
 Und viele weitere kompatible Tools. Inklusive Codegenerierung für viele Sprachen.
 
-## Pydantic
+## Pydantic { #pydantic }
 
-Die ganze Datenvalidierung wird hinter den Kulissen von <a href="https://pydantic-docs.helpmanual.io/" class="external-link" target="_blank">Pydantic</a> durchgeführt, Sie profitieren also von dessen Vorteilen. Und Sie wissen, dass Sie in guten Händen sind.
+Die ganze Datenvalidierung wird hinter den Kulissen von <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> durchgeführt, Sie profitieren also von dessen Vorteilen. Und Sie wissen, dass Sie in guten Händen sind.
 
 Sie können für Typ Deklarationen auch `str`, `float`, `bool` und viele andere komplexe Datentypen verwenden.
 
 Mehrere davon werden wir in den nächsten Kapiteln erkunden.
 
-## Die Reihenfolge ist wichtig
+## Die Reihenfolge ist wichtig { #order-matters }
 
 Wenn Sie *Pfadoperationen* erstellen, haben Sie manchmal einen fixen Pfad.
 
@@ -129,23 +129,23 @@ Sie können eine Pfadoperation auch nicht erneut definieren:
 
 Die erste Definition wird immer verwendet werden, da ihr Pfad zuerst übereinstimmt.
 
-## Vordefinierte Parameterwerte
+## Vordefinierte Parameterwerte { #predefined-values }
 
-Wenn Sie eine *Pfadoperation* haben, welche einen *Pfad-Parameter* hat, aber Sie wollen, dass dessen gültige Werte vordefiniert sind, können Sie ein Standard-Python <abbr title="Enumeration, oder kurz Enum – Aufzählung">`Enum`</abbr> verwenden.
+Wenn Sie eine *Pfadoperation* haben, welche einen *Pfad-Parameter* hat, aber Sie wollen, dass dessen gültige Werte vordefiniert sind, können Sie ein Standard-Python <abbr title="Enumeration – Aufzählung">`Enum`</abbr> verwenden.
 
-### Erstellen Sie eine `Enum`-Klasse
+### Eine `Enum`-Klasse erstellen { #create-an-enum-class }
 
 Importieren Sie `Enum` und erstellen Sie eine Unterklasse, die von `str` und `Enum` erbt.
 
-Indem Sie von `str` erben, weiß die API Dokumentation, dass die Werte des Enums vom Typ `str` sein müssen, und wird in der Lage sein, korrekt zu rendern.
+Indem Sie von `str` erben, weiß die API Dokumentation, dass die Werte vom Typ `str` sein müssen, und wird in der Lage sein, korrekt zu rendern.
 
 Erstellen Sie dann Klassen-Attribute mit festgelegten Werten, welches die erlaubten Werte sein werden:
 
 {* ../../docs_src/path_params/tutorial005.py hl[1,6:9] *}
 
-/// info
+/// info | Info
 
-<a href="https://docs.python.org/3/library/enum.html" class="external-link" target="_blank">Enumerationen (oder kurz Enums)</a> gibt es in Python seit Version 3.4.
+<a href="https://docs.python.org/3/library/enum.html" class="external-link" target="_blank">Enumerationen (oder Enums)</a> gibt es in Python seit Version 3.4.
 
 ///
 
@@ -155,29 +155,29 @@ Falls Sie sich fragen, was „AlexNet“, „ResNet“ und „LeNet“ ist, das
 
 ///
 
-### Deklarieren Sie einen *Pfad-Parameter*
+### Einen *Pfad-Parameter* deklarieren { #declare-a-path-parameter }
 
 Dann erstellen Sie einen *Pfad-Parameter*, der als Typ die gerade erstellte Enum-Klasse hat (`ModelName`):
 
 {* ../../docs_src/path_params/tutorial005.py hl[16] *}
 
-### Testen Sie es in der API-Dokumentation
+### Die API-Dokumentation testen { #check-the-docs }
 
 Weil die erlaubten Werte für den *Pfad-Parameter* nun vordefiniert sind, kann die interaktive Dokumentation sie als Auswahl-Drop-Down anzeigen:
 
 <img src="/img/tutorial/path-params/image03.png">
 
-### Mit Python-*<abbr title="Enumeration – Aufzählung">Enums</abbr>* arbeiten
+### Mit Python-*Enumerationen* arbeiten { #working-with-python-enumerations }
 
-Der *Pfad-Parameter* wird ein *<abbr title="Member – Mitglied: Einer der möglichen Werte einer Enumeration">Member</abbr> eines Enums* sein.
+Der *Pfad-Parameter* wird ein *<abbr title="Member – Mitglied: Einer der möglichen Werte einer Enumeration">Member</abbr> einer Enumeration* sein.
 
-#### *Enum-Member* vergleichen
+#### *Enumeration-Member* vergleichen { #compare-enumeration-members }
 
-Sie können ihn mit einem Member Ihres Enums `ModelName` vergleichen:
+Sie können ihn mit einem Member Ihrer Enumeration `ModelName` vergleichen:
 
 {* ../../docs_src/path_params/tutorial005.py hl[17] *}
 
-#### *Enum-Wert* erhalten
+#### *Enumerations-Wert* erhalten { #get-the-enumeration-value }
 
 Den tatsächlichen Wert (in diesem Fall ein `str`) erhalten Sie via `model_name.value`, oder generell, `ihr_enum_member.value`:
 
@@ -189,7 +189,7 @@ Sie können den Wert `"lenet"` außerdem mittels `ModelName.lenet.value` abrufen
 
 ///
 
-#### *Enum-Member* zurückgeben
+#### *Enumeration-Member* zurückgeben { #return-enumeration-members }
 
 Sie können *Enum-Member* in ihrer *Pfadoperation* zurückgeben, sogar verschachtelt in einem JSON-Body (z. B. als `dict`).
 
@@ -206,7 +206,7 @@ In Ihrem Client erhalten Sie eine JSON-Response, wie etwa:
 }
 ```
 
-## Pfad Parameter die Pfade enthalten
+## Pfad Parameter die Pfade enthalten { #path-parameters-containing-paths }
 
 Angenommen, Sie haben eine *Pfadoperation* mit einem Pfad `/files/{file_path}`.
 
@@ -214,7 +214,7 @@ Aber `file_path` soll selbst einen *Pfad* enthalten, etwa `home/johndoe/myfile.t
 
 Sprich, die URL für diese Datei wäre etwas wie: `/files/home/johndoe/myfile.txt`.
 
-### OpenAPI Unterstützung
+### OpenAPI Unterstützung { #openapi-support }
 
 OpenAPI bietet nicht die Möglichkeit, dass ein *Pfad-Parameter* seinerseits einen *Pfad* enthalten kann, das würde zu Szenarios führen, die schwierig zu testen und zu definieren sind.
 
@@ -222,7 +222,7 @@ Trotzdem können Sie das in **FastAPI** tun, indem Sie eines der internen Tools
 
 Die Dokumentation würde weiterhin funktionieren, allerdings wird nicht dokumentiert werden, dass der Parameter ein Pfad sein sollte.
 
-### Pfad Konverter
+### Pfad Konverter { #path-convertor }
 
 Mittels einer Option direkt von Starlette können Sie einen *Pfad-Parameter* deklarieren, der einen Pfad enthalten soll, indem Sie eine URL wie folgt definieren:
 
@@ -244,12 +244,12 @@ In dem Fall wäre die URL: `/files//home/johndoe/myfile.txt`, mit einem doppelte
 
 ///
 
-## Zusammenfassung
+## Zusammenfassung { #recap }
 
 In **FastAPI** erhalten Sie mittels kurzer, intuitiver Typdeklarationen:
 
 * Editor-Unterstützung: Fehlerprüfungen, Codevervollständigung, usw.
-* Daten "<abbr title="Den String, der von einer HTTP Anfrage kommt, nach Python-Daten konvertieren">parsen</abbr>"
+* Daten "<abbr title="Den String, der von einem HTTP-Request kommt, nach Python-Daten konvertieren">parsen</abbr>"
 * Datenvalidierung
 * API-Annotationen und automatische Dokumentation
 

docs/de/docs/tutorial/query-param-models.md

@@ -0,0 +1,68 @@
+# Query-Parameter-Modelle { #query-parameter-models }
+
+Wenn Sie eine Gruppe von **Query-Parametern** haben, die miteinander in Beziehung stehen, können Sie ein **Pydantic-Modell** erstellen, um diese zu deklarieren.
+
+Dadurch können Sie das **Modell an mehreren Stellen wiederverwenden** und gleichzeitig Validierungen und Metadaten für alle Parameter auf einmal deklarieren. 😎
+
+/// note | Hinweis
+
+Dies wird seit FastAPI Version `0.115.0` unterstützt. 🤓
+
+///
+
+## Query-Parameter mit einem Pydantic-Modell { #query-parameters-with-a-pydantic-model }
+
+Deklarieren Sie die benötigten **Query-Parameter** in einem **Pydantic-Modell** und dann den Parameter als `Query`:
+
+{* ../../docs_src/query_param_models/tutorial001_an_py310.py hl[9:13,17] *}
+
+**FastAPI** wird die Daten für **jedes Feld** aus den **Query-Parametern** des <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> extrahieren und Ihnen das definierte Pydantic-Modell bereitstellen.
+
+## Die Dokumentation testen { #check-the-docs }
+
+Sie können die Query-Parameter in der Dokumentations-Oberfläche unter `/docs` einsehen:
+
+<div class="screenshot">
+<img src="/img/tutorial/query-param-models/image01.png">
+</div>
+
+## Zusätzliche Query-Parameter verbieten { #forbid-extra-query-parameters }
+
+In einigen speziellen Anwendungsfällen (wahrscheinlich nicht sehr häufig) möchten Sie möglicherweise die Query-Parameter, die Sie empfangen möchten, **beschränken**.
+
+Sie können die Modellkonfiguration von Pydantic verwenden, um jegliche `extra` Felder zu `verbieten`:
+
+{* ../../docs_src/query_param_models/tutorial002_an_py310.py hl[10] *}
+
+Wenn ein Client versucht, einige **zusätzliche** Daten in den **Query-Parametern** zu senden, erhält er eine **Error-<abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr>**.
+
+Wenn der Client beispielsweise versucht, einen `tool` Query-Parameter mit dem Wert `plumbus` zu senden, wie:
+
+```http
+https://example.com/items/?limit=10&tool=plumbus
+```
+
+erhält er eine **Error-Response**, die ihm mitteilt, dass der Query-Parameter `tool` nicht erlaubt ist:
+
+```json
+{
+    "detail": [
+        {
+            "type": "extra_forbidden",
+            "loc": ["query", "tool"],
+            "msg": "Extra inputs are not permitted",
+            "input": "plumbus"
+        }
+    ]
+}
+```
+
+## Zusammenfassung { #summary }
+
+Sie können **Pydantic-Modelle** verwenden, um **Query-Parameter** in **FastAPI** zu deklarieren. 😎
+
+/// tip | Tipp
+
+Spoiler-Alarm: Sie können auch Pydantic-Modelle verwenden, um Cookies und Header zu deklarieren, aber darüber werden Sie später im Tutorial lesen. 🤫
+
+///

docs/de/docs/tutorial/query-params-str-validations.md

@@ -1,69 +1,49 @@
-# Query-Parameter und Stringvalidierung
+# Query-Parameter und String-Validierungen { #query-parameters-and-string-validations }
 
-**FastAPI** erlaubt es Ihnen, Ihre Parameter zusätzlich zu validieren, und zusätzliche Informationen hinzuzufügen.
+**FastAPI** ermöglicht es Ihnen, zusätzliche Informationen und Validierungen für Ihre Parameter zu deklarieren.
 
-Nehmen wir als Beispiel die folgende Anwendung:
+Nehmen wir diese Anwendung als Beispiel:
 
 {* ../../docs_src/query_params_str_validations/tutorial001_py310.py hl[7] *}
 
-Der Query-Parameter `q` hat den Typ `Union[str, None]` (oder `str | None` in Python 3.10), was bedeutet, er ist entweder ein `str` oder `None`. Der Defaultwert ist `None`, also weiß FastAPI, der Parameter ist nicht erforderlich.
+Der Query-Parameter `q` hat den Typ `str | None`, das bedeutet, dass er vom Typ `str` sein kann, aber auch `None`, und tatsächlich ist der Defaultwert `None`, sodass FastAPI weiß, dass er nicht erforderlich ist.
 
 /// note | Hinweis
 
-FastAPI weiß nur dank des definierten Defaultwertes `=None`, dass der Wert von `q` nicht erforderlich ist
+FastAPI erkennt, dass der Wert von `q` nicht erforderlich ist, aufgrund des Defaultwertes `= None`.
 
-`Union[str, None]` hingegen erlaubt ihren Editor, Sie besser zu unterstützen und Fehler zu erkennen.
+Die Verwendung von `str | None` ermöglicht es Ihrem Editor, Ihnen bessere Unterstützung zu bieten und Fehler zu erkennen.
 
 ///
 
-## Zusätzliche Validierung
+## Zusätzliche Validierung { #additional-validation }
 
-Wir werden bewirken, dass, obwohl `q` optional ist, wenn es gegeben ist, **seine Länge 50 Zeichen nicht überschreitet**.
+Wir werden sicherstellen, dass, obwohl `q` optional ist, wann immer es bereitgestellt wird, **seine Länge 50 Zeichen nicht überschreitet**.
 
-### `Query` und `Annotated` importieren
+### `Query` und `Annotated` importieren { #import-query-and-annotated }
 
-Importieren Sie zuerst:
+Um dies zu erreichen, importieren Sie zuerst:
 
 * `Query` von `fastapi`
-* `Annotated` von `typing` (oder von `typing_extensions` in Python unter 3.9)
+* `Annotated` von `typing`
 
-//// tab | Python 3.10+
-
-In Python 3.9 oder darüber, ist `Annotated` Teil der Standardbibliothek, also können Sie es von `typing` importieren.
-
-```Python hl_lines="1  3"
-{!> ../../docs_src/query_params_str_validations/tutorial002_an_py310.py!}
-```
+{* ../../docs_src/query_params_str_validations/tutorial002_an_py310.py hl[1,3] *}
 
-////
-
-//// tab | Python 3.8+
-
-In Versionen unter Python 3.9 importieren Sie `Annotated` von `typing_extensions`.
-
-Es wird bereits mit FastAPI installiert sein.
-
-```Python hl_lines="3-4"
-{!> ../../docs_src/query_params_str_validations/tutorial002_an.py!}
-```
-
-////
+/// info | Info
 
-/// info
+FastAPI hat Unterstützung für `Annotated` hinzugefügt (und begonnen, es zu empfehlen) in der Version 0.95.0.
 
-FastAPI unterstützt (und empfiehlt die Verwendung von) `Annotated` seit Version 0.95.0.
+Wenn Sie eine ältere Version haben, würden Sie Fehler erhalten, beim Versuch, `Annotated` zu verwenden.
 
-Wenn Sie eine ältere Version haben, werden Sie Fehler angezeigt bekommen, wenn Sie versuchen, `Annotated` zu verwenden.
-
-Bitte [aktualisieren Sie FastAPI](../deployment/versions.md#upgrade-der-fastapi-versionen){.internal-link target=_blank} daher mindestens zu Version 0.95.1, bevor Sie `Annotated` verwenden.
+Stellen Sie sicher, dass Sie [die FastAPI-Version aktualisieren](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank}, auf mindestens Version 0.95.1, bevor Sie `Annotated` verwenden.
 
 ///
 
-## `Annotated` im Typ des `q`-Parameters verwenden
+## Verwenden von `Annotated` im Typ für den `q`-Parameter { #use-annotated-in-the-type-for-the-q-parameter }
 
-Erinnern Sie sich, wie ich in [Einführung in Python-Typen](../python-types.md#typhinweise-mit-metadaten-annotationen){.internal-link target=_blank} sagte, dass Sie mittels `Annotated` Metadaten zu Ihren Parametern hinzufügen können?
+Erinnern Sie sich, dass ich Ihnen zuvor in [Python-Typen-Intro](../python-types.md#type-hints-with-metadata-annotations){.internal-link target=_blank} gesagt habe, dass `Annotated` verwendet werden kann, um Metadaten zu Ihren Parametern hinzuzufügen?
 
-Jetzt ist es an der Zeit, das mit FastAPI auszuprobieren. 🚀
+Jetzt ist es soweit, dies mit FastAPI zu verwenden. 🚀
 
 Wir hatten diese Typannotation:
 
@@ -83,7 +63,7 @@ q: Union[str, None] = None
 
 ////
 
-Wir wrappen das nun in `Annotated`, sodass daraus wird:
+Was wir tun werden, ist, dies mit `Annotated` zu wrappen, sodass es zu:
 
 //// tab | Python 3.10+
 
@@ -101,101 +81,75 @@ q: Annotated[Union[str, None]] = None
 
 ////
 
-Beide Versionen bedeuten dasselbe: `q` ist ein Parameter, der `str` oder `None` sein kann. Standardmäßig ist er `None`.
+Beide dieser Versionen bedeuten dasselbe: `q` ist ein Parameter, der ein `str` oder `None` sein kann, und standardmäßig ist er `None`.
 
-Wenden wir uns jetzt den spannenden Dingen zu. 🎉
+Jetzt springen wir zu den spannenden Dingen. 🎉
 
-## `Query` zu `Annotated` im `q`-Parameter hinzufügen
+## `Query` zu `Annotated` im `q`-Parameter hinzufügen { #add-query-to-annotated-in-the-q-parameter }
 
-Jetzt, da wir `Annotated` für unsere Metadaten deklariert haben, fügen Sie `Query` hinzu, und setzen Sie den Parameter `max_length` auf `50`:
+Da wir nun `Annotated` haben, in das wir mehr Informationen (in diesem Fall einige zusätzliche Validierungen) einfügen können, fügen Sie `Query` innerhalb von `Annotated` hinzu und setzen Sie den Parameter `max_length` auf `50`:
 
 {* ../../docs_src/query_params_str_validations/tutorial002_an_py310.py hl[9] *}
 
-Beachten Sie, dass der Defaultwert immer noch `None` ist, sodass der Parameter immer noch optional ist.
+Beachten Sie, dass der Defaultwert weiterhin `None` ist, so dass der Parameter weiterhin optional ist.
+
+Aber jetzt, mit `Query(max_length=50)` innerhalb von `Annotated`, sagen wir FastAPI, dass wir eine **zusätzliche Validierung** für diesen Wert wünschen, wir wollen, dass er maximal 50 Zeichen hat. 😎
+
+/// tip | Tipp
+
+Hier verwenden wir `Query()`, weil dies ein **Query-Parameter** ist. Später werden wir andere wie `Path()`, `Body()`, `Header()`, und `Cookie()` sehen, die auch dieselben Argumente wie `Query()` akzeptieren.
 
-Aber jetzt, mit `Query(max_length=50)` innerhalb von `Annotated`, sagen wir FastAPI, dass es diesen Wert aus den Query-Parametern extrahieren soll (das hätte es sowieso gemacht 🤷) und dass wir eine **zusätzliche Validierung** für diesen Wert haben wollen (darum machen wir das, um die zusätzliche Validierung zu bekommen). 😎
+///
 
 FastAPI wird nun:
 
-* Die Daten **validieren** und sicherstellen, dass sie nicht länger als 50 Zeichen sind
-* Dem Client einen **verständlichen Fehler** anzeigen, wenn die Daten ungültig sind
+* Die Daten **validieren**, um sicherzustellen, dass die Länge maximal 50 Zeichen beträgt
+* Einen **klaren Fehler** für den Client anzeigen, wenn die Daten ungültig sind
 * Den Parameter in der OpenAPI-Schema-*Pfadoperation* **dokumentieren** (sodass er in der **automatischen Dokumentation** angezeigt wird)
 
-## Alternativ (alt): `Query` als Defaultwert
+## Alternative (alt): `Query` als Defaultwert { #alternative-old-query-as-the-default-value }
 
-Frühere Versionen von FastAPI (vor <abbr title="vor 2023-03">0.95.0</abbr>) benötigten `Query` als Defaultwert des Parameters, statt es innerhalb von `Annotated` unterzubringen. Die Chance ist groß, dass Sie Quellcode sehen, der das immer noch so macht, darum erkläre ich es Ihnen.
+Frühere Versionen von FastAPI (vor <abbr title="vor 2023-03">0.95.0</abbr>) erforderten, dass Sie `Query` als den Defaultwert Ihres Parameters verwendeten, anstatt es innerhalb von `Annotated` zu platzieren. Es besteht eine hohe Wahrscheinlichkeit, dass Sie Code sehen, der es so verwendet, also werde ich es Ihnen erklären.
 
 /// tip | Tipp
 
-Verwenden Sie für neuen Code, und wann immer möglich, `Annotated`, wie oben erklärt. Es gibt mehrere Vorteile (unten erläutert) und keine Nachteile. 🍰
+Für neuen Code und wann immer es möglich ist, verwenden Sie `Annotated` wie oben erklärt. Es gibt mehrere Vorteile (unten erläutert) und keine Nachteile. 🍰
 
 ///
 
-So würden Sie `Query()` als Defaultwert Ihres Funktionsparameters verwenden, den Parameter `max_length` auf 50 gesetzt:
+So würden Sie `Query()` als den Defaultwert Ihres Funktionsparameters verwenden und den Parameter `max_length` auf 50 setzen:
 
 {* ../../docs_src/query_params_str_validations/tutorial002_py310.py hl[7] *}
 
-Da wir in diesem Fall (ohne die Verwendung von `Annotated`) den Parameter-Defaultwert `None` mit `Query()` ersetzen, müssen wir nun dessen Defaultwert mit dem Parameter `Query(default=None)` deklarieren. Das dient demselben Zweck, `None` als Defaultwert für den Funktionsparameter zu setzen (zumindest für FastAPI).
-
-Sprich:
-
-```Python
-q: Union[str, None] = Query(default=None)
-```
-
-... macht den Parameter optional, mit dem Defaultwert `None`, genauso wie:
-
-```Python
-q: Union[str, None] = None
-```
+Da wir in diesem Fall (ohne die Verwendung von `Annotated`) den Defaultwert `None` in der Funktion durch `Query()` ersetzen müssen, müssen wir nun den Defaultwert mit dem Parameter `Query(default=None)` setzen, er erfüllt den gleichen Zweck, diesen Defaultwert zu definieren (zumindest für FastAPI).
 
-Und in Python 3.10 und darüber macht:
+Also:
 
 ```Python
 q: str | None = Query(default=None)
 ```
 
-... den Parameter optional, mit dem Defaultwert `None`, genauso wie:
+... macht den Parameter optional mit einem Defaultwert von `None`, genauso wie:
 
 ```Python
 q: str | None = None
 ```
 
-Nur, dass die `Query`-Versionen den Parameter explizit als Query-Parameter deklarieren.
-
-/// info
+Aber die `Query`-Version deklariert ihn explizit als Query-Parameter.
 
-Bedenken Sie, dass:
+Dann können wir mehr Parameter an `Query` übergeben. In diesem Fall den `max_length`-Parameter, der auf Strings angewendet wird:
 
 ```Python
-= None
+q: str | None = Query(default=None, max_length=50)
 ```
 
-oder:
-
-```Python
-= Query(default=None)
-```
+Dies wird die Daten validieren, einen klaren Fehler anzeigen, wenn die Daten nicht gültig sind, und den Parameter in der OpenAPI-Schema-*Pfadoperation* dokumentieren.
 
-der wichtigste Teil ist, um einen Parameter optional zu machen, da dieses `None` der Defaultwert ist, und das ist es, was diesen Parameter **nicht erforderlich** macht.
+### `Query` als Defaultwert oder in `Annotated` { #query-as-the-default-value-or-in-annotated }
 
-Der Teil mit `Union[str, None]` erlaubt es Ihrem Editor, Sie besser zu unterstützen, aber er sagt FastAPI nicht, dass dieser Parameter optional ist.
-
-///
-
-Jetzt können wir `Query` weitere Parameter übergeben. Fangen wir mit dem `max_length` Parameter an, der auf Strings angewendet wird:
-
-```Python
-q: Union[str, None] = Query(default=None, max_length=50)
-```
+Beachten Sie, dass wenn Sie `Query` innerhalb von `Annotated` verwenden, Sie den `default`-Parameter für `Query` nicht verwenden dürfen.
 
-Das wird die Daten validieren, einen verständlichen Fehler ausgeben, wenn die Daten nicht gültig sind, und den Parameter in der OpenAPI-Schema-*Pfadoperation* dokumentieren.
-
-### `Query` als Defaultwert oder in `Annotated`
-
-Bedenken Sie, dass wenn Sie `Query` innerhalb von `Annotated` benutzen, Sie den `default`-Parameter für `Query` nicht verwenden dürfen.
-
-Setzen Sie stattdessen den Defaultwert des Funktionsparameters, sonst wäre es inkonsistent.
+Setzen Sie stattdessen den tatsächlichen Defaultwert des Funktionsparameters. Andernfalls wäre es inkonsistent.
 
 Zum Beispiel ist das nicht erlaubt:
 
@@ -203,7 +157,7 @@ Zum Beispiel ist das nicht erlaubt:
 q: Annotated[str, Query(default="rick")] = "morty"
 ```
 
-... denn es wird nicht klar, ob der Defaultwert `"rick"` oder `"morty"` sein soll.
+... denn es ist nicht klar, ob der Defaultwert `"rick"` oder `"morty"` sein soll.
 
 Sie würden also (bevorzugt) schreiben:
 
@@ -211,49 +165,49 @@ Sie würden also (bevorzugt) schreiben:
 q: Annotated[str, Query()] = "rick"
 ```
 
-In älterem Code werden Sie auch finden:
+... oder in älteren Codebasen finden Sie:
 
 ```Python
 q: str = Query(default="rick")
 ```
 
-### Vorzüge von `Annotated`
+### Vorzüge von `Annotated` { #advantages-of-annotated }
 
-**Es wird empfohlen, `Annotated` zu verwenden**, statt des Defaultwertes im Funktionsparameter, das ist aus mehreren Gründen **besser**: 🤓
+**Es wird empfohlen, `Annotated` zu verwenden**, anstelle des Defaultwertes in Funktionsparametern, es ist aus mehreren Gründen **besser**. 🤓
 
-Der **Default**wert des **Funktionsparameters** ist der **tatsächliche Default**wert, das spielt generell intuitiver mit Python zusammen. 😌
+Der **Default**wert des **Funktionsparameters** ist der **tatsächliche Default**wert, das ist in der Regel intuitiver mit Python. 😌
 
-Sie können die Funktion ohne FastAPI an **anderen Stellen aufrufen**, und es wird **wie erwartet funktionieren**. Wenn es einen **erforderlichen** Parameter gibt (ohne Defaultwert), und Sie führen die Funktion ohne den benötigten Parameter aus, dann wird Ihr **Editor** Sie das mit einem Fehler wissen lassen, und **Python** wird sich auch beschweren.
+Sie könnten **diese gleiche Funktion** in **anderen Stellen** ohne FastAPI **aufrufen**, und es würde **wie erwartet funktionieren**. Wenn es einen **erforderlichen** Parameter gibt (ohne Defaultwert), wird Ihr **Editor** Ihnen dies mit einem Fehler mitteilen, außerdem wird **Python** sich beschweren, wenn Sie es ausführen, ohne den erforderlichen Parameter zu übergeben.
 
-Wenn Sie aber nicht `Annotated` benutzen und stattdessen die **(alte) Variante mit einem Defaultwert**, dann müssen Sie, wenn Sie die Funktion ohne FastAPI an **anderen Stellen** aufrufen, sich daran **erinnern**, die Argumente der Funktion zu übergeben, damit es richtig funktioniert. Ansonsten erhalten Sie unerwartete Werte (z. B. `QueryInfo` oder etwas Ähnliches, statt `str`). Ihr Editor kann ihnen nicht helfen, und Python wird die Funktion ohne Beschwerden ausführen, es sei denn, die Operationen innerhalb lösen einen Fehler aus.
+Wenn Sie `Annotated` nicht verwenden und stattdessen die **(alte) Defaultwert-Stilform** verwenden, müssen Sie sich daran **erinnern**, die Argumente der Funktion zu übergeben, wenn Sie diese Funktion ohne FastAPI in **anderen Stellen** aufrufen. Ansonsten sind die Werte anders als erwartet (z. B. `QueryInfo` oder etwas Ähnliches statt `str`). Ihr Editor kann Ihnen nicht helfen, und Python wird die Funktion ohne Klagen ausführen und sich nur beschweren wenn die Operationen innerhalb auf einen Fehler stoßen.
 
-Da `Annotated` mehrere Metadaten haben kann, können Sie dieselbe Funktion auch mit anderen Tools verwenden, wie etwa <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">Typer</a>. 🚀
+Da `Annotated` mehr als eine Metadaten-Annotation haben kann, könnten Sie dieselbe Funktion sogar mit anderen Tools verwenden, wie z. B. <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">Typer</a>. 🚀
 
-## Mehr Validierungen hinzufügen
+## Mehr Validierungen hinzufügen { #add-more-validations }
 
-Sie können auch einen Parameter `min_length` hinzufügen:
+Sie können auch einen `min_length`-Parameter hinzufügen:
 
 {* ../../docs_src/query_params_str_validations/tutorial003_an_py310.py hl[10] *}
 
-## Reguläre Ausdrücke hinzufügen
+## Reguläre Ausdrücke hinzufügen { #add-regular-expressions }
 
-Sie können einen <abbr title="Ein regulärer Ausdruck, auch regex oder regexp genannt, ist eine Zeichensequenz, die ein Suchmuster für Strings definiert.">Regulären Ausdruck</abbr> `pattern` definieren, mit dem der Parameter übereinstimmen muss:
+Sie können einen <abbr title="Ein regulärer Ausdruck, regex oder regexp genannt, ist eine Sequenz von Zeichen, die ein Suchmuster für Zeichenfolgen definiert.">regulären Ausdruck</abbr> `pattern` definieren, mit dem der Parameter übereinstimmen muss:
 
 {* ../../docs_src/query_params_str_validations/tutorial004_an_py310.py hl[11] *}
 
-Dieses bestimmte reguläre Suchmuster prüft, ob der erhaltene Parameter-Wert:
+Dieses spezielle Suchmuster im regulären Ausdruck überprüft, dass der erhaltene Parameterwert:
 
-* `^`: mit den nachfolgenden Zeichen startet, keine Zeichen davor hat.
+* `^`: mit den nachfolgenden Zeichen beginnt, keine Zeichen davor hat.
 * `fixedquery`: den exakten Text `fixedquery` hat.
-* `$`: danach endet, keine weiteren Zeichen hat als `fixedquery`.
+* `$`: dort endet, keine weiteren Zeichen nach `fixedquery` hat.
 
-Wenn Sie sich verloren fühlen bei all diesen **„Regulärer Ausdruck“**-Konzepten, keine Sorge. Reguläre Ausdrücke sind für viele Menschen ein schwieriges Thema. Sie können auch ohne reguläre Ausdrücke eine ganze Menge machen.
+Wenn Sie sich mit all diesen **„regulärer Ausdruck“**-Ideen verloren fühlen, keine Sorge. Sie sind ein schwieriges Thema für viele Menschen. Sie können noch viele Dinge tun, ohne reguläre Ausdrücke direkt zu benötigen.
 
-Aber wenn Sie sie brauchen und sie lernen, wissen Sie, dass Sie sie bereits direkt in **FastAPI** verwenden können.
+Aber nun wissen Sie, dass Sie sie in **FastAPI** immer dann verwenden können, wenn Sie sie brauchen.
 
-### Pydantic v1 `regex` statt `pattern`
+### Pydantic v1 `regex` statt `pattern` { #pydantic-v1-regex-instead-of-pattern }
 
-Vor Pydantic Version 2 und vor FastAPI Version 0.100.0, war der Name des Parameters `regex` statt `pattern`, aber das ist jetzt <abbr title="deprecated – obsolet, veraltet: Es soll nicht mehr verwendet werden">deprecated</abbr>.
+Vor Pydantic Version 2 und FastAPI 0.100.0, hieß der Parameter `regex` statt `pattern`, aber das ist jetzt obsolet.
 
 Sie könnten immer noch Code sehen, der den alten Namen verwendet:
 
@@ -263,25 +217,25 @@ Sie könnten immer noch Code sehen, der den alten Namen verwendet:
 
 ////
 
-Beachten Sie aber, dass das deprecated ist, und zum neuen Namen `pattern` geändert werden sollte. 🤓
+Beachten Sie aber, dass das obsolet ist und auf den neuen Parameter `pattern` aktualisiert werden sollte. 🤓
 
-## Defaultwerte
+## Defaultwerte { #default-values }
 
-Sie können natürlich andere Defaultwerte als `None` verwenden.
+Natürlich können Sie Defaultwerte verwenden, die nicht `None` sind.
 
-Beispielsweise könnten Sie den `q` Query-Parameter so deklarieren, dass er eine `min_length` von `3` hat, und den Defaultwert `"fixedquery"`:
+Nehmen wir an, Sie möchten, dass der `q` Query-Parameter eine `min_length` von `3` hat und einen Defaultwert von `"fixedquery"`:
 
 {* ../../docs_src/query_params_str_validations/tutorial005_an_py39.py hl[9] *}
 
 /// note | Hinweis
 
-Ein Parameter ist optional (nicht erforderlich), wenn er irgendeinen Defaultwert, auch `None`, hat.
+Ein Defaultwert irgendeines Typs, einschließlich `None`, macht den Parameter optional (nicht erforderlich).
 
 ///
 
-## Erforderliche Parameter
+## Erforderliche Parameter { #required-parameters }
 
-Wenn wir keine Validierungen oder Metadaten haben, können wir den `q` Query-Parameter erforderlich machen, indem wir einfach keinen Defaultwert deklarieren, wie in:
+Wenn wir keine weiteren Validierungen oder Metadaten deklarieren müssen, können wir den `q` Query-Parameter erforderlich machen, indem wir einfach keinen Defaultwert deklarieren, wie:
 
 ```Python
 q: str
@@ -290,56 +244,32 @@ q: str
 statt:
 
 ```Python
-q: Union[str, None] = None
+q: str | None = None
 ```
 
-Aber jetzt deklarieren wir den Parameter mit `Query`, wie in:
-
-//// tab | Annotiert
+Aber jetzt deklarieren wir es mit `Query`, zum Beispiel so:
 
 ```Python
-q: Annotated[Union[str, None], Query(min_length=3)] = None
+q: Annotated[str | None, Query(min_length=3)] = None
 ```
 
-////
-
-//// tab | Nicht annotiert
-
-```Python
-q: Union[str, None] = Query(default=None, min_length=3)
-```
-
-////
-
-Wenn Sie einen Parameter erforderlich machen wollen, während Sie `Query` verwenden, deklarieren Sie ebenfalls einfach keinen Defaultwert:
+Wenn Sie einen Wert als erforderlich deklarieren müssen, während Sie `Query` verwenden, deklarieren Sie einfach keinen Defaultwert:
 
 {* ../../docs_src/query_params_str_validations/tutorial006_an_py39.py hl[9] *}
 
-### Erforderlich, kann `None` sein
+### Erforderlich, kann `None` sein { #required-can-be-none }
 
-Sie können deklarieren, dass ein Parameter `None` akzeptiert, aber dennoch erforderlich ist. Das zwingt Clients, den Wert zu senden, selbst wenn er `None` ist.
+Sie können deklarieren, dass ein Parameter `None` akzeptieren kann, aber trotzdem erforderlich ist. Dadurch müssten Clients den Wert senden, selbst wenn der Wert `None` ist.
 
-Um das zu machen, deklarieren Sie, dass `None` ein gültiger Typ ist, aber verwenden Sie dennoch `...` als Default:
+Um das zu tun, können Sie deklarieren, dass `None` ein gültiger Typ ist, einfach indem Sie keinen Defaultwert deklarieren:
 
 {* ../../docs_src/query_params_str_validations/tutorial006c_an_py310.py hl[9] *}
 
-/// tip | Tipp
-
-Pydantic, welches die gesamte Datenvalidierung und Serialisierung in FastAPI antreibt, hat ein spezielles Verhalten, wenn Sie `Optional` oder `Union[Something, None]` ohne Defaultwert verwenden, Sie können mehr darüber in der Pydantic-Dokumentation unter <a href="https://docs.pydantic.dev/2.3/usage/models/#required-fields" class="external-link" target="_blank">Required fields</a> erfahren.
+## Query-Parameter-Liste / Mehrere Werte { #query-parameter-list-multiple-values }
 
-///
-
-/// tip | Tipp
+Wenn Sie einen Query-Parameter explizit mit `Query` definieren, können Sie ihn auch so deklarieren, dass er eine Liste von Werten empfängt, oder anders gesagt, dass er mehrere Werte empfangen kann.
 
-Denken Sie daran, dass Sie in den meisten Fällen, wenn etwas erforderlich ist, einfach den Defaultwert weglassen können. Sie müssen also normalerweise `...` nicht verwenden.
-
-///
-
-## Query-Parameter-Liste / Mehrere Werte
-
-Wenn Sie einen Query-Parameter explizit mit `Query` auszeichnen, können Sie ihn auch eine Liste von Werten empfangen lassen, oder anders gesagt, mehrere Werte.
-
-Um zum Beispiel einen Query-Parameter `q` zu deklarieren, der mehrere Male in der URL vorkommen kann, schreiben Sie:
+Um zum Beispiel einen Query-Parameter `q` zu deklarieren, der mehrmals in der URL vorkommen kann, schreiben Sie:
 
 {* ../../docs_src/query_params_str_validations/tutorial011_an_py310.py hl[9] *}
 
@@ -349,9 +279,9 @@ Dann, mit einer URL wie:
 http://localhost:8000/items/?q=foo&q=bar
 ```
 
-bekommen Sie alle `q`-*Query-Parameter*-Werte (`foo` und `bar`) in einer Python-Liste – `list` – in ihrer *Pfadoperation-Funktion*, im Funktionsparameter `q`, überreicht.
+würden Sie die mehreren `q`-*Query-Parameter*-Werte (`foo` und `bar`) in einer Python-`list` in Ihrer *Pfadoperation-Funktion* im *Funktionsparameter* `q` erhalten.
 
-Die Response für diese URL wäre also:
+So wäre die <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> zu dieser URL:
 
 ```JSON
 {
@@ -364,27 +294,27 @@ Die Response für diese URL wäre also:
 
 /// tip | Tipp
 
-Um einen Query-Parameter vom Typ `list` zu deklarieren, wie im Beispiel oben, müssen Sie explizit `Query` verwenden, sonst würde der Parameter als Requestbody interpretiert werden.
+Um einen Query-Parameter mit einem Typ `list` zu deklarieren, wie im obigen Beispiel, müssen Sie explizit `Query` verwenden, da er andernfalls als <abbr title="Anfragekörper">Requestbody</abbr> interpretiert würde.
 
 ///
 
-Die interaktive API-Dokumentation wird entsprechend aktualisiert und erlaubt jetzt mehrere Werte.
+Die interaktive API-Dokumentation wird entsprechend aktualisiert, um mehrere Werte zu erlauben:
 
 <img src="/img/tutorial/query-params-str-validations/image02.png">
 
-### Query-Parameter-Liste / Mehrere Werte mit Defaults
+### Query-Parameter-Liste / Mehrere Werte mit Defaults { #query-parameter-list-multiple-values-with-defaults }
 
-Und Sie können auch eine Default-`list`e von Werten definieren, wenn keine übergeben werden:
+Sie können auch eine Default-`list` von Werten definieren, wenn keine bereitgestellt werden:
 
 {* ../../docs_src/query_params_str_validations/tutorial012_an_py39.py hl[9] *}
 
-Wenn Sie auf:
+Wenn Sie zu:
 
 ```
 http://localhost:8000/items/
 ```
 
-gehen, wird der Default für `q` verwendet: `["foo", "bar"]`, und als Response erhalten Sie:
+gehen, wird der Default für `q` sein: `["foo", "bar"]`, und Ihre Response wird sein:
 
 ```JSON
 {
@@ -395,9 +325,9 @@ gehen, wird der Default für `q` verwendet: `["foo", "bar"]`, und als Response e
 }
 ```
 
-#### `list` alleine verwenden
+#### Nur `list` verwenden { #using-just-list }
 
-Sie können auch `list` direkt verwenden, anstelle von `List[str]` (oder `list[str]` in Python 3.9+):
+Sie können auch `list` direkt verwenden, anstelle von `list[str]`:
 
 {* ../../docs_src/query_params_str_validations/tutorial013_an_py39.py hl[9] *}
 
@@ -405,35 +335,35 @@ Sie können auch `list` direkt verwenden, anstelle von `List[str]` (oder `list[s
 
 Beachten Sie, dass FastAPI in diesem Fall den Inhalt der Liste nicht überprüft.
 
-Zum Beispiel würde `List[int]` überprüfen (und dokumentieren) dass die Liste Ganzzahlen enthält. `list` alleine macht das nicht.
+Zum Beispiel würde `list[int]` überprüfen (und dokumentieren), dass der Inhalt der Liste Ganzzahlen sind. Aber `list` alleine würde das nicht.
 
 ///
 
-## Deklarieren von mehr Metadaten
+## Mehr Metadaten deklarieren { #declare-more-metadata }
 
-Sie können mehr Informationen zum Parameter hinzufügen.
+Sie können mehr Informationen über den Parameter hinzufügen.
 
-Diese Informationen werden zur generierten OpenAPI hinzugefügt, und von den Dokumentations-Oberflächen und von externen Tools verwendet.
+Diese Informationen werden in das generierte OpenAPI aufgenommen und von den Dokumentationsoberflächen und externen Tools verwendet.
 
 /// note | Hinweis
 
-Beachten Sie, dass verschiedene Tools OpenAPI möglicherweise unterschiedlich gut unterstützen.
+Beachten Sie, dass verschiedene Tools möglicherweise unterschiedliche Unterstützungslevels für OpenAPI haben.
 
-Einige könnten noch nicht alle zusätzlichen Informationen anzeigen, die Sie deklariert haben, obwohl in den meisten Fällen geplant ist, das fehlende Feature zu implementieren.
+Einige davon könnten noch nicht alle zusätzlichen Informationen anzuzeigen, die Sie erklärten, obwohl in den meisten Fällen die fehlende Funktionalität bereits in der Entwicklung geplant ist.
 
 ///
 
-Sie können einen Titel hinzufügen – `title`:
+Sie können einen `title` hinzufügen:
 
 {* ../../docs_src/query_params_str_validations/tutorial007_an_py310.py hl[10] *}
 
-Und eine Beschreibung – `description`:
+Und eine `description`:
 
 {* ../../docs_src/query_params_str_validations/tutorial008_an_py310.py hl[14] *}
 
-## Alias-Parameter
+## Alias-Parameter { #alias-parameters }
 
-Stellen Sie sich vor, der Parameter soll `item-query` sein.
+Stellen Sie sich vor, Sie möchten, dass der Parameter `item-query` ist.
 
 Wie in:
 
@@ -443,37 +373,99 @@ http://127.0.0.1:8000/items/?item-query=foobaritems
 
 Aber `item-query` ist kein gültiger Name für eine Variable in Python.
 
-Am ähnlichsten wäre `item_query`.
+Der am ähnlichsten wäre `item_query`.
 
-Aber Sie möchten dennoch exakt `item-query` verwenden.
+Aber Sie benötigen dennoch, dass er genau `item-query` ist ...
 
-Dann können Sie einen `alias` deklarieren, und dieser Alias wird verwendet, um den Parameter-Wert zu finden:
+Dann können Sie ein `alias` deklarieren, und dieser Alias wird verwendet, um den Parameterwert zu finden:
 
 {* ../../docs_src/query_params_str_validations/tutorial009_an_py310.py hl[9] *}
 
-## Parameter als deprecated ausweisen
+## Parameter als deprecatet ausweisen { #deprecating-parameters }
 
-Nehmen wir an, Sie mögen diesen Parameter nicht mehr.
+Nehmen wir an, Ihnen gefällt dieser Parameter nicht mehr.
 
-Sie müssen ihn eine Weile dort belassen, weil Clients ihn benutzen, aber Sie möchten, dass die Dokumentation klar anzeigt, dass er <abbr title="deprecated – obsolet, veraltet: Es soll nicht mehr verwendet werden">deprecated</abbr> ist.
+Sie müssen ihn eine Weile dort belassen, da es Clients gibt, die ihn verwenden, aber Sie möchten, dass die Dokumentation ihn klar als <abbr title="veraltet, obsolet: Es soll nicht mehr verwendet werden">deprecatet</abbr> anzeigt.
 
-In diesem Fall fügen Sie den Parameter `deprecated=True` zu `Query` hinzu.
+Dann übergeben Sie den Parameter `deprecated=True` an `Query`:
 
 {* ../../docs_src/query_params_str_validations/tutorial010_an_py310.py hl[19] *}
 
-Die Dokumentation wird das so anzeigen:
+Die Dokumentation wird es so anzeigen:
 
 <img src="/img/tutorial/query-params-str-validations/image01.png">
 
-## Parameter von OpenAPI ausschließen
+## Parameter von OpenAPI ausschließen { #exclude-parameters-from-openapi }
 
-Um einen Query-Parameter vom generierten OpenAPI-Schema auszuschließen (und daher von automatischen Dokumentations-Systemen), setzen Sie den Parameter `include_in_schema` in `Query` auf `False`.
+Um einen Query-Parameter aus dem generierten OpenAPI-Schema auszuschließen (und somit aus den automatischen Dokumentationssystemen), setzen Sie den Parameter `include_in_schema` von `Query` auf `False`:
 
 {* ../../docs_src/query_params_str_validations/tutorial014_an_py310.py hl[10] *}
 
-## Zusammenfassung
+## Benutzerdefinierte Validierung { #custom-validation }
+
+Es kann Fälle geben, in denen Sie eine **benutzerdefinierte Validierung** durchführen müssen, die nicht mit den oben gezeigten Parametern durchgeführt werden kann.
 
-Sie können zusätzliche Validierungen und Metadaten zu ihren Parametern hinzufügen.
+In diesen Fällen können Sie eine **benutzerdefinierte Validierungsfunktion** verwenden, die nach der normalen Validierung angewendet wird (z. B. nach der Validierung, dass der Wert ein `str` ist).
+
+Sie können dies mit <a href="https://docs.pydantic.dev/latest/concepts/validators/#field-after-validator" class="external-link" target="_blank">Pydantic's `AfterValidator`</a> innerhalb von `Annotated` erreichen.
+
+/// tip | Tipp
+
+Pydantic unterstützt auch <a href="https://docs.pydantic.dev/latest/concepts/validators/#field-before-validator" class="external-link" target="_blank">`BeforeValidator`</a> und andere. 🤓
+
+///
+
+Zum Beispiel überprüft dieser benutzerdefinierte Validator, ob die Artikel-ID mit `isbn-` für eine <abbr title="ISBN bedeutet Internationale Standardbuchnummer">ISBN</abbr>-Buchnummer oder mit `imdb-` für eine <abbr title="IMDB (Internet Movie Database) ist eine Website mit Informationen über Filme">IMDB</abbr>-Film-URL-ID beginnt:
+
+{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py hl[5,16:19,24] *}
+
+/// info | Info
+
+Dies ist verfügbar seit Pydantic Version 2 oder höher. 😎
+
+///
+
+/// tip | Tipp
+
+Wenn Sie irgendeine Art von Validierung durchführen müssen, die eine Kommunikation mit einer **externen Komponente** erfordert, wie z. B. einer Datenbank oder einer anderen API, sollten Sie stattdessen **FastAPI-Abhängigkeiten** verwenden. Sie werden diese später kennenlernen.
+
+Diese benutzerdefinierten Validatoren sind für Dinge gedacht, die einfach mit denselben **Daten** überprüft werden können, die im Request bereitgestellt werden.
+
+///
+
+### Dieses Codebeispiel verstehen { #understand-that-code }
+
+Der wichtige Punkt ist einfach die Verwendung von **`AfterValidator` mit einer Funktion innerhalb von `Annotated`**. Fühlen Sie sich frei, diesen Teil zu überspringen. 🤸
+
+---
+
+Aber wenn Sie neugierig auf dieses spezielle Codebeispiel sind und immer noch Spaß haben, hier sind einige zusätzliche Details.
+
+#### Zeichenkette mit `value.startswith()` { #string-with-value-startswith }
+
+Haben Sie bemerkt? Eine Zeichenkette mit `value.startswith()` kann ein Tuple übernehmen, und es wird jeden Wert im Tuple überprüfen:
+
+{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[16:19] hl[17] *}
+
+#### Ein zufälliges Item { #a-random-item }
+
+Mit `data.items()` erhalten wir ein <abbr title="Etwas, das man mit einer for-Schleife durchlaufen kann, wie eine Liste, Set, usw.">iterierbares Objekt</abbr> mit Tupeln, die Schlüssel und Wert für jedes <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">Dictionary</abbr>-Element enthalten.
+
+Wir konvertieren dieses iterierbare Objekt mit `list(data.items())` in eine richtige `list`.
+
+Dann können wir mit `random.choice()` einen **zufälligen Wert** aus der Liste erhalten, also bekommen wir ein Tuple mit `(id, name)`. Es wird etwas wie `("imdb-tt0371724", "The Hitchhiker's Guide to the Galaxy")` sein.
+
+Dann **weisen wir diese beiden Werte** des Tupels den Variablen `id` und `name` zu.
+
+Wenn der Benutzer also keine Artikel-ID bereitgestellt hat, erhält er trotzdem einen zufälligen Vorschlag.
+
+... wir tun all dies in einer **einzelnen einfachen Zeile**. 🤯 Lieben Sie nicht auch Python? 🐍
+
+{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[22:30] hl[29] *}
+
+## Zusammenfassung { #recap }
+
+Sie können zusätzliche Validierungen und Metadaten für Ihre Parameter deklarieren.
 
 Allgemeine Validierungen und Metadaten:
 
@@ -482,12 +474,14 @@ Allgemeine Validierungen und Metadaten:
 * `description`
 * `deprecated`
 
-Validierungen spezifisch für Strings:
+Validierungen, die spezifisch für Strings sind:
 
 * `min_length`
 * `max_length`
 * `pattern`
 
-In diesen Beispielen haben Sie gesehen, wie Sie Validierungen für Strings hinzufügen.
+Benutzerdefinierte Validierungen mit `AfterValidator`.
+
+In diesen Beispielen haben Sie gesehen, wie Sie Validierungen für `str`-Werte deklarieren.
 
-In den nächsten Kapiteln sehen wir, wie man Validierungen für andere Typen hinzufügt, etwa für Zahlen.
+Sehen Sie sich die nächsten Kapitel an, um zu erfahren, wie Sie Validierungen für andere Typen, wie z. B. Zahlen, deklarieren.

docs/de/docs/tutorial/query-params.md

@@ -1,10 +1,10 @@
-# Query-Parameter
+# Query-Parameter { #query-parameters }
 
-Wenn Sie in ihrer Funktion Parameter deklarieren, die nicht Teil der Pfad-Parameter sind, dann werden diese automatisch als „Query“-Parameter interpretiert.
+Wenn Sie in Ihrer Funktion andere Parameter deklarieren, die nicht Teil der Pfad-Parameter sind, dann werden diese automatisch als „Query“-Parameter interpretiert.
 
 {* ../../docs_src/query_params/tutorial001.py hl[9] *}
 
-Query-Parameter (Deutsch: Abfrage-Parameter) sind die Schlüssel-Wert-Paare, die nach dem `?` in einer URL aufgelistet sind, getrennt durch `&`-Zeichen.
+Die <abbr title="Abfrage">Query</abbr> ist die Menge von Schlüssel-Wert-Paaren, die nach dem `?` in einer URL folgen und durch `&`-Zeichen getrennt sind.
 
 Zum Beispiel sind in der URL:
 
@@ -19,18 +19,18 @@ http://127.0.0.1:8000/items/?skip=0&limit=10
 
 Da sie Teil der URL sind, sind sie „naturgemäß“ Strings.
 
-Aber wenn Sie sie mit Python-Typen deklarieren (im obigen Beispiel als `int`), werden sie zu diesem Typ konvertiert, und gegen diesen validiert.
+Aber wenn Sie sie mit Python-Typen deklarieren (im obigen Beispiel als `int`), werden sie zu diesem Typ konvertiert und gegen diesen validiert.
 
-Die gleichen Prozesse, die für Pfad-Parameter stattfinden, werden auch auf Query-Parameter angewendet:
+Die gleichen Prozesse, die für Pfad-Parameter gelten, werden auch auf Query-Parameter angewendet:
 
 * Editor Unterstützung (natürlich)
-* <abbr title="Konvertieren des Strings, der von einer HTTP-Anfrage kommt, in Python-Daten">„Parsen“</abbr> der Daten
+* Daten-<abbr title="Konvertieren des Strings, der von einem HTTP-Request kommt, in Python-Daten">„Parsen“</abbr>
 * Datenvalidierung
 * Automatische Dokumentation
 
-## Defaultwerte
+## Defaultwerte { #defaults }
 
-Da Query-Parameter nicht ein festgelegter Teil des Pfades sind, können sie optional sein und Defaultwerte haben.
+Da Query-Parameter kein fester Teil eines Pfades sind, können sie optional sein und Defaultwerte haben.
 
 Im obigen Beispiel haben sie die Defaultwerte `skip=0` und `limit=10`.
 
@@ -52,28 +52,28 @@ Aber wenn Sie zum Beispiel zu:
 http://127.0.0.1:8000/items/?skip=20
 ```
 
-gehen, werden die Parameter-Werte Ihrer Funktion sein:
+gehen, werden die Parameterwerte Ihrer Funktion sein:
 
 * `skip=20`: da Sie das in der URL gesetzt haben
 * `limit=10`: weil das der Defaultwert ist
 
-## Optionale Parameter
+## Optionale Parameter { #optional-parameters }
 
 Auf die gleiche Weise können Sie optionale Query-Parameter deklarieren, indem Sie deren Defaultwert auf `None` setzen:
 
 {* ../../docs_src/query_params/tutorial002_py310.py hl[7] *}
 
-In diesem Fall wird der Funktionsparameter `q` optional, und standardmäßig `None` sein.
+In diesem Fall wird der Funktionsparameter `q` optional und standardmäßig `None` sein.
 
-/// check
+/// check | Testen
 
 Beachten Sie auch, dass **FastAPI** intelligent genug ist, um zu erkennen, dass `item_id` ein Pfad-Parameter ist und `q` keiner, daher muss letzteres ein Query-Parameter sein.
 
 ///
 
-## Query-Parameter Typkonvertierung
+## Query-Parameter Typkonvertierung { #query-parameter-type-conversion }
 
-Sie können auch `bool`-Typen deklarieren und sie werden konvertiert:
+Sie können auch `bool`-Typen deklarieren, und sie werden konvertiert:
 
 {* ../../docs_src/query_params/tutorial003_py310.py hl[7] *}
 
@@ -109,9 +109,9 @@ http://127.0.0.1:8000/items/foo?short=yes
 
 gehen, oder zu irgendeiner anderen Variante der Groß-/Kleinschreibung (Alles groß, Anfangsbuchstabe groß, usw.), dann wird Ihre Funktion den Parameter `short` mit dem `bool`-Wert `True` sehen, ansonsten mit dem Wert `False`.
 
-## Mehrere Pfad- und Query-Parameter
+## Mehrere Pfad- und Query-Parameter { #multiple-path-and-query-parameters }
 
-Sie können mehrere Pfad-Parameter und Query-Parameter gleichzeitig deklarieren, **FastAPI** weiß, was welches ist.
+Sie können mehrere Pfad-Parameter und Query-Parameter gleichzeitig deklarieren, **FastAPI** weiß, welches welcher ist.
 
 Und Sie müssen sie auch nicht in einer spezifischen Reihenfolge deklarieren.
 
@@ -119,7 +119,7 @@ Parameter werden anhand ihres Namens erkannt:
 
 {* ../../docs_src/query_params/tutorial004_py310.py hl[6,8] *}
 
-## Erforderliche Query-Parameter
+## Erforderliche Query-Parameter { #required-query-parameters }
 
 Wenn Sie einen Defaultwert für Nicht-Pfad-Parameter deklarieren (Bis jetzt haben wir nur Query-Parameter gesehen), dann ist der Parameter nicht erforderlich.
 
@@ -183,6 +183,6 @@ In diesem Fall gibt es drei Query-Parameter:
 
 /// tip | Tipp
 
-Sie können auch `Enum`s verwenden, auf die gleiche Weise wie mit [Pfad-Parametern](path-params.md#vordefinierte-parameterwerte){.internal-link target=_blank}.
+Sie können auch `Enum`s verwenden, auf die gleiche Weise wie mit [Pfad-Parametern](path-params.md#predefined-values){.internal-link target=_blank}.
 
 ///

docs/de/docs/tutorial/request-files.md

@@ -1,40 +1,44 @@
-# Dateien im Request
+# Dateien im Request { #request-files }
 
-Mit `File` können sie vom Client hochzuladende Dateien definieren.
+Sie können Dateien, die vom Client hochgeladen werden, mithilfe von `File` definieren.
 
-/// info
+/// info | Info
 
-Um hochgeladene Dateien zu empfangen, installieren Sie zuerst <a href="https://andrew-d.github.io/python-multipart/" class="external-link" target="_blank">`python-multipart`</a>.
+Um hochgeladene Dateien zu empfangen, installieren Sie zuerst <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">`python-multipart`</a>.
 
-Z. B. `pip install python-multipart`.
+Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellen, sie aktivieren und dann das Paket installieren, zum Beispiel:
 
-Das, weil hochgeladene Dateien als „Formulardaten“ gesendet werden.
+```console
+$ pip install python-multipart
+```
+
+Das liegt daran, dass hochgeladene Dateien als „Formulardaten“ gesendet werden.
 
 ///
 
-## `File` importieren
+## `File` importieren { #import-file }
 
 Importieren Sie `File` und `UploadFile` von `fastapi`:
 
 {* ../../docs_src/request_files/tutorial001_an_py39.py hl[3] *}
 
-## `File`-Parameter definieren
+## `File`-Parameter definieren { #define-file-parameters }
 
 Erstellen Sie Datei-Parameter, so wie Sie es auch mit `Body` und `Form` machen würden:
 
 {* ../../docs_src/request_files/tutorial001_an_py39.py hl[9] *}
 
-/// info
+/// info | Info
 
 `File` ist eine Klasse, die direkt von `Form` erbt.
 
-Aber erinnern Sie sich, dass, wenn Sie `Query`, `Path`,  `File` und andere von `fastapi` importieren, diese tatsächlich Funktionen sind, welche spezielle Klassen zurückgeben
+Aber erinnern Sie sich, dass, wenn Sie `Query`, `Path`, `File` und andere von `fastapi` importieren, diese tatsächlich Funktionen sind, welche spezielle Klassen zurückgeben.
 
 ///
 
 /// tip | Tipp
 
-Um Dateibodys zu deklarieren, müssen Sie `File` verwenden, da diese Parameter sonst als Query-Parameter oder Body(-JSON)-Parameter interpretiert werden würden.
+Um Dateibodys zu deklarieren, müssen Sie `File` verwenden, da diese Parameter sonst als Query-Parameter oder Body (JSON)-Parameter interpretiert werden würden.
 
 ///
 
@@ -46,7 +50,7 @@ Bedenken Sie, dass das bedeutet, dass sich der gesamte Inhalt der Datei im Arbei
 
 Aber es gibt viele Fälle, in denen Sie davon profitieren, `UploadFile` zu verwenden.
 
-## Datei-Parameter mit `UploadFile`
+## Datei-Parameter mit `UploadFile` { #file-parameters-with-uploadfile }
 
 Definieren Sie einen Datei-Parameter mit dem Typ `UploadFile`:
 
@@ -55,20 +59,20 @@ Definieren Sie einen Datei-Parameter mit dem Typ `UploadFile`:
 `UploadFile` zu verwenden, hat mehrere Vorzüge gegenüber `bytes`:
 
 * Sie müssen `File()` nicht als Parameter-Defaultwert verwenden.
-* Es wird eine <abbr title='Aufgespult, Warteschlangenartig'>„Spool“</abbr>-Datei verwendet:
+* Es wird eine „<abbr title="warteschlangenartig">gespoolte</abbr>“ Datei verwendet:
     * Eine Datei, die bis zu einem bestimmten Größen-Limit im Arbeitsspeicher behalten wird, und wenn das Limit überschritten wird, auf der Festplatte gespeichert wird.
 * Das bedeutet, es wird für große Dateien wie Bilder, Videos, große Binärdateien, usw. gut funktionieren, ohne den ganzen Arbeitsspeicher aufzubrauchen.
 * Sie können Metadaten aus der hochgeladenen Datei auslesen.
-* Es hat eine <abbr title="dateiartig"><a href="https://docs.python.org/3/glossary.html#term-file-like-object" class="external-link" target="_blank">file-like</a></abbr> `async`hrone Schnittstelle.
-* Es stellt ein tatsächliches Python-<abbr title="Warteschlangenartige, temporäre Datei"><a href="https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile" class="external-link" target="_blank">`SpooledTemporaryFile`</a></abbr>-Objekt bereit, welches Sie direkt anderen Bibliotheken übergeben können, die ein dateiartiges Objekt erwarten.
+* Es hat eine <a href="https://docs.python.org/3/glossary.html#term-file-like-object" class="external-link" target="_blank">dateiartige</a> `async`hrone Schnittstelle.
+* Es stellt ein tatsächliches Python-<a href="https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile" class="external-link" target="_blank">`SpooledTemporaryFile`</a>-Objekt bereit, welches Sie direkt anderen Bibliotheken übergeben können, die ein dateiartiges Objekt erwarten.
 
-### `UploadFile`
+### `UploadFile` { #uploadfile }
 
 `UploadFile` hat die folgenden Attribute:
 
 * `filename`: Ein `str` mit dem ursprünglichen Namen der hochgeladenen Datei (z. B. `meinbild.jpg`).
 * `content_type`: Ein `str` mit dem Inhaltstyp (MIME-Typ / Medientyp) (z. B. `image/jpeg`).
-* `file`: Ein <a href="https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile" class="external-link" target="_blank">`SpooledTemporaryFile`</a> (ein <a href="https://docs.python.org/3/glossary.html#term-file-like-object" class="external-link" target="_blank">file-like</a> Objekt). Das ist das tatsächliche Python-Objekt, das Sie direkt anderen Funktionen oder Bibliotheken übergeben können, welche ein „file-like“-Objekt erwarten.
+* `file`: Ein <a href="https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile" class="external-link" target="_blank">`SpooledTemporaryFile`</a> (ein <a href="https://docs.python.org/3/glossary.html#term-file-like-object" class="external-link" target="_blank">dateiartiges</a> Objekt). Das ist das tatsächliche Python-Objekt, das Sie direkt anderen Funktionen oder Bibliotheken übergeben können, welche ein „file-like“-Objekt erwarten.
 
 `UploadFile` hat die folgenden `async`hronen Methoden. Sie alle rufen die entsprechenden Methoden des darunterliegenden Datei-Objekts auf (wobei intern `SpooledTemporaryFile` verwendet wird).
 
@@ -79,7 +83,7 @@ Definieren Sie einen Datei-Parameter mit dem Typ `UploadFile`:
     * Das ist besonders dann nützlich, wenn Sie `await myfile.read()` einmal ausführen und dann diese Inhalte erneut auslesen müssen.
 * `close()`: Schließt die Datei.
 
-Da alle diese Methoden `async`hron sind, müssen Sie sie `await`en („erwarten“).
+Da alle diese Methoden `async`hron sind, müssen Sie sie „await“en („erwarten“).
 
 Zum Beispiel können Sie innerhalb einer `async` *Pfadoperation-Funktion* den Inhalt wie folgt auslesen:
 
@@ -105,9 +109,9 @@ Wenn Sie die `async`-Methoden verwenden, führt **FastAPI** die Datei-Methoden i
 
 ///
 
-## Was sind „Formulardaten“
+## Was sind „Formulardaten“ { #what-is-form-data }
 
-HTML-Formulare (`<form></form>`) senden die Daten in einer „speziellen“ Kodierung zum Server, welche sich von JSON unterscheidet.
+Der Weg, wie HTML-Formulare (`<form></form>`) die Daten zum Server senden, verwendet normalerweise eine „spezielle“ Kodierung für diese Daten. Diese unterscheidet sich von JSON.
 
 **FastAPI** stellt sicher, dass diese Daten korrekt ausgelesen werden, statt JSON zu erwarten.
 
@@ -117,31 +121,31 @@ Daten aus Formularen werden, wenn es keine Dateien sind, normalerweise mit dem <
 
 Sollte das Formular aber Dateien enthalten, dann werden diese mit `multipart/form-data` kodiert. Wenn Sie `File` verwenden, wird **FastAPI** wissen, dass es die Dateien vom korrekten Teil des Bodys holen muss.
 
-Wenn Sie mehr über Formularfelder und ihre Kodierungen lesen möchten, besuchen Sie die <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST" class="external-link" target="_blank"><abbr title="Mozilla Developer Network – Mozilla-Entwickler-Netzwerk">MDN</abbr>-Webdokumentation für <code>POST</code></a>.
+Wenn Sie mehr über diese Kodierungen und Formularfelder lesen möchten, besuchen Sie die <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST" class="external-link" target="_blank"><abbr title="Mozilla Developer Network">MDN</abbr>-Webdokumentation für <code>POST</code></a>.
 
 ///
 
 /// warning | Achtung
 
-Sie können mehrere `File`- und `Form`-Parameter in einer *Pfadoperation* deklarieren, aber Sie können nicht gleichzeitig auch `Body`-Felder deklarieren, welche Sie als JSON erwarten, da der Request den Body mittels `multipart/form-data` statt `application/json` kodiert.
+Sie können mehrere `File`- und `Form`-Parameter in einer *Pfadoperation* deklarieren, aber Sie können nicht gleichzeitig auch `Body`-Felder deklarieren, welche Sie als JSON erwarten, da der <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> den Body mittels `multipart/form-data` statt `application/json` kodiert.
 
 Das ist keine Limitation von **FastAPI**, sondern Teil des HTTP-Protokolls.
 
 ///
 
-## Optionaler Datei-Upload
+## Optionaler Datei-Upload { #optional-file-upload }
 
 Sie können eine Datei optional machen, indem Sie Standard-Typannotationen verwenden und den Defaultwert auf `None` setzen:
 
 {* ../../docs_src/request_files/tutorial001_02_an_py310.py hl[9,17] *}
 
-## `UploadFile` mit zusätzlichen Metadaten
+## `UploadFile` mit zusätzlichen Metadaten { #uploadfile-with-additional-metadata }
 
-Sie können auch `File()` zusammen mit `UploadFile` verwenden, um zum Beispiel zusätzliche Metadaten zu setzen:
+Sie können auch `File()` mit `UploadFile` verwenden, um zum Beispiel zusätzliche Metadaten zu setzen:
 
 {* ../../docs_src/request_files/tutorial001_03_an_py39.py hl[9,15] *}
 
-## Mehrere Datei-Uploads
+## Mehrere Datei-Uploads { #multiple-file-uploads }
 
 Es ist auch möglich, mehrere Dateien gleichzeitig hochzuladen.
 
@@ -151,22 +155,22 @@ Um das zu machen, deklarieren Sie eine Liste von `bytes` oder `UploadFile`s:
 
 {* ../../docs_src/request_files/tutorial002_an_py39.py hl[10,15] *}
 
-Sie erhalten, wie deklariert, eine `list`e von `bytes` oder `UploadFile`s.
+Sie erhalten, wie deklariert, eine `list` von `bytes` oder `UploadFile`s.
 
 /// note | Technische Details
 
 Sie können auch `from starlette.responses import HTMLResponse` verwenden.
 
-**FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, als Annehmlichkeit für Sie, den Entwickler. Die meisten verfügbaren Responses kommen aber direkt von Starlette.
+**FastAPI** bietet dieselben `starlette.responses` auch via `fastapi.responses` an, als Annehmlichkeit für Sie, den Entwickler. Die meisten verfügbaren <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Responses</abbr> kommen aber direkt von Starlette.
 
 ///
 
-### Mehrere Datei-Uploads mit zusätzlichen Metadaten
+### Mehrere Datei-Uploads mit zusätzlichen Metadaten { #multiple-file-uploads-with-additional-metadata }
 
 Und so wie zuvor können Sie `File()` verwenden, um zusätzliche Parameter zu setzen, sogar für `UploadFile`:
 
 {* ../../docs_src/request_files/tutorial003_an_py39.py hl[11,18:20] *}
 
-## Zusammenfassung
+## Zusammenfassung { #recap }
 
 Verwenden Sie `File`, `bytes` und `UploadFile`, um hochladbare Dateien im Request zu deklarieren, die als Formulardaten gesendet werden.

docs/de/docs/tutorial/request-form-models.md

@@ -0,0 +1,78 @@
+# Formularmodelle { #form-models }
+
+Sie können **Pydantic-Modelle** verwenden, um **Formularfelder** in FastAPI zu deklarieren.
+
+/// info | Info
+
+Um Formulare zu verwenden, installieren Sie zuerst <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">`python-multipart`</a>.
+
+Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellen, sie aktivieren und es dann installieren, zum Beispiel:
+
+```console
+$ pip install python-multipart
+```
+
+///
+
+/// note | Hinweis
+
+Dies wird seit FastAPI Version `0.113.0` unterstützt. 🤓
+
+///
+
+## Pydantic-Modelle für Formulare { #pydantic-models-for-forms }
+
+Sie müssen nur ein **Pydantic-Modell** mit den Feldern deklarieren, die Sie als **Formularfelder** erhalten möchten, und dann den Parameter als `Form` deklarieren:
+
+{* ../../docs_src/request_form_models/tutorial001_an_py39.py hl[9:11,15] *}
+
+**FastAPI** wird die Daten für **jedes Feld** aus den **Formulardaten** im <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> **extrahieren** und Ihnen das von Ihnen definierte Pydantic-Modell übergeben.
+
+## Die Dokumentation testen { #check-the-docs }
+
+Sie können dies in der Dokumentations-UI unter `/docs` testen:
+
+<div class="screenshot">
+<img src="/img/tutorial/request-form-models/image01.png">
+</div>
+
+## Zusätzliche Formularfelder verbieten { #forbid-extra-form-fields }
+
+In einigen speziellen Anwendungsfällen (wahrscheinlich nicht sehr häufig) möchten Sie möglicherweise die Formularfelder auf nur diejenigen beschränken, die im Pydantic-Modell deklariert sind, und jegliche **zusätzlichen** Felder **verbieten**.
+
+/// note | Hinweis
+
+Dies wird seit FastAPI Version `0.114.0` unterstützt. 🤓
+
+///
+
+Sie können die Modellkonfiguration von Pydantic verwenden, um jegliche `extra` Felder zu `verbieten`:
+
+{* ../../docs_src/request_form_models/tutorial002_an_py39.py hl[12] *}
+
+Wenn ein Client versucht, einige zusätzliche Daten zu senden, erhält er eine **Error-<abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr>**.
+
+Zum Beispiel, wenn der Client versucht, folgende Formularfelder zu senden:
+
+* `username`: `Rick`
+* `password`: `Portal Gun`
+* `extra`: `Mr. Poopybutthole`
+
+erhält er eine Error-Response, die ihm mitteilt, dass das Feld `extra` nicht erlaubt ist:
+
+```json
+{
+    "detail": [
+        {
+            "type": "extra_forbidden",
+            "loc": ["body", "extra"],
+            "msg": "Extra inputs are not permitted",
+            "input": "Mr. Poopybutthole"
+        }
+    ]
+}
+```
+
+## Zusammenfassung { #summary }
+
+Sie können Pydantic-Modelle verwenden, um Formularfelder in FastAPI zu deklarieren. 😎

docs/de/docs/tutorial/request-forms-and-files.md

@@ -1,22 +1,26 @@
-# Formulardaten und Dateien im Request
+# Formulardaten und Dateien im Request { #request-forms-and-files }
 
 Sie können gleichzeitig Dateien und Formulardaten mit `File` und `Form` definieren.
 
-/// info
+/// info | Info
 
-Um hochgeladene Dateien und/oder Formulardaten zu empfangen, installieren Sie zuerst <a href="https://andrew-d.github.io/python-multipart/" class="external-link" target="_blank">`python-multipart`</a>.
+Um hochgeladene Dateien und/oder Formulardaten zu empfangen, installieren Sie zuerst <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">`python-multipart`</a>.
 
-Z. B. `pip install python-multipart`.
+Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md){.internal-link target=_blank} erstellen, diese aktivieren und es dann installieren, z. B.:
+
+```console
+$ pip install python-multipart
+```
 
 ///
 
-## `File` und `Form` importieren
+## `File` und `Form` importieren { #import-file-and-form }
 
 {* ../../docs_src/request_forms_and_files/tutorial001_an_py39.py hl[3] *}
 
-## `File` und `Form`-Parameter definieren
+## `File` und `Form`-Parameter definieren { #define-file-and-form-parameters }
 
-Erstellen Sie Datei- und Formularparameter, so wie Sie es auch mit `Body` und `Query` machen würden:
+Erstellen Sie Datei- und Formularparameter, so wie Sie es auch mit `Body` oder `Query` machen würden:
 
 {* ../../docs_src/request_forms_and_files/tutorial001_an_py39.py hl[10:12] *}
 
@@ -26,12 +30,12 @@ Und Sie können einige der Dateien als `bytes` und einige als `UploadFile` dekla
 
 /// warning | Achtung
 
-Sie können mehrere `File`- und `Form`-Parameter in einer *Pfadoperation* deklarieren, aber Sie können nicht gleichzeitig auch `Body`-Felder deklarieren, welche Sie als JSON erwarten, da der Request den Body mittels `multipart/form-data` statt `application/json` kodiert.
+Sie können mehrere `File`- und `Form`-Parameter in einer *Pfadoperation* deklarieren, aber Sie können nicht auch `Body`-Felder deklarieren, die Sie als JSON erwarten, da der Body des <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> mittels `multipart/form-data` statt `application/json` kodiert sein wird.
 
 Das ist keine Limitation von **FastAPI**, sondern Teil des HTTP-Protokolls.
 
 ///
 
-## Zusammenfassung
+## Zusammenfassung { #recap }
 
 Verwenden Sie `File` und `Form` zusammen, wenn Sie Daten und Dateien zusammen im selben Request empfangen müssen.