```console
$ fastapi dev main.py
```

Mais vous devrez vous souvenir de passer le chemin correct à chaque exécution de la commande `fastapi`.

* [`python-multipart`](https://github.com/Kludex/python-multipart) - Obligatoire si vous souhaitez prendre en charge l’<dfn title="convertir la chaîne issue d'une requête HTTP en données Python">« parsing »</dfn> de formulaires avec `request.form()`.

Utilisées par FastAPI :

* `Header()`
* `Cookie()`
* `Body()`
* `Form()`
* `File()`

Les clés du `dict` identifient chaque exemple, et chaque valeur est un autre `dict`.

Chaque `dict` d'exemple spécifique dans `examples` peut contenir :

* `summary` : une courte description de l'exemple.
* `description` : une description longue qui peut contenir du texte Markdown.
* `value` : c'est l'exemple réel affiché, par ex. un `dict`.

# Middleware { #middleware }

Vous pouvez ajouter des middlewares aux applications **FastAPI**.

Un « middleware » est une fonction qui agit sur chaque **requête** avant qu’elle ne soit traitée par un *chemin d'accès* spécifique. Et aussi sur chaque **réponse** avant son renvoi.

* Il intercepte chaque **requête** qui parvient à votre application.
* Il peut alors faire quelque chose avec cette **requête** ou exécuter tout code nécessaire.

Ainsi, la fonction située en dessous sera exécutée une fois pour chaque combinaison d'arguments. Ensuite, les valeurs renvoyées par chacune de ces combinaisons d'arguments seront réutilisées à chaque fois que la fonction sera appelée avec exactement la même combinaison d'arguments.

Par exemple, si vous avez une fonction :

```TypeScript
ItemsService.createItemItemsPost({name: "Plumbus", price: 5})
```

... c’est parce que le générateur de client utilise l’**operation ID** interne OpenAPI pour chaque *chemin d'accès*.

/// info

Le point important est que votre application pourra produire chaque ligne à son tour, tandis que le client consomme les lignes précédentes.

///

/// note | Détails techniques

Si vous déclarez un `response_class=StreamingResponse` dans votre *fonction de chemin d'accès*, vous pouvez utiliser `yield` pour envoyer chaque bloc de données à son tour.

{* ../../docs_src/stream_data/tutorial001_py310.py ln[1:23] hl[20,23] *}

FastAPI transmettra chaque bloc de données à la `StreamingResponse` tel quel ; il n'essaiera pas de le convertir en JSON ni autre chose similaire.

* Chaque application que vous avez en cours d'exécution sur votre ordinateur a un processus derrière elle, chaque programme lancé, chaque fenêtre, etc. Et il y a normalement de nombreux processus exécutés **en même temps** tant qu'un ordinateur est allumé.

le système de conteneurs distribués avec l'**équilibreur de charge** **distribuera les requêtes** à chacun des conteneurs exécutant votre application **à tour de rôle**. Ainsi, chaque requête pourrait être traitée par l'un des multiples **conteneurs répliqués** exécutant votre application.

Et normalement cet **équilibreur de charge** pourra gérer des requêtes qui vont vers *d'autres* applications dans votre cluster (par ex. vers un autre domaine, ou sous un autre préfixe de chemin d'URL),...