Il a une opération `GET` qui pourrait renvoyer une erreur.

Il a une opération `POST` qui pourrait renvoyer plusieurs erreurs.

Les deux chemins d’accès requièrent un en-tête `X-Token`.

{* ../../docs_src/app_testing/app_b_an_py310/main.py *}

### Fichier de test étendu { #extended-testing-file }

{* ../../docs_src/body_multiple_params/tutorial002_py310.py hl[20] *}

Dans ce cas, **FastAPI** détectera qu'il y a plus d'un paramètre du corps de la requête dans la fonction (il y a deux paramètres qui sont des modèles Pydantic).

Il utilisera alors les noms des paramètres comme clés (noms de champs) dans le corps de la requête, et s'attendra à recevoir un corps de la requête semblable à :

```JSON
{

Aimez-vous **FastAPI** ?

Souhaitez-vous aider FastAPI, les autres utilisateurs et l'auteur ?

Ou souhaitez-vous obtenir de l'aide avec **FastAPI** ?

Il existe des moyens très simples d'aider (plusieurs ne nécessitent qu'un ou deux clics).

Et il existe aussi plusieurs façons d'obtenir de l'aide.

## S'abonner à la newsletter { #subscribe-to-the-newsletter }

{* ../../docs_src/extra_models/tutorial002_py310.py hl[7,13:14,17:18,21:22] *}

## `Union` ou `anyOf` { #union-or-anyof }

Vous pouvez déclarer qu'une réponse est l'`Union` de deux types ou plus, ce qui signifie que la réponse peut être n'importe lequel d'entre eux.

Cela sera défini dans OpenAPI avec `anyOf`.

## URL des documents { #docs-urls }

Vous pouvez configurer les deux interfaces utilisateur de documentation incluses :

* **Swagger UI** : servie à `/docs`.
    * Vous pouvez définir son URL avec le paramètre `docs_url`.
    * Vous pouvez la désactiver en définissant `docs_url=None`.

```Python
q: str | None = None
```

Ce que nous allons faire, c’est l’englober avec `Annotated`, de sorte que cela devienne :

```Python
q: Annotated[str | None] = None
```

Les deux versions signifient la même chose, `q` est un paramètre qui peut être une `str` ou `None`, et par défaut, c’est `None`.

Passons maintenant aux choses amusantes. 🎉

Gardez cela à l'esprit lorsque vous lisez « serveur » en général, cela pourrait faire référence à l'une de ces deux choses.

///

#### Utiliser `CMD` - Forme Exec { #use-cmd-exec-form }

L'instruction Docker [`CMD`](https://docs.docker.com/reference/dockerfile/#cmd) peut être écrite sous deux formes :

✅ Forme **Exec** :

```Dockerfile
# ✅ À faire
CMD ["fastapi", "run", "app/main.py", "--port", "80"]
```

⛔️ Forme **Shell** :

```Dockerfile
# ⛔️ À ne pas faire

Le code réel du callback dépendra fortement de votre application API.

Et il variera probablement beaucoup d’une application à l’autre.

Cela pourrait être seulement une ou deux lignes de code, comme :

```Python
callback_url = "https://example.com/api/v1/invoices/events/"
httpx.post(callback_url, json={"description": "Invoice paid", "paid": True})
```

Intégrer des outils d'interface utilisateur basés sur des normes :

* [Swagger UI](https://github.com/swagger-api/swagger-ui)
* [ReDoc](https://github.com/Rebilly/ReDoc)

Ces deux-là ont été choisis parce qu'ils sont populaires et stables, mais en faisant une recherche rapide, vous pourriez trouver des dizaines d'alternatives supplémentaires pour OpenAPI (que vous pouvez utiliser avec **FastAPI**).

///